joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/filter/MitchellFilter.java

@@ -0,0 +1,28 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class MitchellFilter implements Filter {
+
+    @Override
+    public float getSize() {
+        return 4.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        return mitchell(x) * mitchell(y);
+    }
+
+    private float mitchell(float x) {
+        final float B = 1 / 3.0f;
+        final float C = 1 / 3.0f;
+        final float SIXTH = 1 / 6.0f;
+        x = Math.abs(x);
+        float x2 = x * x;
+        if (x > 1.0f) {
+            return ((-B - 6 * C) * x * x2 + (6 * B + 30 * C) * x2 + (-12 * B - 48 * C) * x + (8 * B + 24 * C)) * SIXTH;
+        }
+        return ((12 - 9 * B - 6 * C) * x * x2 + (-18 + 12 * B + 6 * C) * x2 + (6 - 2 * B)) * SIXTH;
+    }
+}

data/src/main/java/org/sunflow/core/filter/SincFilter.java

@@ -0,0 +1,25 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class SincFilter implements Filter {
+
+    @Override
+    public float getSize() {
+        return 4.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        return sinc1d(x) * sinc1d(y);
+    }
+
+    private float sinc1d(float x) {
+        x = Math.abs(x);
+        if (x < 0.0001f) {
+            return 1.0f;
+        }
+        x *= Math.PI;
+        return (float) Math.sin(x) / x;
+    }
+}

data/src/main/java/org/sunflow/core/filter/TriangleFilter.java

@@ -0,0 +1,16 @@
+package org.sunflow.core.filter;
+
+import org.sunflow.core.Filter;
+
+public class TriangleFilter implements Filter {
+
+    @Override
+    public float getSize() {
+        return 2.0f;
+    }
+
+    @Override
+    public float get(float x, float y) {
+        return (1.0f - Math.abs(x)) * (1.0f - Math.abs(y));
+    }
+}

data/src/main/java/org/sunflow/core/gi/AmbientOcclusionGIEngine.java

@@ -0,0 +1,57 @@
+package org.sunflow.core.gi;
+
+import org.sunflow.core.GIEngine;
+import org.sunflow.core.Options;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Scene;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Vector3;
+
+public class AmbientOcclusionGIEngine implements GIEngine {
+
+    private Color bright;
+    private Color dark;
+    private int samples;
+    private float maxDist;
+
+    @Override
+    public Color getGlobalRadiance(ShadingState state) {
+        return Color.BLACK;
+    }
+
+    @Override
+    public boolean init(Options options, Scene scene) {
+        bright = options.getColor("gi.ambocc.bright", Color.WHITE);
+        dark = options.getColor("gi.ambocc.dark", Color.BLACK);
+        samples = options.getInt("gi.ambocc.samples", 32);
+        maxDist = options.getFloat("gi.ambocc.maxdist", 0);
+        maxDist = (maxDist <= 0) ? Float.POSITIVE_INFINITY : maxDist;
+        return true;
+    }
+
+    @Override
+    public Color getIrradiance(ShadingState state, Color diffuseReflectance) {
+        OrthoNormalBasis onb = state.getBasis();
+        Vector3 w = new Vector3();
+        Color result = Color.black();
+        for (int i = 0; i < samples; i++) {
+            float xi = (float) state.getRandom(i, 0, samples);
+            float xj = (float) state.getRandom(i, 1, samples);
+            float phi = (float) (2 * Math.PI * xi);
+            float cosPhi = (float) Math.cos(phi);
+            float sinPhi = (float) Math.sin(phi);
+            float sinTheta = (float) Math.sqrt(xj);
+            float cosTheta = (float) Math.sqrt(1.0f - xj);
+            w.x = cosPhi * sinTheta;
+            w.y = sinPhi * sinTheta;
+            w.z = cosTheta;
+            onb.transform(w);
+            Ray r = new Ray(state.getPoint(), w);
+            r.setMax(maxDist);
+            result.add(Color.blend(bright, dark, state.traceShadow(r)));
+        }
+        return result.mul((float) Math.PI / samples);
+    }
+}

