joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/bucket/InvertedBucketOrder.java

@@ -0,0 +1,28 @@
+package org.sunflow.core.bucket;
+
+import org.sunflow.core.BucketOrder;
+
+public class InvertedBucketOrder implements BucketOrder {
+
+    private BucketOrder order;
+
+    public InvertedBucketOrder(BucketOrder order) {
+        this.order = order;
+    }
+
+    @Override
+    public int[] getBucketSequence(int nbw, int nbh) {
+        int[] coords = order.getBucketSequence(nbw, nbh);
+        for (int i = 0; i < coords.length / 2; i += 2) {
+            int src = i;
+            int dst = coords.length - 2 - i;
+            int tmp = coords[src + 0];
+            coords[src + 0] = coords[dst + 0];
+            coords[dst + 0] = tmp;
+            tmp = coords[src + 1];
+            coords[src + 1] = coords[dst + 1];
+            coords[dst + 1] = tmp;
+        }
+        return coords;
+    }
+}

data/src/main/java/org/sunflow/core/bucket/RandomBucketOrder.java

@@ -0,0 +1,49 @@
+package org.sunflow.core.bucket;
+
+import org.sunflow.core.BucketOrder;
+
+public class RandomBucketOrder implements BucketOrder {
+
+    @Override
+    public int[] getBucketSequence(int nbw, int nbh) {
+        int[] coords = new int[2 * nbw * nbh];
+        for (int i = 0; i < nbw * nbh; i++) {
+            int by = i / nbw;
+            int bx = i % nbw;
+            if ((by & 1) == 1) {
+                bx = nbw - 1 - bx;
+            }
+            coords[2 * i + 0] = bx;
+            coords[2 * i + 1] = by;
+        }
+
+        long seed = 2463534242L;
+        for (int i = 0; i < coords.length; i++) {
+            // pick 2 random indices
+            seed = xorshift(seed);
+            int src = mod((int) seed, nbw * nbh);
+            seed = xorshift(seed);
+            int dst = mod((int) seed, nbw * nbh);
+            int tmp = coords[2 * src + 0];
+            coords[2 * src + 0] = coords[2 * dst + 0];
+            coords[2 * dst + 0] = tmp;
+            tmp = coords[2 * src + 1];
+            coords[2 * src + 1] = coords[2 * dst + 1];
+            coords[2 * dst + 1] = tmp;
+        }
+
+        return coords;
+    }
+
+    private int mod(int a, int b) {
+        int m = a % b;
+        return (m < 0) ? m + b : m;
+    }
+
+    private long xorshift(long y) {
+        y = y ^ (y << 13);
+        y = y ^ (y >>> 17); // unsigned
+        y = y ^ (y << 5);
+        return y;
+    }
+}

data/src/main/java/org/sunflow/core/bucket/RowBucketOrder.java

@@ -0,0 +1,21 @@
+package org.sunflow.core.bucket;
+
+import org.sunflow.core.BucketOrder;
+
+public class RowBucketOrder implements BucketOrder {
+
+    @Override
+    public int[] getBucketSequence(int nbw, int nbh) {
+        int[] coords = new int[2 * nbw * nbh];
+        for (int i = 0; i < nbw * nbh; i++) {
+            int by = i / nbw;
+            int bx = i % nbw;
+            if ((by & 1) == 1) {
+                bx = nbw - 1 - bx;
+            }
+            coords[2 * i + 0] = bx;
+            coords[2 * i + 1] = by;
+        }
+        return coords;
+    }
+}

data/src/main/java/org/sunflow/core/bucket/SpiralBucketOrder.java

@@ -0,0 +1,43 @@
+package org.sunflow.core.bucket;
+
+import org.sunflow.core.BucketOrder;
+
+public class SpiralBucketOrder implements BucketOrder {
+
+    @Override
+    public int[] getBucketSequence(int nbw, int nbh) {
+        int[] coords = new int[2 * nbw * nbh];
+        for (int i = 0; i < nbw * nbh; i++) {
+            int bx, by;
+            int center = (Math.min(nbw, nbh) - 1) / 2;
+            int nx = nbw;
+            int ny = nbh;
+            while (i < (nx * ny)) {
+                nx--;
+                ny--;
+            }
+            int nxny = nx * ny;
+            int minnxny = Math.min(nx, ny);
+            if ((minnxny & 1) == 1) {
+                if (i <= (nxny + ny)) {
+                    bx = nx - minnxny / 2;
+                    by = -minnxny / 2 + i - nxny;
+                } else {
+                    bx = nx - minnxny / 2 - (i - (nxny + ny));
+                    by = ny - minnxny / 2;
+                }
+            } else {
+                if (i <= (nxny + ny)) {
+                    bx = -minnxny / 2;
+                    by = ny - minnxny / 2 - (i - nxny);
+                } else {
+                    bx = -minnxny / 2 + (i - (nxny + ny));
+                    by = -minnxny / 2;
+                }
+            }
+            coords[2 * i + 0] = bx + center;
+            coords[2 * i + 1] = by + center;
+        }
+        return coords;
+    }
+}

