joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/renderer/MultipassRenderer.java

@@ -0,0 +1,237 @@
+package org.sunflow.core.renderer;
+
+import org.sunflow.core.BucketOrder;
+import org.sunflow.core.Display;
+import org.sunflow.core.ImageSampler;
+import org.sunflow.core.IntersectionState;
+import org.sunflow.core.Options;
+import org.sunflow.core.Scene;
+import org.sunflow.core.ShadingCache;
+import org.sunflow.core.ShadingState;
+import org.sunflow.core.bucket.BucketOrderFactory;
+import org.sunflow.image.Color;
+import org.sunflow.math.MathUtils;
+import org.sunflow.math.QMC;
+import org.sunflow.system.Timer;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class MultipassRenderer implements ImageSampler {
+
+    private Scene scene;
+    private Display display;
+    // resolution
+    private int imageWidth;
+    private int imageHeight;
+    // bucketing
+    private String bucketOrderName;
+    private BucketOrder bucketOrder;
+    private int bucketSize;
+    private int bucketCounter;
+    private int[] bucketCoords;
+    // anti-aliasing
+    private int numSamples;
+    private float invNumSamples;
+    private boolean shadingCache;
+
+    public MultipassRenderer() {
+        bucketSize = 32;
+        bucketOrderName = "hilbert";
+        numSamples = 16;
+        shadingCache = false;
+    }
+
+    @Override
+    public boolean prepare(Options options, Scene scene, int w, int h) {
+        this.scene = scene;
+        imageWidth = w;
+        imageHeight = h;
+
+        // fetch options
+        bucketSize = options.getInt("bucket.size", bucketSize);
+        bucketOrderName = options.getString("bucket.order", bucketOrderName);
+        numSamples = options.getInt("aa.samples", numSamples);
+        shadingCache = options.getBoolean("aa.cache", shadingCache);
+
+        // limit bucket size and compute number of buckets in each direction
+        bucketSize = MathUtils.clamp(bucketSize, 16, 512);
+        int numBucketsX = (imageWidth + bucketSize - 1) / bucketSize;
+        int numBucketsY = (imageHeight + bucketSize - 1) / bucketSize;
+        bucketOrder = BucketOrderFactory.create(bucketOrderName);
+        bucketCoords = bucketOrder.getBucketSequence(numBucketsX, numBucketsY);
+        // validate AA options
+        numSamples = Math.max(1, numSamples);
+        invNumSamples = 1.0f / numSamples;
+        // prepare QMC sampling
+        UI.printInfo(Module.BCKT, "Multipass renderer settings:");
+        UI.printInfo(Module.BCKT, "  * Resolution:         %dx%d", imageWidth, imageHeight);
+        UI.printInfo(Module.BCKT, "  * Bucket size:        %d", bucketSize);
+        UI.printInfo(Module.BCKT, "  * Number of buckets:  %dx%d", numBucketsX, numBucketsY);
+        UI.printInfo(Module.BCKT, "  * Samples / pixel:    %d", numSamples);
+        UI.printInfo(Module.BCKT, "  * Shading cache:      %s", shadingCache ? "enabled" : "disabled");
+        return true;
+    }
+
+    @Override
+    public void render(Display display) {
+        this.display = display;
+        display.imageBegin(imageWidth, imageHeight, bucketSize);
+        // set members variables
+        bucketCounter = 0;
+        // start task
+        Timer timer = new Timer();
+        timer.start();
+        UI.taskStart("Rendering", 0, bucketCoords.length);
+        BucketThread[] renderThreads = new BucketThread[scene.getThreads()];
+        for (int i = 0; i < renderThreads.length; i++) {
+            renderThreads[i] = new BucketThread(i);
+            renderThreads[i].setPriority(scene.getThreadPriority());
+            renderThreads[i].start();
+        }
+        for (int i = 0; i < renderThreads.length; i++) {
+            try {
+                renderThreads[i].join();
+            } catch (InterruptedException e) {
+                UI.printError(Module.BCKT, "Bucket processing thread %d of %d was interrupted", i + 1, renderThreads.length);
+            } finally {
+                renderThreads[i].updateStats();
+            }
+        }
+        UI.taskStop();
+        timer.end();
+        UI.printInfo(Module.BCKT, "Render time: %s", timer.toString());
+        display.imageEnd();
+    }
+
+    private class BucketThread extends Thread {
+
+        private final int threadID;
+        private final IntersectionState istate;
+        private final ShadingCache cache;
+
+        BucketThread(int threadID) {
+            this.threadID = threadID;
+            istate = new IntersectionState();
+            cache = shadingCache ? new ShadingCache() : null;
+        }
+
+        @Override
+        public void run() {
+            while (true) {
+                int bx, by;
+                synchronized (MultipassRenderer.this) {
+                    if (bucketCounter >= bucketCoords.length) {
+                        return;
+                    }
+                    UI.taskUpdate(bucketCounter);
+                    bx = bucketCoords[bucketCounter + 0];
+                    by = bucketCoords[bucketCounter + 1];
+                    bucketCounter += 2;
+                }
+                renderBucket(display, bx, by, threadID, istate, cache);
+            }
+        }
+
+        void updateStats() {
+            scene.accumulateStats(istate);
+            if (shadingCache) {
+                scene.accumulateStats(cache);
+            }
+        }
+    }
+
+    private void renderBucket(Display display, int bx, int by, int threadID, IntersectionState istate, ShadingCache cache) {
+        // pixel sized extents
+        int x0 = bx * bucketSize;
+        int y0 = by * bucketSize;
+        int bw = Math.min(bucketSize, imageWidth - x0);
+        int bh = Math.min(bucketSize, imageHeight - y0);
+
+        // prepare bucket
+        display.imagePrepare(x0, y0, bw, bh, threadID);
+
+        Color[] bucketRGB = new Color[bw * bh];
+        float[] bucketAlpha = new float[bw * bh];
+
+        for (int y = 0, i = 0, cy = imageHeight - 1 - y0; y < bh; y++, cy--) {
+            for (int x = 0, cx = x0; x < bw; x++, i++, cx++) {
+                // sample pixel
+                Color c = Color.black();
+                float a = 0;
+                int instance = ((cx & ((1 << QMC.MAX_SIGMA_ORDER) - 1)) << QMC.MAX_SIGMA_ORDER) + QMC.sigma(cy & ((1 << QMC.MAX_SIGMA_ORDER) - 1), QMC.MAX_SIGMA_ORDER);
+                double jitterX = QMC.halton(0, instance);
+                double jitterY = QMC.halton(1, instance);
+                double jitterT = QMC.halton(2, instance);
+                double jitterU = QMC.halton(3, instance);
+                double jitterV = QMC.halton(4, instance);
+                for (int s = 0; s < numSamples; s++) {
+                    float rx = cx + 0.5f + (float) warpCubic(QMC.mod1(jitterX + s * invNumSamples));
+                    float ry = cy + 0.5f + (float) warpCubic(QMC.mod1(jitterY + QMC.halton(0, s)));
+                    double time = QMC.mod1(jitterT + QMC.halton(1, s));
+                    double lensU = QMC.mod1(jitterU + QMC.halton(2, s));
+                    double lensV = QMC.mod1(jitterV + QMC.halton(3, s));
+                    ShadingState state = scene.getRadiance(istate, rx, ry, lensU, lensV, time, instance + s, 5, cache);
+                    if (state != null) {
+                        c.add(state.getResult());
+                        a++;
+                    }
+                }
+                bucketRGB[i] = c.mul(invNumSamples);
+                bucketAlpha[i] = a * invNumSamples;
+                if (cache != null) {
+                    cache.reset();
+                }
+            }
+        }
+        // update pixels
+        display.imageUpdate(x0, y0, bw, bh, bucketRGB, bucketAlpha);
+    }
+
+    /**
+     * Tent filter warping function.
+     *
+     * @param x sample in the [0,1) range
+     * @return warped sample in the [-1,+1) range
+     */
+    @SuppressWarnings("unused")
+    private static float warpTent(float x) {
+        if (x < 0.5f) {
+            return -1 + (float) Math.sqrt(2 * x);
+        } else {
+            return +1 - (float) Math.sqrt(2 - 2 * x);
+        }
+    }
+
+    /**
+     * Cubic BSpline warping functions. Formulas from: "Generation of Stratified
+     * Samples for B-Spline Pixel Filtering"
+     * http://www.cs.utah.edu/~mstark/papers/
+     *
+     * @param x samples in the [0,1) range
+     * @return warped sample in the [-2,+2) range
+     */
+    private static double warpCubic(double x) {
+        if (x < (1.0 / 24)) {
+            return qpow(24 * x) - 2;
+        }
+        if (x < 0.5f) {
+            return distb1((24.0 / 11.0) * (x - (1.0 / 24.0))) - 1;
+        }
+        if (x < (23.0f / 24)) {
+            return 1 - distb1((24.0 / 11.0) * ((23.0 / 24.0) - x));
+        }
+        return 2 - qpow(24 * (1 - x));
+    }
+
+    private static double qpow(double x) {
+        return Math.sqrt(Math.sqrt(x));
+    }
+
+    private static double distb1(double x) {
+        double u = x;
+        for (int i = 0; i < 5; i++) {
+            u = (11 * x + u * u * (6 + u * (8 - 9 * u))) / (4 + 12 * u * (1 + u * (1 - u)));
+        }
+        return u;
+    }
+}

