joonsrenderer 1.1-java

data/src/main/java/joons/JRFiller.java

@@ -0,0 +1,79 @@
+package joons;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class JRFiller {
+
+    private final List<Float> vertices;
+    private final List<Integer> triangleIndices;
+    private final List<Float> spheres;
+    private final List<Float> points;
+
+    private final String fillType;
+    public float[] p; //array of parameters
+    public int np = 0; //number of parameters
+
+    public JRFiller(String fillType, float... params) {
+        vertices = new ArrayList<>();
+        triangleIndices = new ArrayList<>();
+        spheres = new ArrayList<>();
+        points = new ArrayList<>();
+
+        this.fillType = fillType;
+        p = params;
+        np = p.length;
+    }
+
+    public String getType() {
+        return fillType;
+    }
+
+    public List<Float> getVertices() {
+        return vertices;
+    }
+
+    private void writeTriangleIndices() {
+        for (int i = 0; i < (vertices.size() / 9); i++) {
+            //vertices/3 = number of 3d points
+            //vertices/9 = number of triangles
+            triangleIndices.add(i * 3);
+            triangleIndices.add(i * 3 + 1);
+            triangleIndices.add(i * 3 + 2);
+        }
+    }
+
+    public float[] verticesToArray() {
+        float[] v = new float[vertices.size()];
+        for (int i = 0; i < vertices.size(); i++) {
+            v[i] = vertices.get(i);
+        }
+        return v;
+    }
+
+    public int[] triangleIndicesToArray() {
+        writeTriangleIndices();
+        int[] t = new int[triangleIndices.size()];
+        for (int i = 0; i < triangleIndices.size(); i++) {
+            t[i] = triangleIndices.get(i);
+        }
+        return t;
+    }
+
+    public void addSphere(float x, float y, float z, float r) {
+        spheres.add(x);
+        spheres.add(y);
+        spheres.add(z);
+        spheres.add(r);
+    }
+
+    public List<Float> getSpheres() {
+        return spheres;
+    }
+
+    public void addPoint(float x, float y, float z) {
+        points.add(x);
+        points.add(y);
+        points.add(z);
+    }
+}

data/src/main/java/joons/JRImagePanel.java