data/src/main/java/org/sunflow/core/camera/FisheyeLens.java

@@ -0,0 +1,25 @@
+package org.sunflow.core.camera;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.CameraLens;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+
+public class FisheyeLens implements CameraLens {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Ray getRay(float x, float y, int imageWidth, int imageHeight, double lensX, double lensY, double time) {
+        float cx = 2.0f * x / imageWidth - 1.0f;
+        float cy = 2.0f * y / imageHeight - 1.0f;
+        float r2 = cx * cx + cy * cy;
+        if (r2 > 1) {
+            return null; // outside the fisheye
+        }
+        return new Ray(0, 0, 0, cx, cy, (float) -Math.sqrt(1 - r2));
+    }
+}

data/src/main/java/org/sunflow/core/camera/PinholeLens.java

@@ -0,0 +1,43 @@
+package org.sunflow.core.camera;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.CameraLens;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+
+public class PinholeLens implements CameraLens {
+
+    private float au, av;
+    private float aspect, fov;
+    private float shiftX, shiftY;
+
+    public PinholeLens() {
+        fov = 90;
+        aspect = 1;
+        shiftX = shiftY = 0;
+        update();
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        // get parameters
+        fov = pl.getFloat("fov", fov);
+        aspect = pl.getFloat("aspect", aspect);
+        shiftX = pl.getFloat("shift.x", shiftX);
+        shiftY = pl.getFloat("shift.y", shiftY);
+        update();
+        return true;
+    }
+
+    private void update() {
+        au = (float) Math.tan(Math.toRadians(fov * 0.5f));
+        av = au / aspect;
+    }
+
+    @Override
+    public Ray getRay(float x, float y, int imageWidth, int imageHeight, double lensX, double lensY, double time) {
+        float du = shiftX - au + ((2.0f * au * x) / (imageWidth - 1.0f));
+        float dv = shiftY - av + ((2.0f * av * y) / (imageHeight - 1.0f));
+        return new Ray(0, 0, 0, du, dv, -1);
+    }
+}

data/src/main/java/org/sunflow/core/camera/SphericalLens.java

@@ -0,0 +1,22 @@
+package org.sunflow.core.camera;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.CameraLens;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+
+public class SphericalLens implements CameraLens {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Ray getRay(float x, float y, int imageWidth, int imageHeight, double lensX, double lensY, double time) {
+        // Generate environment camera ray direction
+        double theta = 2 * Math.PI * x / imageWidth + Math.PI / 2;
+        double phi = Math.PI * (imageHeight - 1 - y) / imageHeight;
+        return new Ray(0, 0, 0, (float) (Math.cos(theta) * Math.sin(phi)), (float) (Math.cos(phi)), (float) (Math.sin(theta) * Math.sin(phi)));
+    }
+}

data/src/main/java/org/sunflow/core/camera/ThinLens.java

@@ -0,0 +1,107 @@
+package org.sunflow.core.camera;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.CameraLens;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+
+public class ThinLens implements CameraLens {
+
+    private float au, av;
+    private float aspect, fov;
+    private float shiftX, shiftY;
+    private float focusDistance;
+    private float lensRadius;
+    private int lensSides;
+    private float lensRotation;
+    private float lensRotationRadians;
+
+    public ThinLens() {
+        focusDistance = 1;
+        lensRadius = 0;
+        fov = 90;
+        aspect = 1;
+        lensSides = 0; // < 3 means use circular lens
+        lensRotation = lensRotationRadians = 0; // this rotates polygonal lenses
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        // get parameters
+        fov = pl.getFloat("fov", fov);
+        aspect = pl.getFloat("aspect", aspect);
+        shiftX = pl.getFloat("shift.x", shiftX);
+        shiftY = pl.getFloat("shift.y", shiftY);
+        focusDistance = pl.getFloat("focus.distance", focusDistance);
+        lensRadius = pl.getFloat("lens.radius", lensRadius);
+        lensSides = pl.getInt("lens.sides", lensSides);
+        lensRotation = pl.getFloat("lens.rotation", lensRotation);
+        update();
+        return true;
+    }
+
+    private void update() {
+        au = (float) Math.tan(Math.toRadians(fov * 0.5f)) * focusDistance;
+        av = au / aspect;
+        lensRotationRadians = (float) Math.toRadians(lensRotation);
+    }
+
+    @Override
+    public Ray getRay(float x, float y, int imageWidth, int imageHeight, double lensX, double lensY, double time) {
+        float du = shiftX * focusDistance - au + ((2.0f * au * x) / (imageWidth - 1.0f));
+        float dv = shiftY * focusDistance - av + ((2.0f * av * y) / (imageHeight - 1.0f));
+
+        float eyeX, eyeY;
+        if (lensSides < 3) {
+            double angle, r;
+            // concentric map sampling
+            double r1 = 2 * lensX - 1;
+            double r2 = 2 * lensY - 1;
+            if (r1 > -r2) {
+                if (r1 > r2) {
+                    r = r1;
+                    angle = 0.25 * Math.PI * r2 / r1;
+                } else {
+                    r = r2;
+                    angle = 0.25 * Math.PI * (2 - r1 / r2);
+                }
+            } else {
+                if (r1 < r2) {
+                    r = -r1;
+                    angle = 0.25 * Math.PI * (4 + r2 / r1);
+                } else {
+                    r = -r2;
+                    if (r2 != 0) {
+                        angle = 0.25 * Math.PI * (6 - r1 / r2);
+                    } else {
+                        angle = 0;
+                    }
+                }
+            }
+            r *= lensRadius;
+            // point on the lens
+            eyeX = (float) (Math.cos(angle) * r);
+            eyeY = (float) (Math.sin(angle) * r);
+        } else {
+            // sample N-gon
+            // FIXME: this could use concentric sampling
+            lensY *= lensSides;
+            float side = (int) lensY;
+            float offs = (float) lensY - side;
+            float dist = (float) Math.sqrt(lensX);
+            float a0 = (float) (side * Math.PI * 2.0f / lensSides + lensRotationRadians);
+            float a1 = (float) ((side + 1.0f) * Math.PI * 2.0f / lensSides + lensRotationRadians);
+            eyeX = (float) ((Math.cos(a0) * (1.0f - offs) + Math.cos(a1) * offs) * dist);
+            eyeY = (float) ((Math.sin(a0) * (1.0f - offs) + Math.sin(a1) * offs) * dist);
+            eyeX *= lensRadius;
+            eyeY *= lensRadius;
+        }
+        float eyeZ = 0;
+        // point on the image plane
+        float dirX = du;
+        float dirY = dv;
+        float dirZ = -focusDistance;
+        // ray
+        return new Ray(eyeX, eyeY, eyeZ, dirX - eyeX, dirY - eyeY, dirZ - eyeZ);
+    }
+}