data/src/main/java/org/sunflow/core/renderer/ProgressiveRenderer.java

@@ -0,0 +1,171 @@
+package org.sunflow.core.renderer;
+
+import java.util.concurrent.PriorityBlockingQueue;
+
+import org.sunflow.core.Display;
+import org.sunflow.core.ImageSampler;
+import org.sunflow.core.IntersectionState;
+import org.sunflow.core.Options;
+import org.sunflow.core.Scene;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.QMC;
+import org.sunflow.system.Timer;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class ProgressiveRenderer implements ImageSampler {
+
+    private Scene scene;
+    private int imageWidth, imageHeight;
+    private PriorityBlockingQueue<SmallBucket> smallBucketQueue;
+    private Display display;
+    private int counter, counterMax;
+
+    public ProgressiveRenderer() {
+        imageWidth = 640;
+        imageHeight = 480;
+        smallBucketQueue = null;
+    }
+
+    @Override
+    public boolean prepare(Options options, Scene scene, int w, int h) {
+        this.scene = scene;
+        imageWidth = w;
+        imageHeight = h;
+        // prepare table used by deterministic anti-aliasing
+        return true;
+    }
+
+    @Override
+    public void render(Display display) {
+        this.display = display;
+        display.imageBegin(imageWidth, imageHeight, 0);
+        // create first bucket
+        SmallBucket b = new SmallBucket();
+        b.x = b.y = 0;
+        int s = Math.max(imageWidth, imageHeight);
+        b.size = 1;
+        while (b.size < s) {
+            b.size <<= 1;
+        }
+        smallBucketQueue = new PriorityBlockingQueue<>();
+        smallBucketQueue.add(b);
+        UI.taskStart("Progressive Render", 0, imageWidth * imageHeight);
+        Timer t = new Timer();
+        t.start();
+        counter = 0;
+        counterMax = imageWidth * imageHeight;
+
+        SmallBucketThread[] renderThreads = new SmallBucketThread[scene.getThreads()];
+        for (int i = 0; i < renderThreads.length; i++) {
+            renderThreads[i] = new SmallBucketThread();
+            renderThreads[i].start();
+        }
+        for (int i = 0; i < renderThreads.length; i++) {
+            try {
+                renderThreads[i].join();
+            } catch (InterruptedException e) {
+                UI.printError(Module.IPR, "Thread %d of %d was interrupted", i + 1, renderThreads.length);
+            } finally {
+                renderThreads[i].updateStats();
+            }
+        }
+        UI.taskStop();
+        t.end();
+        UI.printInfo(Module.IPR, "Rendering time: %s", t.toString());
+        display.imageEnd();
+    }
+
+    private class SmallBucketThread extends Thread {
+
+        private final IntersectionState istate = new IntersectionState();
+
+        @Override
+        public void run() {
+            while (true) {
+                int n = progressiveRenderNext(istate);
+                synchronized (ProgressiveRenderer.this) {
+                    if (counter >= counterMax) {
+                        return;
+                    }
+                    counter += n;
+                    UI.taskUpdate(counter);
+                }
+                if (UI.taskCanceled()) {
+                    return;
+                }
+            }
+        }
+
+        void updateStats() {
+            scene.accumulateStats(istate);
+        }
+    }
+
+    private int progressiveRenderNext(IntersectionState istate) {
+        final int TASK_SIZE = 16;
+        SmallBucket first = smallBucketQueue.poll();
+        if (first == null) {
+            return 0;
+        }
+        int ds = first.size / TASK_SIZE;
+        boolean useMask = !smallBucketQueue.isEmpty();
+        int mask = 2 * first.size / TASK_SIZE - 1;
+        int pixels = 0;
+        for (int i = 0, y = first.y; i < TASK_SIZE && y < imageHeight; i++, y += ds) {
+            for (int j = 0, x = first.x; j < TASK_SIZE && x < imageWidth; j++, x += ds) {
+                // check to see if this is a pixel from a higher level tile
+                if (useMask && (x & mask) == 0 && (y & mask) == 0) {
+                    continue;
+                }
+                int instance = ((x & ((1 << QMC.MAX_SIGMA_ORDER) - 1)) << QMC.MAX_SIGMA_ORDER) + QMC.sigma(y & ((1 << QMC.MAX_SIGMA_ORDER) - 1), QMC.MAX_SIGMA_ORDER);
+                double time = QMC.halton(1, instance);
+                double lensU = QMC.halton(2, instance);
+                double lensV = QMC.halton(3, instance);
+                ShadingState state = scene.getRadiance(istate, x, imageHeight - 1 - y, lensU, lensV, time, instance, 4, null);
+                Color c = state != null ? state.getResult() : Color.BLACK;
+                pixels++;
+                // fill region
+                display.imageFill(x, y, Math.min(ds, imageWidth - x), Math.min(ds, imageHeight - y), c, state == null ? 0 : 1);
+            }
+        }
+        if (first.size >= 2 * TASK_SIZE) {
+            // generate child buckets
+            int size = first.size >>> 1;
+            for (int i = 0; i < 2; i++) {
+                if (first.y + i * size < imageHeight) {
+                    for (int j = 0; j < 2; j++) {
+                        if (first.x + j * size < imageWidth) {
+                            SmallBucket b = new SmallBucket();
+                            b.x = first.x + j * size;
+                            b.y = first.y + i * size;
+                            b.size = size;
+                            b.constrast = 1.0f / size;
+                            smallBucketQueue.put(b);
+                        }
+                    }
+                }
+            }
+        }
+        return pixels;
+    }
+
+    // progressive rendering
+    private static class SmallBucket implements Comparable<SmallBucket> {
+
+        int x, y, size;
+        float constrast;
+
+        @Override
+        public int compareTo(SmallBucket o) {
+            if (constrast < o.constrast) {
+                return -1;
+            }
+            if (constrast == o.constrast) {
+                return 0;
+            }
+            return 1;
+        }
+    }
+}