@@ -0,0 +1,141 @@
+package joons;
+
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.image.BufferedImage;
+import javax.swing.JPanel;
+
+import org.sunflow.core.Display;
+import org.sunflow.image.Color;
+
+import processing.core.PImage;
+
+@SuppressWarnings("serial")
+public class JRImagePanel extends JPanel implements Display {
+
+    private static final int[] BORDERS = {Color.RED.toRGB(),
+        Color.GREEN.toRGB(), Color.BLUE.toRGB(), Color.YELLOW.toRGB(),
+        Color.CYAN.toRGB(), Color.MAGENTA.toRGB()};
+    private BufferedImage image;
+    private float xo, yo;
+    private float w, h;
+    private long repaintCounter;
+
+    public JRImagePanel() {
+        setPreferredSize(new Dimension(640, 480));
+        image = null;
+        xo = yo = 0;
+        w = h = 0;
+    }
+
+    @Override
+    public synchronized void imageBegin(int w, int h, int bucketSize) {
+        if (image != null && w == image.getWidth() && h == image.getHeight()) {
+            // dull image if it has same resolution (75%)
+            for (int y = 0; y < h; y++) {
+                for (int x = 0; x < w; x++) {
+                    int rgba = image.getRGB(x, y);
+                    image.setRGB(x, y, ((rgba & 0xFEFEFEFE) >>> 1) + ((rgba & 0xFCFCFCFC) >>> 2));
+                }
+            }
+        } else {
+            // allocate new framebuffer
+            image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
+            // center
+            this.w = w;
+            this.h = h;
+            xo = yo = 0;
+        }
+        repaintCounter = System.nanoTime();
+        repaint();
+    }
+
+    @Override
+    public synchronized void imagePrepare(int x, int y, int w, int h, int id) {
+        int border = BORDERS[id % BORDERS.length] | 0xFF000000;
+        for (int by = 0; by < h; by++) {
+            for (int bx = 0; bx < w; bx++) {
+                if (bx == 0 || bx == w - 1) {
+                    if (5 * by < h || 5 * (h - by - 1) < h) {
+                        image.setRGB(x + bx, y + by, border);
+                    }
+                } else if (by == 0 || by == h - 1) {
+                    if (5 * bx < w || 5 * (w - bx - 1) < w) {
+                        image.setRGB(x + bx, y + by, border);
+                    }
+                }
+            }
+        }
+        repaint();
+    }
+
+    @Override
+    public synchronized void imageUpdate(int x, int y, int w, int h, Color[] data, float[] alpha) {
+        for (int j = 0, index = 0; j < h; j++) {
+            for (int i = 0; i < w; i++, index++) {
+                image.setRGB(x + i, y + j, data[index].copy().mul(1.0f / alpha[index]).toNonLinear().toRGBA(alpha[index]));
+            }
+        }
+        repaint();
+    }
+
+    @Override
+    public synchronized void imageFill(int x, int y, int w, int h, Color c, float alpha) {
+        int rgba = c.copy().mul(1.0f / alpha).toNonLinear().toRGBA(alpha);
+        for (int j = 0; j < h; j++) {
+            for (int i = 0; i < w; i++) {
+                image.setRGB(x + i, y + j, rgba);
+            }
+        }
+        fastRepaint();
+    }
+
+    @Override
+    public void imageEnd() {
+        repaint();
+    }
+
+    private void fastRepaint() {
+        long t = System.nanoTime();
+        if (repaintCounter + 125000000 < t) {
+            repaintCounter = t;
+            repaint();
+        }
+    }
+
+    @Override
+    public synchronized void paintComponent(Graphics g) {
+        super.paintComponent(g);
+        if (image == null) {
+            return;
+        }
+        int x = Math.round(xo + (getWidth() - w) * 0.5f);
+        int y = Math.round(yo + (getHeight() - h) * 0.5f);
+        int iw = Math.round(w);
+        int ih = Math.round(h);
+        int x0 = x - 1;
+        int y0 = y - 1;
+        int x1 = x + iw + 1;
+        int y1 = y + ih + 1;
+        g.setColor(java.awt.Color.WHITE);
+        g.drawLine(x0, y0, x1, y0);
+        g.drawLine(x1, y0, x1, y1);
+        g.drawLine(x1, y1, x0, y1);
+        g.drawLine(x0, y1, x0, y0);
+        g.drawImage(image, x, y, iw, ih, java.awt.Color.BLACK, this);
+    }
+
+    public PImage getInversedImage() {
+        int iw = Math.round(w);
+        int ih = Math.round(h);
+        PImage inversed = new PImage(iw, ih);
+        for (int i = 0; i < ih; i++) {
+            for (int j = 0; j < iw; j++) {
+                //PApplet.println(i);
+                //PApplet.println(j);
+                inversed.pixels[(ih - i - 1) * iw + j] = image.getRGB(j, i);
+            }
+        }
+        return inversed;
+    }
+}

data/src/main/java/joons/JRRecorder.java