data/src/main/java/org/sunflow/core/gi/FakeGIEngine.java

@@ -0,0 +1,48 @@
+package org.sunflow.core.gi;
+
+import org.sunflow.core.GIEngine;
+import org.sunflow.core.Options;
+import org.sunflow.core.Scene;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.Vector3;
+
+/**
+ * This is a quick way to get a bit of ambient lighting into your scene with
+ * hardly any overhead. It's based on the formula found here:
+ *
+ * @link http://www.cs.utah.edu/~shirley/papers/rtrt/node7.html#SECTION00031100000000000000
+ */
+public class FakeGIEngine implements GIEngine {
+
+    private Vector3 up;
+    private Color sky;
+    private Color ground;
+
+    @Override
+    public Color getIrradiance(ShadingState state, Color diffuseReflectance) {
+        float cosTheta = Vector3.dot(up, state.getNormal());
+        float sin2 = (1 - cosTheta * cosTheta);
+        float sine = sin2 > 0 ? (float) Math.sqrt(sin2) * 0.5f : 0;
+        if (cosTheta > 0) {
+            return Color.blend(sky, ground, sine);
+        } else {
+            return Color.blend(ground, sky, sine);
+        }
+    }
+
+    @Override
+    public Color getGlobalRadiance(ShadingState state) {
+        return Color.BLACK;
+    }
+
+    @Override
+    public boolean init(Options options, Scene scene) {
+        up = options.getVector("gi.fake.up", new Vector3(0, 1, 0)).normalize();
+        sky = options.getColor("gi.fake.sky", Color.WHITE).copy();
+        ground = options.getColor("gi.fake.ground", Color.BLACK).copy();
+        sky.mul((float) Math.PI);
+        ground.mul((float) Math.PI);
+        return true;
+    }
+}

data/src/main/java/org/sunflow/core/gi/InstantGI.java