data/src/main/java/org/sunflow/core/display/FastDisplay.java

@@ -0,0 +1,119 @@
+package org.sunflow.core.display;
+
+import java.awt.Dimension;
+import java.awt.Graphics;
+import java.awt.event.KeyAdapter;
+import java.awt.event.KeyEvent;
+import java.awt.image.BufferedImage;
+
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.Display;
+import org.sunflow.image.Color;
+import org.sunflow.system.Timer;
+
+@SuppressWarnings("serial")
+public class FastDisplay extends JPanel implements Display {
+
+    private JFrame frame;
+    private BufferedImage image;
+    private int[] pixels;
+    private final Timer t;
+    private float seconds;
+    private int frames;
+
+    public FastDisplay() {
+        image = null;
+        frame = null;
+        t = new Timer();
+        frames = 0;
+        seconds = 0;
+    }
+
+    @Override
+    public synchronized void imageBegin(int w, int h, int bucketSize) {
+        if (frame != null && image != null && w == image.getWidth() && h == image.getHeight()) {
+            // nothing to do
+        } else {
+            // allocate new framebuffer
+            pixels = new int[w * h];
+            image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
+            // prepare frame
+            if (frame == null) {
+                setPreferredSize(new Dimension(w, h));
+                frame = new JFrame("Sunflow v" + SunflowAPI.VERSION);
+                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+                frame.addKeyListener(new KeyAdapter() {
+                    @Override
+                    public void keyPressed(KeyEvent e) {
+                        if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
+                            System.exit(0);
+                        }
+                    }
+                });
+                frame.setContentPane(this);
+                frame.pack();
+                frame.setLocationRelativeTo(null);
+                frame.setVisible(true);
+            }
+        }
+        // start counter
+        t.start();
+    }
+
+    @Override
+    public void imagePrepare(int x, int y, int w, int h, int id) {
+    }
+
+    @Override
+    public void imageUpdate(int x, int y, int w, int h, Color[] data, float[] alpha) {
+        int iw = image.getWidth();
+        int off = x + iw * y;
+        iw -= w;
+        for (int j = 0, index = 0; j < h; j++, off += iw) {
+            for (int i = 0; i < w; i++, index++, off++) {
+                pixels[off] = 0xFF000000 | data[index].toRGB();
+            }
+        }
+    }
+
+    @Override
+    public void imageFill(int x, int y, int w, int h, Color c, float alpha) {
+        int iw = image.getWidth();
+        int off = x + iw * y;
+        iw -= w;
+        int rgb = 0xFF000000 | c.toRGB();
+        for (int j = 0, index = 0; j < h; j++, off += iw) {
+            for (int i = 0; i < w; i++, index++, off++) {
+                pixels[off] = rgb;
+            }
+        }
+    }
+
+    @Override
+    public synchronized void imageEnd() {
+        // copy buffer
+        image.setRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());
+        repaint();
+        // update stats
+        t.end();
+        seconds += t.seconds();
+        frames++;
+        if (seconds > 1) {
+            // display average fps every second
+            frame.setTitle(String.format("Sunflow v%s - %.2f fps", SunflowAPI.VERSION, frames / seconds));
+            frames = 0;
+            seconds = 0;
+        }
+    }
+
+    @Override
+    public synchronized void paint(Graphics g) {
+        if (image == null) {
+            return;
+        }
+        g.drawImage(image, 0, 0, null);
+    }
+}