@@ -0,0 +1,183 @@
+package joons;
+
+import java.util.ArrayList;
+
+import static joons.JRStatics.*;
+import processing.core.*;
+import processing.opengl.PGraphics3D;
+
+/*
+ * The purpose of JRRecorder is to geometry used in P5 sketch, and reproduce them in sunflow.
+ * Remember, JRRecorder is a secondary PGraphics3D object, and methods are echoed to it by PApplet.
+ * Say, when you call PApplet.method(), PApplet will do something like:
+ * public void method() { primaryPG3D.method(); secondaryPG3D.method(); }
+ */
+public class JRRecorder extends PGraphics3D {
+
+    private boolean writingVertices = false;
+    private ArrayList<Float> tempVertices;
+    private final PApplet app;
+    int kind, vertCount;
+
+    /**
+     *
+     * @param parent
+     */
+    public JRRecorder(final PApplet parent) {
+        //standard construction for a PGraphics object
+        app = parent;
+        setParent(app);
+        setPrimary(false);
+        setSize(app.width, app.height);
+        init();
+        
+    }
+
+    private void init() {
+        initializeFillers(); //emptying out fillers
+        FILLERS_ARE_VALID = true; //true unless proven false		
+        tempVertices = new ArrayList<>(); //emptying out vertices
+        writingVertices = false; //init beginShape()
+    }
+
+    @Override
+    public void beginDraw() {
+        //this method is echoed before every draw() loop.
+        init();
+    }
+
+    @Override
+    public void endDraw() {
+        //We need this empty override.
+    }
+
+    @Override
+    public void perspective(float fov, float aspect, float zNear, float zFar) {
+        //zNear and zFar are unused in sunflow.
+        FOV = fov;
+        ASPECT = aspect;
+    }
+
+    @Override
+    public void beginShape() {
+        PApplet.println("Joons-Renderer: Please use beginShape(TRIANGLES) or beginShape(QUADS).");
+        PApplet.println("Joons-Renderer: Your vertices will be rendered using beginShape(TRIANGLES).");
+        beginShape(PConstants.TRIANGLES);
+    }
+
+    @Override
+    public void beginShape(int kind) {
+        this.kind = kind;
+        writingVertices = true;
+        vertCount = 0;
+    }
+
+    @Override
+    public void vertex(float x, float y, float z) {
+        if (writingVertices) {
+            vertCount++;
+            tempVertices.add(x);
+            tempVertices.add(y);
+            tempVertices.add(z);
+
+            if (kind == PConstants.QUADS && vertCount == 4) {
+                //if more than 1 quad, simply start a new one.
+                endShape();
+                beginShape(PConstants.QUADS);
+            }
+        }
+    }
+
+    @Override
+    public void endShape() {
+        if (kind == PConstants.QUADS && vertCount == 4) {
+            //adding vertices to make two triangles from four points
+            //abcd -> abc dac
+            tempVertices.add(tempVertices.get(0));//ax
+            tempVertices.add(tempVertices.get(1));//ay
+            tempVertices.add(tempVertices.get(2));//az
+            tempVertices.add(tempVertices.get(6));//cx
+            tempVertices.add(tempVertices.get(7));//cy
+            tempVertices.add(tempVertices.get(8));//cz
+        }
+        //divide by 3, because 3 numbers make 1 point.
+        for (int i = 0; i < tempVertices.size() / 3; i++) { 
+            float[] tCoord = applyTransform(
+                    app, 
+                    tempVertices.get(i * 3),
+                    tempVertices.get(i * 3 + 1),
+                    tempVertices.get(i * 3 + 2)
+            );
+            getCurrentFiller().getVertices().add(tCoord[0]);
+            getCurrentFiller().getVertices().add(tCoord[1]);
+            getCurrentFiller().getVertices().add(tCoord[2]);
+        }
+        writingVertices = false;
+        vertCount = 0;
+        tempVertices = new ArrayList<>(); //emptying out vertices
+    }
+
+    //implementations of 3D primitives	
+    @Override
+    public void box(float d) {
+        box(d, d, d);
+    }
+
+    @Override
+    public void box(float width, float height, float depth) {
+        float w = width / 2;
+        float h = height / 2;
+        float d = depth / 2;
+
+        beginShape(PConstants.QUADS);// top
+        vertex(w, h, d);
+        vertex(-w, h, d);
+        vertex(-w, -h, d);
+        vertex(w, -h, d);
+        endShape();
+
+        beginShape(PConstants.QUADS);// +x side
+        vertex(w, h, d);
+        vertex(w, -h, d);
+        vertex(w, -h, -d);
+        vertex(w, h, -d);
+        endShape();
+
+        beginShape(PConstants.QUADS);// -x side
+        vertex(-w, h, -d);
+        vertex(-w, -h, -d);
+        vertex(-w, -h, d);
+        vertex(-w, h, d);
+        endShape();
+
+        beginShape(PConstants.QUADS);// +y side
+        vertex(w, h, d);
+        vertex(w, h, -d);
+        vertex(-w, h, -d);
+        vertex(-w, h, d);
+        endShape();
+
+        beginShape(PConstants.QUADS);// -y side
+        vertex(-w, -h, d);
+        vertex(-w, -h, -d);
+        vertex(w, -h, -d);
+        vertex(w, -h, d);
+        endShape();
+
+        beginShape(PConstants.QUADS);// bottom
+        vertex(-w, h, -d);
+        vertex(w, h, -d);
+        vertex(w, -h, -d);
+        vertex(-w, -h, -d);
+        endShape();
+    }
+
+    @Override
+    public void sphere(float r) {
+        //Sunflow seems to offer an optimized render for a perfect sphere,
+        //meaning no triangle polygonal mess from Processing
+        float[] sph = applyTransform(app, 0, 0, 0);
+        getCurrentFiller().addSphere(sph[0], sph[1], sph[2], r);
+    }
+
+}

data/src/main/java/joons/JRStatics.java