data/src/main/java/org/sunflow/core/renderer/SimpleRenderer.java

@@ -0,0 +1,106 @@
+package org.sunflow.core.renderer;
+
+import org.sunflow.core.Display;
+import org.sunflow.core.ImageSampler;
+import org.sunflow.core.IntersectionState;
+import org.sunflow.core.Options;
+import org.sunflow.core.Scene;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.system.Timer;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class SimpleRenderer implements ImageSampler {
+
+    private Scene scene;
+    private Display display;
+    private int imageWidth, imageHeight;
+    private int numBucketsX, numBucketsY;
+    private int bucketCounter, numBuckets;
+
+    @Override
+    public boolean prepare(Options options, Scene scene, int w, int h) {
+        this.scene = scene;
+        imageWidth = w;
+        imageHeight = h;
+        numBucketsX = (imageWidth + 31) >>> 5;
+        numBucketsY = (imageHeight + 31) >>> 5;
+        numBuckets = numBucketsX * numBucketsY;
+        return true;
+    }
+
+    @Override
+    public void render(Display display) {
+        this.display = display;
+        display.imageBegin(imageWidth, imageHeight, 32);
+        // set members variables
+        bucketCounter = 0;
+        // start task
+        Timer timer = new Timer();
+        timer.start();
+        BucketThread[] renderThreads = new BucketThread[scene.getThreads()];
+        for (int i = 0; i < renderThreads.length; i++) {
+            renderThreads[i] = new BucketThread();
+            renderThreads[i].start();
+        }
+        for (int i = 0; i < renderThreads.length; i++) {
+            try {
+                renderThreads[i].join();
+            } catch (InterruptedException e) {
+                UI.printError(Module.BCKT, "Bucket processing thread %d of %d was interrupted", i + 1, renderThreads.length);
+            } finally {
+                renderThreads[i].updateStats();
+            }
+        }
+        timer.end();
+        UI.printInfo(Module.BCKT, "Render time: %s", timer.toString());
+        display.imageEnd();
+    }
+
+    private class BucketThread extends Thread {
+
+        private final IntersectionState istate = new IntersectionState();
+
+        @Override
+        public void run() {
+            while (true) {
+                int bx, by;
+                synchronized (SimpleRenderer.this) {
+                    if (bucketCounter >= numBuckets) {
+                        return;
+                    }
+                    by = bucketCounter / numBucketsX;
+                    bx = bucketCounter % numBucketsX;
+                    bucketCounter++;
+                }
+                renderBucket(bx, by, istate);
+            }
+        }
+
+        void updateStats() {
+            scene.accumulateStats(istate);
+        }
+    }
+
+    public void renderBucket(int bx, int by, IntersectionState istate) {
+        // pixel sized extents
+        int x0 = bx * 32;
+        int y0 = by * 32;
+        int bw = Math.min(32, imageWidth - x0);
+        int bh = Math.min(32, imageHeight - y0);
+
+        Color[] bucketRGB = new Color[bw * bh];
+        float[] bucketAlpha = new float[bw * bh];
+
+        for (int y = 0, i = 0; y < bh; y++) {
+            for (int x = 0; x < bw; x++, i++) {
+                ShadingState state = scene.getRadiance(istate, x0 + x, imageHeight - 1 - (y0 + y), 0.0, 0.0, 0.0, 0, 0, null);
+                bucketRGB[i] = (state != null) ? state.getResult() : Color.BLACK;
+                bucketAlpha[i] = (state != null) ? 1 : 0;
+            }
+        }
+        // update pixels
+        display.imageUpdate(x0, y0, bw, bh, bucketRGB, bucketAlpha);
+    }
+}