Setup framework

Co-authored-by: sigonasr2 <sigonasr2@gmail.com>
main
sigonasr2 2 years ago
parent b75aa0aba0
commit b1cade73f4
  1. BIN
      bin/test.png
  2. 36
      src/sig/JavaProjectTemplate.java
  3. 38
      src/sig/engine/Color.java
  4. 33
      src/sig/engine/Edge.java
  5. 314
      src/sig/engine/Panel.java
  6. 32
      src/sig/engine/Point.java
  7. 2
      utils/md5

Binary file not shown.

After

Width:  |  Height:  |  Size: 446 KiB

@ -1,21 +1,29 @@
package sig;
import javax.swing.JFrame;
import sig.engine.Panel;
import java.awt.AWTException;
import java.awt.Robot;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import java.awt.Rectangle;
public class JavaProjectTemplate {
public static final String PROGRAM_NAME="Sig's Java Project Template";
public static void main(String[] args) {
JFrame f = new JFrame(PROGRAM_NAME);
Panel p = new Panel(f);
p.init();
f.add(p);
f.setSize(1280,720);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
p.render();
try {
Robot r = new Robot();
System.out.println("Waiting 5 seconds before starting...");
final Rectangle capture = new Rectangle(312,118,1352,889);
Thread.sleep(5000);
//312,118 1352,889
ImageIO.write(r.createScreenCapture(capture),"png",new File("test.png"));
} catch (AWTException | IOException | InterruptedException e) {
e.printStackTrace();
}
}
}

@ -1,38 +0,0 @@
package sig.engine;
public class Color {
int r,g,b,a;
final static public Color BLACK = new Color(0,0,0);
final static public Color RED = new Color(204,0,0);
final static public Color GREEN = new Color(78,154,6);
final static public Color YELLOW = new Color(196,160,0);
final static public Color BLUE = new Color(114,159,207);
final static public Color MAGENTA = new Color(117,80,123);
final static public Color CYAN = new Color(6,152,154);
final static public Color WHITE = new Color(211,215,207);
final static public Color BRIGHT_BLACK = new Color(85,87,83);
final static public Color BRIGHT_RED = new Color(239,41,41);
final static public Color BRIGHT_GREEN = new Color(138,226,52);
final static public Color BRIGHT_YELLOW = new Color(252,233,79);
final static public Color BRIGHT_BLUE = new Color(50,175,255);
final static public Color BRIGHT_MAGENTA = new Color(173,127,168);
final static public Color BRIGHT_CYAN = new Color(52,226,226);
final static public Color BRIGHT_WHITE = new Color(255,255,255);
public Color(int r, int g, int b) {
this(r,g,b,255);
}
public Color(int r, int g, int b,int a) {
super();
this.r = r;
this.g = g;
this.b = b;
this.a = a;
}
public int getColor() {
return (a<<24)+(r<<16)+(g<<8)+b;
}
}

@ -1,33 +0,0 @@
package sig.engine;
public class Edge {
Point a,b;
int min_y;
int max_y;
int min_x;
int max_x;
double x_of_min_y;
double inverse_slope;
public Edge(Point a, Point b) {
super();
this.a = a;
this.b = b;
min_y=Math.min(a.y, b.y);
max_y=Math.max(a.y, b.y);
min_x=Math.min(a.x, b.x);
max_x=Math.max(a.x, b.x);
if (a.y==min_y) {
x_of_min_y=a.x;
} else {
x_of_min_y=b.x;
}
inverse_slope=(double)(a.x-b.x)/(a.y-b.y);
}
@Override
public String toString() {
return "Edge [a=" + a + ", b=" + b + ", min_y=" + min_y + ", max_y=" + max_y + ", min_x=" + min_x + ", max_x="
+ max_x + ", x_of_min_y=" + x_of_min_y + ", inverse_slope=" + inverse_slope + "]";
}
}