@@ -0,0 +1,199 @@
+package joons;
+
+import java.util.ArrayList;
+import java.util.List;
+import processing.core.PApplet;
+import processing.core.PImage;
+import processing.core.PMatrix3D;
+
+public final class JRStatics {
+  //This class contains all the shared variables and constants,
+  //and also the default values for them.
+
+  //sys constants
+  public static final String JR_VERSION = "v1.02";
+  public static final String UNRENDERED_FILE_NAME = "captured.png";
+  public static final String RENDERED_INV_FILE_NAME = "rendered.png";
+
+  //sys variables, default unless modified
+  // public static PApplet app;
+  public static float FOV, ASPECT;
+  public static PImage IMG_RENDERED;
+  public static List<JRFiller> fillers;
+  public static boolean FILLERS_ARE_VALID;
+  public static boolean CORNELL_BOX_IS_CALLED = false;
+  public static boolean GI_IS_CALLED = false;
+  public static boolean GI_AMB_OCC_IS_CALLED = false;
+
+  //user interface keys
+  public static final String IPR = "ipr";
+  public static final String BUCKET = "bucket";
+  public static final String SRGB_NONLINEAR = "sRGB nonlinear";
+  public static final String GI_AMB_OCC = "gi_ambient_occlusion"; // "ambocc" is the proper sunflow parameter.
+  public static final String GI_INSTANT = "gi_instant"; //"igi" is the proper sunflow parameter.
+  public static final String CORNELL_BOX = "cornell_box";
+  public static final String CONSTANT = "constant";
+  public static final String DIFFUSE = "diffuse";
+  public static final String SHINY = "shiny"; //"shiny_diffuse" is the proper sunflow parameter.
+  public static final String MIRROR = "mirror";
+  public static final String GLASS = "glass";
+  public static final String PHONG = "phong";
+  public static final String AMBIENT_OCCLUSION = "ambient_occlusion";
+  public static final String LIGHT = "light";
+  public static final String SUNSKY = "sunsky"; // Sunsky lighting
+
+  //sunflow image settings variables, default unless modified
+  public static double SIZE_MULTIPLIER = 1;
+  public static String SAMPLER = BUCKET;
+  public static int AA_MIN = -2;
+  public static int AA_MAX = 0;
+  public static int AA_SAMPLES = 1;
+  public static int CAUSTICS_EMIT = 1000000;
+  public static int CAUSTICS_GATHER = 100;
+  public static float CAUSTICS_RADIUS = 0.5f;
+  public static int TRACE_DEPTH_DIFF = 2;
+  public static int TRACE_DEPTH_REFL = 4;
+  public static int TRACE_DEPTH_REFR = 4;
+  public static float FOCAL_DISTANCE = -1; //uninitialized -1
+  public static float LENS_RADIUS = 1f;
+
+  //sunflow GI instant variables
+  public static int GI_INSTANT_SAMPLES = 16;
+  public static int GI_INSTANT_SETS = 1;
+  public static float GI_INSTANT_C = 0.00003f;
+  public static int GI_INSTANT_BIAS_SAMPLES = 0;
+
+  //sunflow GI ambient occlusion variables
+  public static float GI_AMB_OCC_BRIGHT_R = 0.5f;
+  public static float GI_AMB_OCC_BRIGHT_G = 0.5f;
+  public static float GI_AMB_OCC_BRIGHT_B = 0.5f;
+  public static float GI_AMB_OCC_DARK_R = 0;
+  public static float GI_AMB_OCC_DARK_G = 0;
+  public static float GI_AMB_OCC_DARK_B = 0;
+  public static float GI_AMB_OCC_MAX_DIST = 100;
+  public static int GI_AMB_OCC_SAMPLES = 32;
+
+  //background primitive variables
+  public static float BG_R = 0.7f;
+  public static float BG_G = 0.7f;
+  public static float BG_B = 0.7f;
+
+  //final default values
+  public static final float DEF_RADIANCE = 5;
+  public static final float DEF_RGB = 255;
+  public static final float DEF_GLASS_ALPHA = 150;
+  public static final int DEF_SAMPLES = 16;
+  public static final float DEF_CORB_RADIANCE = 20;
+  public static final float DEF_CORB_COLOR_1 = 220;
+  public static final float DEF_CORB_COLOR_2 = 130;
+  public static final float DEF_AMB_OCC_MAX_DIST = 50;
+
+  // Default values for Sunsky lighting.
+  public static final float[] DEF_SUNSKY_UP = {0, -1, 0};
+  public static final float[] DEF_SUNSKY_EAST = {1, 0, 0};
+  public static final float[] DEF_SUNSKY_DIR = {-0.5f, -0.6f, 0.5f};
+  public static final int DEF_SUNSKY_SAMPLES = 128;
+  public static final float DEF_SUNSKY_TURBIDITY = 6.0f;
+
+  //static methods
+  public static JRFiller getCurrentFiller(){
+    return fillers.get(fillers.size() - 1);
+  }
+
+  public static void initializeFillers(){
+    fillers = new ArrayList<>();
+    //Default shader that kicks in when no shader has been declared.
+    fillers.add(new JRFiller(DIFFUSE, DEF_RGB, DEF_RGB, DEF_RGB));
+  }
+
+  public static float[] applyTransform(PApplet app, float x, float y, float z){
+    PMatrix3D tr = (PMatrix3D)app.getMatrix();
+    float tx = x * tr.m00 + y * tr.m01 + z * tr.m02 + tr.m03;
+    float ty = x * tr.m10 + y * tr.m11 + z * tr.m12 + tr.m13;
+    float tz = x * tr.m20 + y * tr.m21 + z * tr.m22 + tr.m23;
+    return new float[]{tx, ty, tz};
+  }
+
+  //error message strings
+  public static final String JR_VERSION_PRINT
+  = "Joons-Renderer : " + JR_VERSION + ".";
+
+  public static final String IMAGE_SAMPLER_ERROR
+  = "Joons-Renderer : ERROR, Unknown sampler type. Use either \"ipr\" or \"bucket\" with setSampler() in setup().";
+
+  public static final String IMAGE_AA_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, aaMax must be equal to or greater than aaMin."
+  , "Joons-Renderer : Use setAA(int aaMin, int aaMax), or"
+  , "Joons-Renderer :     setAA(int aaMin, int aaMax, int aaSamples)."
+  );
+
+  public static final String GI_INSTANT_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, background type \"gi_instant\" must have 0 or 4 parameters."
+  , "Joons-Renderer : int samples, int sets, float b, float biasSamples."
+  );
+
+  public static final String GI_AMB_OCC_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, background type \"gi_ambient_occlusion\" must have 0 or 8 parameters."
+  , "Joons-Renderer : float bright R, G, B, dark R, G, B, float maxDistance, int samples."
+  );
+
+  public static final String FILLER_UNKOWN_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, Unknown fill type."
+  , "Joons-Renderer : Choose from \"constant\", \"diffuse\", \"shiny\", \"mirror\", \"glass\", \"phong\","
+  , "Joons-Renderer : \"ambient_occlusion\" and \"light\"."
+  );
+
+  public static final String FILLER_LIGHT_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"light\" must have 0, 3 or 4 parameters."
+  , "Joons-Renderer : float radiance R, G, B, (3 params)"
+  , "Joons-Renderer : int samples. (4 params)"
+  );
+
+  public static final String FILLER_CONSTANT_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"constant\" must have 0 or 3 parameters."
+  , "Joons-Renderer : float R, G, B."
+  );
+
+  public static final String FILLER_DIFFUSE_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"diffuse\" must have 0 or 3 parameters."
+  , "Joons-Renderer : float R, G, B."
+  );
+
+  public static final String FILLER_SHINY_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"shiny\" must have 0, 3 or 4 parameters."
+  , "Joons-Renderer : float R, G, B, (3 params);,"
+  , "Joons-Renderer : float shininess. (4 params)"
+  );
+
+  public static final String FILLER_MIRROR_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"mirror\" must have 0 or 3 parameters."
+  , "Joons-Renderer : float R, G, B."
+  );
+
+  public static final String FILLER_GLASS_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"glass\" must have 0, 3, 4 or 8 parameters."
+  , "Joons-Renderer : float R, G, B, (3 params);,"
+  , "Joons-Renderer : float indexOfRefraction, (4 params);,"
+  , "Joons-Renderer : float absorptionDistance, float absorption R, G, B. (8 params)"
+  );
+
+  public static final String FILLER_PHONG_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"phong\" must have 0, 3, 6 or 8 parameters."
+  , "Joons-Renderer : float diffuse R, G, B, (3 params);,"
+  , "Joons-Renderer : float specular R, G, B, (6 params);,"
+  , "Joons-Renderer : float specularityHardness, float reflectionBluriness. (8 params)"
+  );
+
+  public static final String FILLER_AMB_OCC_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, fill type \"ambient_occlusion\" must have 0, 3 or 8 parameters."
+  , "Joons-Renderer : float bright R, G, B, (3 params);,"
+  , "Joons-Renderer : float dark R, G, B, float maxDistance, int samples. (8 params)"
+  );
+
+  public static final String CORNELL_BOX_ERROR = String.join("\n"
+  , "Joons-Renderer : ERROR, background type \"cornell_box\" must have 3, 7 or 22 parameters."
+  , "Joons-Renderer : float width, height, depth, (3 params);,"
+  , "Joons-Renderer : float radiance R, G, B, int samples, (7 params);,"
+  , "Joons-Renderer : float left R, G, B, right R, G, B, back R, G, B, top R, G, B, bottom R, G, B. (21 params)"
+  );
+}