@@ -0,0 +1,194 @@
+package org.sunflow.core.gi;
+
+import java.util.ArrayList;
+
+import org.sunflow.core.GIEngine;
+import org.sunflow.core.Options;
+import org.sunflow.core.PhotonStore;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Scene;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class InstantGI implements GIEngine {
+
+    private int numPhotons;
+    private int numSets;
+    private float c;
+    private int numBias;
+    private PointLight[][] virtualLights;
+
+    @Override
+    public Color getGlobalRadiance(ShadingState state) {
+        Point3 p = state.getPoint();
+        Vector3 n = state.getNormal();
+        int set = (int) (state.getRandom(0, 1, 1) * numSets);
+        float maxAvgPow = 0;
+        float minDist = 1;
+        Color pow = null;
+        for (PointLight vpl : virtualLights[set]) {
+            maxAvgPow = Math.max(maxAvgPow, vpl.power.getAverage());
+            if (Vector3.dot(n, vpl.n) > 0.9f) {
+                float d = vpl.p.distanceToSquared(p);
+                if (d < minDist) {
+                    pow = vpl.power;
+                    minDist = d;
+                }
+            }
+        }
+        return pow == null ? Color.BLACK : pow.copy().mul(1.0f / maxAvgPow);
+    }
+
+    @Override
+    public boolean init(Options options, Scene scene) {
+        numPhotons = options.getInt("gi.igi.samples", 64);
+        numSets = options.getInt("gi.igi.sets", 1);
+        c = options.getFloat("gi.igi.c", 0.00003f);
+        numBias = options.getInt("gi.igi.bias_samples", 0);
+        virtualLights = null;
+        if (numSets < 1) {
+            numSets = 1;
+        }
+        UI.printInfo(Module.LIGHT, "Instant Global Illumination settings:");
+        UI.printInfo(Module.LIGHT, "  * Samples:     %d", numPhotons);
+        UI.printInfo(Module.LIGHT, "  * Sets:        %d", numSets);
+        UI.printInfo(Module.LIGHT, "  * Bias bound:  %f", c);
+        UI.printInfo(Module.LIGHT, "  * Bias rays:   %d", numBias);
+        virtualLights = new PointLight[numSets][];
+        if (numPhotons > 0) {
+            for (int i = 0, seed = 0; i < virtualLights.length; i++, seed += numPhotons) {
+                PointLightStore map = new PointLightStore();
+                if (!scene.calculatePhotons(map, "virtual", seed, options)) {
+                    return false;
+                }
+                virtualLights[i] = map.virtualLights.toArray(new PointLight[map.virtualLights.size()]);
+                UI.printInfo(Module.LIGHT, "Stored %d virtual point lights for set %d of %d", virtualLights[i].length, i + 1, numSets);
+            }
+        } else {
+            // create an empty array
+            for (int i = 0; i < virtualLights.length; i++) {
+                virtualLights[i] = new PointLight[0];
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public Color getIrradiance(ShadingState state, Color diffuseReflectance) {
+        float b = (float) Math.PI * c / diffuseReflectance.getMax();
+        Color irr = Color.black();
+        Point3 p = state.getPoint();
+        Vector3 n = state.getNormal();
+        int set = (int) (state.getRandom(0, 1, 1) * numSets);
+        for (PointLight vpl : virtualLights[set]) {
+            Ray r = new Ray(p, vpl.p);
+            float dotNlD = -(r.dx * vpl.n.x + r.dy * vpl.n.y + r.dz * vpl.n.z);
+            float dotND = r.dx * n.x + r.dy * n.y + r.dz * n.z;
+            if (dotNlD > 0 && dotND > 0) {
+                float r2 = r.getMax() * r.getMax();
+                Color opacity = state.traceShadow(r);
+                Color power = Color.blend(vpl.power, Color.BLACK, opacity);
+                float g = (dotND * dotNlD) / r2;
+                irr.madd(0.25f * Math.min(g, b), power);
+            }
+        }
+        // bias compensation
+        int nb = (state.getDiffuseDepth() == 0 || numBias <= 0) ? numBias : 1;
+        if (nb <= 0) {
+            return irr;
+        }
+        OrthoNormalBasis onb = state.getBasis();
+        Vector3 w = new Vector3();
+        float scale = (float) Math.PI / nb;
+        for (int i = 0; i < nb; i++) {
+            float xi = (float) state.getRandom(i, 0, nb);
+            float xj = (float) state.getRandom(i, 1, nb);
+            float phi = (float) (xi * 2 * Math.PI);
+            float cosPhi = (float) Math.cos(phi);
+            float sinPhi = (float) Math.sin(phi);
+            float sinTheta = (float) Math.sqrt(xj);
+            float cosTheta = (float) Math.sqrt(1.0f - xj);
+            w.x = cosPhi * sinTheta;
+            w.y = sinPhi * sinTheta;
+            w.z = cosTheta;
+            onb.transform(w);
+            Ray r = new Ray(state.getPoint(), w);
+            r.setMax((float) Math.sqrt(cosTheta / b));
+            ShadingState temp = state.traceFinalGather(r, i);
+            if (temp != null) {
+                temp.getInstance().prepareShadingState(temp);
+                if (temp.getShader() != null) {
+                    float dist = temp.getRay().getMax();
+                    float r2 = dist * dist;
+                    float cosThetaY = -Vector3.dot(w, temp.getNormal());
+                    if (cosThetaY > 0) {
+                        float g = (cosTheta * cosThetaY) / r2;
+                        // was this path accounted for yet?
+                        if (g > b) {
+                            irr.madd(scale * (g - b) / g, temp.getShader().getRadiance(temp));
+                        }
+                    }
+                }
+            }
+        }
+        return irr;
+    }
+
+    private static class PointLight {
+
+        Point3 p;
+        Vector3 n;
+        Color power;
+    }
+
+    private class PointLightStore implements PhotonStore {
+
+        ArrayList<PointLight> virtualLights = new ArrayList<>();
+
+        @Override
+        public int numEmit() {
+            return numPhotons;
+        }
+
+        @Override
+        public void prepare(Options options, BoundingBox sceneBounds) {
+        }
+
+        @Override
+        public void store(ShadingState state, Vector3 dir, Color power, Color diffuse) {
+            state.faceforward();
+            PointLight vpl = new PointLight();
+            vpl.p = state.getPoint();
+            vpl.n = state.getNormal();
+            vpl.power = power;
+            synchronized (this) {
+                virtualLights.add(vpl);
+            }
+        }
+
+        @Override
+        public void init() {
+        }
+
+        @Override
+        public boolean allowDiffuseBounced() {
+            return true;
+        }
+
+        @Override
+        public boolean allowReflectionBounced() {
+            return true;
+        }
+
+        @Override
+        public boolean allowRefractionBounced() {
+            return true;
+        }
+    }
+}

data/src/main/java/org/sunflow/core/gi/IrradianceCacheGIEngine.java

@@ -0,0 +1,268 @@
+package org.sunflow.core.gi;
+
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import org.sunflow.PluginRegistry;
+import org.sunflow.core.GIEngine;
+import org.sunflow.core.GlobalPhotonMapInterface;
+import org.sunflow.core.Options;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Scene;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.MathUtils;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class IrradianceCacheGIEngine implements GIEngine {
+
+    private int samples;
+    private float tolerance;
+    private float invTolerance;
+    private float minSpacing;
+    private float maxSpacing;
+    private Node root;
+    private ReentrantReadWriteLock rwl;
+    private GlobalPhotonMapInterface globalPhotonMap;
+
+    @Override
+    public boolean init(Options options, Scene scene) {
+        // get settings
+        samples = options.getInt("gi.irr-cache.samples", 256);
+        tolerance = options.getFloat("gi.irr-cache.tolerance", 0.05f);
+        invTolerance = 1.0f / tolerance;
+        minSpacing = options.getFloat("gi.irr-cache.min_spacing", 0.05f);
+        maxSpacing = options.getFloat("gi.irr-cache.max_spacing", 5.00f);
+        root = null;
+        rwl = new ReentrantReadWriteLock();
+        globalPhotonMap = PluginRegistry.GLOBAL_PHOTON_MAP_PLUGINS.createObject(options.getString("gi.irr-cache.gmap", null));
+        // check settings
+        samples = Math.max(0, samples);
+        minSpacing = Math.max(0.001f, minSpacing);
+        maxSpacing = Math.max(0.001f, maxSpacing);
+        // display settings
+        UI.printInfo(Module.LIGHT, "Irradiance cache settings:");
+        UI.printInfo(Module.LIGHT, "  * Samples: %d", samples);
+        if (tolerance <= 0) {
+            UI.printInfo(Module.LIGHT, "  * Tolerance: off");
+        } else {
+            UI.printInfo(Module.LIGHT, "  * Tolerance: %.3f", tolerance);
+        }
+        UI.printInfo(Module.LIGHT, "  * Spacing: %.3f to %.3f", minSpacing, maxSpacing);
+        // prepare root node
+        Vector3 ext = scene.getBounds().getExtents();
+        root = new Node(scene.getBounds().getCenter(), 1.0001f * MathUtils.max(ext.x, ext.y, ext.z));
+        // init global photon map
+        return (globalPhotonMap != null) ? scene.calculatePhotons(globalPhotonMap, "global", 0, options) : true;
+    }
+
+    @Override
+    public Color getGlobalRadiance(ShadingState state) {
+        if (globalPhotonMap == null) {
+            if (state.getShader() != null) {
+                return state.getShader().getRadiance(state);
+            } else {
+                return Color.BLACK;
+            }
+        } else {
+            return globalPhotonMap.getRadiance(state.getPoint(), state.getNormal());
+        }
+    }
+
+    @Override
+    public Color getIrradiance(ShadingState state, Color diffuseReflectance) {
+        if (samples <= 0) {
+            return Color.BLACK;
+        }
+        if (state.getDiffuseDepth() > 0) {
+            // do simple path tracing for additional bounces (single ray)
+            float xi = (float) state.getRandom(0, 0, 1);
+            float xj = (float) state.getRandom(0, 1, 1);
+            float phi = (float) (xi * 2 * Math.PI);
+            float cosPhi = (float) Math.cos(phi);
+            float sinPhi = (float) Math.sin(phi);
+            float sinTheta = (float) Math.sqrt(xj);
+            float cosTheta = (float) Math.sqrt(1.0f - xj);
+            Vector3 w = new Vector3();
+            w.x = cosPhi * sinTheta;
+            w.y = sinPhi * sinTheta;
+            w.z = cosTheta;
+            OrthoNormalBasis onb = state.getBasis();
+            onb.transform(w);
+            Ray r = new Ray(state.getPoint(), w);
+            ShadingState temp = state.traceFinalGather(r, 0);
+            return temp != null ? getGlobalRadiance(temp).copy().mul((float) Math.PI) : Color.BLACK;
+        }
+        rwl.readLock().lock();
+        Color irr;
+        try {
+            irr = getIrradiance(state.getPoint(), state.getNormal());
+        } finally {
+            rwl.readLock().unlock();
+        }
+        if (irr == null) {
+            // compute new sample
+            irr = Color.black();
+            OrthoNormalBasis onb = state.getBasis();
+            float invR = 0;
+            float minR = Float.POSITIVE_INFINITY;
+            Vector3 w = new Vector3();
+            for (int i = 0; i < samples; i++) {
+                float xi = (float) state.getRandom(i, 0, samples);
+                float xj = (float) state.getRandom(i, 1, samples);
+                float phi = (float) (xi * 2 * Math.PI);
+                float cosPhi = (float) Math.cos(phi);
+                float sinPhi = (float) Math.sin(phi);
+                float sinTheta = (float) Math.sqrt(xj);
+                float cosTheta = (float) Math.sqrt(1.0f - xj);
+                w.x = cosPhi * sinTheta;
+                w.y = sinPhi * sinTheta;
+                w.z = cosTheta;
+                onb.transform(w);
+                Ray r = new Ray(state.getPoint(), w);
+                ShadingState temp = state.traceFinalGather(r, i);
+                if (temp != null) {
+                    minR = Math.min(r.getMax(), minR);
+                    invR += 1.0f / r.getMax();
+                    temp.getInstance().prepareShadingState(temp);
+                    irr.add(getGlobalRadiance(temp));
+                }
+            }
+            irr.mul((float) Math.PI / samples);
+            invR = samples / invR;
+            rwl.writeLock().lock();
+            try {
+                insert(state.getPoint(), state.getNormal(), invR, irr);
+            } finally {
+                rwl.writeLock().unlock();
+            }
+        }
+        return irr;
+    }
+
+    private void insert(Point3 p, Vector3 n, float r0, Color irr) {
+        if (tolerance <= 0) {
+            return;
+        }
+        Node node = root;
+        r0 = MathUtils.clamp(r0 * tolerance, minSpacing, maxSpacing) * invTolerance;
+        if (root.isInside(p)) {
+            while (node.sideLength >= (4.0 * r0 * tolerance)) {
+                int k = 0;
+                k |= (p.x > node.center.x) ? 1 : 0;
+                k |= (p.y > node.center.y) ? 2 : 0;
+                k |= (p.z > node.center.z) ? 4 : 0;
+                if (node.children[k] == null) {
+                    Point3 c = new Point3(node.center);
+                    c.x += ((k & 1) == 0) ? -node.quadSideLength : node.quadSideLength;
+                    c.y += ((k & 2) == 0) ? -node.quadSideLength : node.quadSideLength;
+                    c.z += ((k & 4) == 0) ? -node.quadSideLength : node.quadSideLength;
+                    node.children[k] = new Node(c, node.halfSideLength);
+                }
+                node = node.children[k];
+            }
+        }
+        Sample s = new Sample(p, n, r0, irr);
+        s.next = node.first;
+        node.first = s;
+    }
+
+    private Color getIrradiance(Point3 p, Vector3 n) {
+        if (tolerance <= 0) {
+            return null;
+        }
+        Sample x = new Sample(p, n);
+        float w = root.find(x);
+        return (x.irr == null) ? null : x.irr.mul(1.0f / w);
+    }
+
+    private final class Node {
+
+        Node[] children;
+        Sample first;
+        Point3 center;
+        float sideLength;
+        float halfSideLength;
+        float quadSideLength;
+
+        Node(Point3 center, float sideLength) {
+            children = new Node[8];
+            for (int i = 0; i < 8; i++) {
+                children[i] = null;
+            }
+            this.center = new Point3(center);
+            this.sideLength = sideLength;
+            halfSideLength = 0.5f * sideLength;
+            quadSideLength = 0.5f * halfSideLength;
+            first = null;
+        }
+
+        final boolean isInside(Point3 p) {
+            return (Math.abs(p.x - center.x) < halfSideLength) && (Math.abs(p.y - center.y) < halfSideLength) && (Math.abs(p.z - center.z) < halfSideLength);
+        }
+
+        final float find(Sample x) {
+            float weight = 0;
+            for (Sample s = first; s != null; s = s.next) {
+                float c2 = 1.0f - (x.nix * s.nix + x.niy * s.niy + x.niz * s.niz);
+                float d2 = (x.pix - s.pix) * (x.pix - s.pix) + (x.piy - s.piy) * (x.piy - s.piy) + (x.piz - s.piz) * (x.piz - s.piz);
+                if (c2 > tolerance * tolerance || d2 > maxSpacing * maxSpacing) {
+                    continue;
+                }
+                float invWi = (float) (Math.sqrt(d2) * s.invR0 + Math.sqrt(Math.max(c2, 0)));
+                if (invWi < tolerance || d2 < minSpacing * minSpacing) {
+                    float wi = Math.min(1e10f, 1.0f / invWi);
+                    if (x.irr != null) {
+                        x.irr.madd(wi, s.irr);
+                    } else {
+                        x.irr = s.irr.copy().mul(wi);
+                    }
+                    weight += wi;
+                }
+            }
+            for (int i = 0; i < 8; i++) {
+                if ((children[i] != null) && (Math.abs(children[i].center.x - x.pix) <= halfSideLength) && (Math.abs(children[i].center.y - x.piy) <= halfSideLength) && (Math.abs(children[i].center.z - x.piz) <= halfSideLength)) {
+                    weight += children[i].find(x);
+                }
+            }
+            return weight;
+        }
+    }
+
+    private static final class Sample {
+
+        float pix, piy, piz;
+        float nix, niy, niz;
+        float invR0;
+        Color irr;
+        Sample next;
+
+        Sample(Point3 p, Vector3 n) {
+            pix = p.x;
+            piy = p.y;
+            piz = p.z;
+            Vector3 ni = new Vector3(n).normalize();
+            nix = ni.x;
+            niy = ni.y;
+            niz = ni.z;
+            irr = null;
+            next = null;
+        }
+
+        Sample(Point3 p, Vector3 n, float r0, Color irr) {
+            pix = p.x;
+            piy = p.y;
+            piz = p.z;
+            Vector3 ni = new Vector3(n).normalize();
+            nix = ni.x;
+            niy = ni.y;
+            niz = ni.z;
+            invR0 = 1.0f / r0;
+            this.irr = irr;
+            next = null;
+        }
+    }
+}