@ -1,314 +0,0 @@
package sig.engine;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.image.ColorModel;
import java.awt.image.MemoryImageSource;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JFrame;
import javax.swing.JPanel;
import sig.JavaProjectTemplate;
public class Panel extends JPanel implements Runnable {
JFrame window;
public int pixel[];
public int width=1280;
public int height=720;
final int CIRCLE_PRECISION=32;
final int OUTLINE_COL=Color.BRIGHT_WHITE.getColor();
private Thread thread;
private Image imageBuffer;
private MemoryImageSource mImageProducer;
private ColorModel cm;
int scanLine=0;
int nextScanLine=0;
double x_offset=0;
double y_offset=0;
int frameCount=0;
long lastSecond=0;
int lastFrameCount=0;
public Panel(JFrame f) {
super(true);
this.window=f;
thread = new Thread(this, "MyPanel Thread");
}
/**
* Get Best Color model available for current screen.
* @return color model
*/
protected static ColorModel getCompatibleColorModel(){
GraphicsConfiguration gfx_config = GraphicsEnvironment.
getLocalGraphicsEnvironment().getDefaultScreenDevice().
getDefaultConfiguration();
return gfx_config.getColorModel();
}
/**
* Call it after been visible and after resizes.
*/
public void init(){
cm = getCompatibleColorModel();
int screenSize = width * height;
if(pixel == null || pixel.length < screenSize){
pixel = new int[screenSize];
}
if(thread.isInterrupted() || !thread.isAlive()){
thread.start();
}
mImageProducer = new MemoryImageSource(width, height, cm, pixel,0, width);
mImageProducer.setAnimated(true);
mImageProducer.setFullBufferUpdates(true);
imageBuffer = Toolkit.getDefaultToolkit().createImage(mImageProducer);
}
@Override
public void paintComponent(Graphics g) {
super.paintComponent(g);
// perform draws on pixels
render();
// ask ImageProducer to update image
mImageProducer.newPixels();
// draw it on panel
g.drawImage(this.imageBuffer, 0, 0, this);
if (window!=null&&System.currentTimeMillis()-lastSecond>=1000) {
window.setTitle(JavaProjectTemplate.PROGRAM_NAME+" - FPS: "+(frameCount-lastFrameCount));
lastFrameCount=frameCount;
lastSecond=System.currentTimeMillis();
}
frameCount++;
}
/**
* Overrides ImageObserver.imageUpdate.
* Always return true, assuming that imageBuffer is ready to go when called
*/
@Override
public boolean imageUpdate(Image image, int a, int b, int c, int d, int e) {
return true;
}
/**
* Do your draws in here !!
* pixel is your canvas!
*/
public /* abstract */ void render(){
int[] p = pixel; // this avoid crash when resizing
//a=h/w
for (int x=0;x<width;x++) {
for (int y=0;y<height;y++) {
p[y*width+x]=(0<<16)+(0<<8)+0;
}
}
x_offset+=1;
y_offset=50;
FillPolygon(p,Color.WHITE,50,50,new Point[] {
new Point(135,2),
new Point(166,96),
new Point(265,97),
new Point(185,156),
new Point(215,251),
new Point(134,192),
new Point(54,251),
new Point(84,156),
new Point(4,97),
new Point(103,96),
});
FillPolygon(p,Color.BRIGHT_CYAN,x_offset,y_offset,new Point[] {
new Point(28,29),
new Point(78,103),
new Point(120,31),
new Point(123,221),
new Point(30,218),
});
//FillRect(p,Color.BRIGHT_RED,200,200,600,64);
final Color testAlpha = new Color(150,0,0,128);
FillCircle(p,testAlpha,150,150,100);
FillOval(p,Color.BRIGHT_GREEN,300,150,100,50);
}
public void FillRect(int[] p,Color col,double x,double y,double w,double h) {
for (int xx=0;xx<w;xx++) {
for (int yy=0;yy<h;yy++) {
int index = ((int)y+yy)*width+(int)x+xx;
p[index]=col.getColor();
}
}
}
public void FillCircle(int[] p,Color col,double center_x,double center_y,double r) {
int counter=0;
Point[] points = new Point[CIRCLE_PRECISION];
for (double theta=0;theta<Math.PI*2;theta+=((Math.PI*2)/CIRCLE_PRECISION)) {
//System.out.println("Loop "+counter+++". Theta:"+theta);
//System.out.println("X:"+(Math.sin(theta)*r+center_x)+" Y:"+(Math.cos(theta)*r+center_y));
points[counter++]=new Point((int)(Math.round(Math.sin(theta)*r+center_x)),(int)(Math.round(Math.cos(theta)*r+center_y)));
}
FillPolygon(p,col,0,0,points);
}
public void FillOval(int[] p,Color col,double center_x,double center_y,double w,double h) {
int counter=0;
Point[] points = new Point[CIRCLE_PRECISION];
double r = Math.max(w,h);
double ratio = Math.min(w,h)/r;
for (double theta=0;theta<Math.PI*2;theta+=((Math.PI*2)/CIRCLE_PRECISION)) {
//System.out.println("Loop "+counter+++". Theta:"+theta);
//System.out.println("X:"+(Math.sin(theta)*r+center_x)+" Y:"+(Math.cos(theta)*r+center_y));
Point newP = new Point((int)(Math.round(Math.sin(theta)*r)),(int)(Math.round(Math.cos(theta)*r)));
if (w<h) {
newP.x=(int)Math.round(newP.x*ratio);
} else {
newP.y=(int)Math.round(newP.y*ratio);
}
newP.x+=center_x;
newP.y+=center_y;
points[counter++]=newP;
}
FillPolygon(p,col,0,0,points);
}
public void FillPolygon(int[] p,Color col,double x_offset,double y_offset,Point...points) {
Edge[] edges = new Edge[points.length];
List<Edge> edges_sorted = new ArrayList<Edge>();
for (int i=0;i<points.length;i++) {
edges[i] = new Edge(points[i],points[(i+1)%points.length]);
if (!Double.isInfinite(edges[i].inverse_slope)) {
if (edges_sorted.size()==0) {
edges_sorted.add(edges[i]);
} else {
boolean inserted=false;
for (int j=0;j<edges_sorted.size();j++) {
Edge e2 = edges_sorted.get(j);
if (e2.min_y>=edges[i].min_y) {
edges_sorted.add(j,edges[i]);
inserted=true;
break;
}
}
if (!inserted) {
edges_sorted.add(edges[i]);
}
}
}
}
//System.out.println(edges_sorted);
List<Edge> active_edges = new ArrayList<Edge>();
scanLine = edges_sorted.get(0).min_y-1;
nextScanLine = scanLine+1;
do {
for (int i=0;i<active_edges.size();i+=2) {
Edge e1 = active_edges.get(i);
Edge e2 = active_edges.get(i+1);
//System.out.println("Drawing from "+((int)Math.round(e1.x_of_min_y))+" to "+e2.x_of_min_y+" on line "+scanLine);
for (int x=(int)Math.round(e1.x_of_min_y);x<=e2.x_of_min_y;x++) {
int index = (scanLine+(int)y_offset)*width+x+(int)x_offset;
if (index<p.length&&index>=0) {
Draw(p,index,col.getColor());
}
}
}
List<Edge> new_active_edges = new ArrayList<Edge>();
for (int i=0;i<active_edges.size();i++) {
Edge e = active_edges.get(i);
if (e.max_y==scanLine+1) {
active_edges.remove(i--);
} else {
e.x_of_min_y+=e.inverse_slope;
}
}
scanLine++;
for (int i=0;i<active_edges.size();i++) {
Edge e = active_edges.get(i);
boolean inserted=false;
for (int j=0;j<new_active_edges.size();j++) {
Edge e2 = new_active_edges.get(j);
if (e2.x_of_min_y>e.x_of_min_y) {
new_active_edges.add(j,e);
inserted=true;
break;
}
}
if (!inserted) {
new_active_edges.add(e);
}
}
active_edges=new_active_edges;
GetNextScanLineEdges(edges_sorted, active_edges);
}
while (active_edges.size()>0);
}
private void GetNextScanLineEdges(List<Edge> edges_sorted, List<Edge> active_edges) {
if (scanLine==nextScanLine) {
for (int i=0;i<edges_sorted.size();i++) {
Edge e = edges_sorted.get(i);
if (e.min_y==scanLine) {
e = edges_sorted.remove(i--);
boolean inserted=false;
for (int j=0;j<active_edges.size();j++) {
if (e.x_of_min_y<active_edges.get(j).x_of_min_y) {
active_edges.add(j,e);
inserted=true;
break;
}
}
if (!inserted) {
active_edges.add(e);
}
} else
if (e.min_y>scanLine) {
nextScanLine=e.min_y;
break;
}
}
}
}
public void Draw(int[] canvas,int index, int col) {
int alpha = col>>>24;
if (alpha==0) {
return;}
else
if (alpha==255) {
canvas[index]=col;
} else {
float ratio=alpha/255f;
int prev_col=canvas[index];
int prev_r=(prev_col&0xFF);
int prev_g=(prev_col&0xFF00)>>>8;
int prev_b=(prev_col&0xFF0000)>>>16;
int r=(col&0xFF);
int g=(col&0xFF00)>>>8;
int b=(col&0xFF0000)>>>16;
int new_r=(int)(ratio*r+(1-ratio)*prev_r);
int new_g=(int)(ratio*g+(1-ratio)*prev_g);
int new_b=(int)(ratio*b+(1-ratio)*prev_b);
canvas[index]=new_r+(new_g<<8)+(new_b<<16)+(col&0xFF000000);
}
}
@Override
public void run() {
while (true) {
// request a JPanel re-drawing
repaint();
//System.out.println("Repaint "+frameCount++);
//try {Thread.sleep(1);} catch (InterruptedException e) {}
}
}
}

@ -1,32 +0,0 @@
package sig.engine;
public class Point {
int x,y;
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String toString() {
return "Point(" + x + "," + y + ")";
}
}

@ -1,4 +1,4 @@
define.sh:3ecab0dffe2adfb950f3eb7c7061b750 -
main.sh:4e6e9f0650ec790ce2c4364db94f0caa -
search.sh:81d08f5ff48e8a44b5f68387d426da05 -
search.sh:30e1842e9a13452ea883bb6516d28e1c -
.updateDirectories:fa5e95db12be22ae8aed7ecbc560e38c -

Loading…
Cancel
Save