joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/InstanceList.java

@@ -0,0 +1,83 @@
+package org.sunflow.core;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+
+final class InstanceList implements PrimitiveList {
+
+    private Instance[] instances;
+    private Instance[] lights;
+
+    InstanceList() {
+        instances = new Instance[0];
+        clearLightSources();
+    }
+
+    InstanceList(Instance[] instances) {
+        this.instances = instances;
+        clearLightSources();
+    }
+
+    void addLightSourceInstances(Instance[] lights) {
+        this.lights = lights;
+    }
+
+    void clearLightSources() {
+        lights = new Instance[0];
+    }
+
+    @Override
+    public final float getPrimitiveBound(int primID, int i) {
+        if (primID < instances.length) {
+            return instances[primID].getBounds().getBound(i);
+        } else {
+            return lights[primID - instances.length].getBounds().getBound(i);
+        }
+    }
+
+    @Override
+    public final BoundingBox getWorldBounds(Matrix4 o2w) {
+        BoundingBox bounds = new BoundingBox();
+        for (Instance i : instances) {
+            bounds.include(i.getBounds());
+        }
+        for (Instance i : lights) {
+            bounds.include(i.getBounds());
+        }
+        return bounds;
+    }
+
+    @Override
+    public final void intersectPrimitive(Ray r, int primID, IntersectionState state) {
+        if (primID < instances.length) {
+            instances[primID].intersect(r, state);
+        } else {
+            lights[primID - instances.length].intersect(r, state);
+        }
+    }
+
+    @Override
+    public final int getNumPrimitives() {
+        return instances.length + lights.length;
+    }
+
+    public final int getNumPrimitives(int primID) {
+        return primID < instances.length ? instances[primID].getNumPrimitives() : lights[primID - instances.length].getNumPrimitives();
+    }
+
+    @Override
+    public final void prepareShadingState(ShadingState state) {
+        state.getInstance().prepareShadingState(state);
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+     public PrimitiveList getBakingPrimitives() {
+        return null;
+    }
+}

data/src/main/java/org/sunflow/core/IntersectionState.java

@@ -0,0 +1,120 @@
+package org.sunflow.core;
+
+/**
+ * This class is used to store ray/object intersections. It also provides
+ * additional data to assist {@link AccelerationStructure} objects with
+ * traversal.
+ */
+public final class IntersectionState {
+
+    private static final int MAX_STACK_SIZE = 64;
+    float time;
+    float u, v, w;
+    Instance instance;
+    int id;
+    private final StackNode[][] stacks = new StackNode[2][MAX_STACK_SIZE];
+    Instance current;
+    long numEyeRays;
+    long numShadowRays;
+    long numReflectionRays;
+    long numGlossyRays;
+    long numRefractionRays;
+    long numRays;
+
+    /**
+     * Traversal stack node, helps with tree-based {@link AccelerationStructure}
+     * traversal.
+     */
+    public static final class StackNode {
+
+        public int node;
+        public float near;
+        public float far;
+    }
+
+    /**
+     * Initializes all traversal stacks.
+     */
+    public IntersectionState() {
+        for (int i = 0; i < stacks.length; i++) {
+            for (int j = 0; j < stacks[i].length; j++) {
+                stacks[i][j] = new StackNode();
+            }
+        }
+    }
+
+    /**
+     * Returns the time at which the intersection should be calculated. This
+     * will be constant for a given ray-tree. This value is guarenteed to be
+     * between the camera's shutter open and shutter close time.
+     *
+     * @return time value
+     */
+    public float getTime() {
+        return time;
+    }
+
+    /**
+     * Get stack object for tree based {@link AccelerationStructure}s.
+     *
+     * @return array of stack nodes
+     */
+    public final StackNode[] getStack() {
+        return current == null ? stacks[0] : stacks[1];
+    }
+
+    /**
+     * Checks to see if a hit has been recorded.
+     *
+     * @return <code>true</code> if a hit has been recorded, <code>false</code>
+     * otherwise
+     */
+    public final boolean hit() {
+        return instance != null;
+    }
+
+    /**
+     * Record an intersection with the specified primitive id. The parent object
+     * is assumed to be the current instance. The u and v parameters are used to
+     * pinpoint the location on the surface if needed.
+     *
+     * @param id primitive id of the intersected object
+     */
+    public final void setIntersection(int id) {
+        instance = current;
+        this.id = id;
+    }
+
+    /**
+     * Record an intersection with the specified primitive id. The parent object
+     * is assumed to be the current instance. The u and v parameters are used to
+     * pinpoint the location on the surface if needed.
+     *
+     * @param id primitive id of the intersected object
+     * @param u u surface paramater of the intersection point
+     * @param v v surface parameter of the intersection point
+     */
+    public final void setIntersection(int id, float u, float v) {
+        instance = current;
+        this.id = id;
+        this.u = u;
+        this.v = v;
+    }
+
+    /**
+     * Record an intersection with the specified primitive id. The parent object
+     * is assumed to be the current instance. The u and v parameters are used to
+     * pinpoint the location on the surface if needed.
+     *
+     * @param id primitive id of the intersected object
+     * @param u u surface paramater of the intersection point
+     * @param v v surface parameter of the intersection point
+     */
+    public final void setIntersection(int id, float u, float v, float w) {
+        instance = current;
+        this.id = id;
+        this.u = u;
+        this.v = v;
+        this.w = w;
+    }
+}

data/src/main/java/org/sunflow/core/LightSample.java

@@ -0,0 +1,104 @@
+package org.sunflow.core;
+
+import org.sunflow.image.Color;
+import org.sunflow.math.Vector3;
+
+/**
+ * Represents a sample taken from a light source that faces a point being
+ * shaded.
+ */
+public class LightSample {
+
+    private Ray shadowRay; // ray to be used to evaluate if the point is in
+    // shadow
+    private Color ldiff;
+    private Color lspec;
+    LightSample next; // pointer to next item in a linked list of samples
+
+    /**
+     * Creates a new light sample object (invalid by default).
+     */
+    public LightSample() {
+        ldiff = lspec = null;
+        shadowRay = null;
+        next = null;
+    }
+
+    boolean isValid() {
+        return ldiff != null && lspec != null && shadowRay != null;
+    }
+
+    /**
+     * Set the current shadow ray. The ray's direction is used as the sample's
+     * orientation.
+     *
+     * @param shadowRay shadow ray from the point being shaded towards the light
+     */
+    public void setShadowRay(Ray shadowRay) {
+        this.shadowRay = shadowRay;
+    }
+
+    /**
+     * Trace the shadow ray, attenuating the sample's color by the opacity of
+     * intersected objects.
+     *
+     * @param state shading state representing the point to be shaded
+     */
+    public final void traceShadow(ShadingState state) {
+        Color opacity = state.traceShadow(shadowRay);
+        Color.blend(ldiff, Color.BLACK, opacity, ldiff);
+        Color.blend(lspec, Color.BLACK, opacity, lspec);
+    }
+
+    /**
+     * Get the sample's shadow ray.
+     *
+     * @return shadow ray
+     */
+    public Ray getShadowRay() {
+        return shadowRay;
+    }
+
+    /**
+     * Get diffuse radiance.
+     *
+     * @return diffuse radiance
+     */
+    public Color getDiffuseRadiance() {
+        return ldiff;
+    }
+
+    /**
+     * Get specular radiance.
+     *
+     * @return specular radiance
+     */
+    public Color getSpecularRadiance() {
+        return lspec;
+    }
+
+    /**
+     * Set the diffuse and specular radiance emitted by the current light
+     * source. These should usually be the same, but are distinguished to allow
+     * for non-physical light setups or light source types which compute diffuse
+     * and specular responses seperately.
+     *
+     * @param d diffuse radiance
+     * @param s specular radiance
+     */
+    public void setRadiance(Color d, Color s) {
+        ldiff = d.copy();
+        lspec = s.copy();
+    }
+
+    /**
+     * Compute a dot product between the current shadow ray direction and the
+     * specified vector.
+     *
+     * @param v direction vector
+     * @return dot product of the vector with the shadow ray direction
+     */
+    public float dot(Vector3 v) {
+        return shadowRay.dot(v);
+    }
+}

data/src/main/java/org/sunflow/core/LightServer.java

@@ -0,0 +1,382 @@
+package org.sunflow.core;
+
+import org.sunflow.PluginRegistry;
+import org.sunflow.image.Color;
+import org.sunflow.math.Point3;
+import org.sunflow.math.QMC;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.Timer;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+class LightServer {
+    // parent
+
+    private Scene scene;
+    // lighting
+    LightSource[] lights;
+    // shading override
+    private Shader shaderOverride;
+    private boolean shaderOverridePhotons;
+    // direct illumination
+    private int maxDiffuseDepth;
+    private int maxReflectionDepth;
+    private int maxRefractionDepth;
+    // indirect illumination
+    private CausticPhotonMapInterface causticPhotonMap;
+    private GIEngine giEngine;
+    private int photonCounter;
+
+    LightServer(Scene scene) {
+        this.scene = scene;
+        lights = new LightSource[0];
+        causticPhotonMap = null;
+
+        shaderOverride = null;
+        shaderOverridePhotons = false;
+
+        maxDiffuseDepth = 1;
+        maxReflectionDepth = 4;
+        maxRefractionDepth = 4;
+
+        causticPhotonMap = null;
+        giEngine = null;
+    }
+
+    void setLights(LightSource[] lights) {
+        this.lights = lights;
+    }
+
+    Scene getScene() {
+        return scene;
+    }
+
+    void setShaderOverride(Shader shader, boolean photonOverride) {
+        shaderOverride = shader;
+        shaderOverridePhotons = photonOverride;
+    }
+
+    boolean build(Options options) {
+        // read options
+        maxDiffuseDepth = options.getInt("depths.diffuse", maxDiffuseDepth);
+        maxReflectionDepth = options.getInt("depths.reflection", maxReflectionDepth);
+        maxRefractionDepth = options.getInt("depths.refraction", maxRefractionDepth);
+        String giEngineType = options.getString("gi.engine", null);
+        giEngine = PluginRegistry.GI_ENGINE_PLUGINS.createObject(giEngineType);
+        String caustics = options.getString("caustics", null);
+        causticPhotonMap = PluginRegistry.CAUSTIC_PHOTON_MAP_PLUGINS.createObject(caustics);
+
+        // validate options
+        maxDiffuseDepth = Math.max(0, maxDiffuseDepth);
+        maxReflectionDepth = Math.max(0, maxReflectionDepth);
+        maxRefractionDepth = Math.max(0, maxRefractionDepth);
+
+        Timer t = new Timer();
+        t.start();
+        // count total number of light samples
+        int numLightSamples = 0;
+        for (int i = 0; i < lights.length; i++) {
+            numLightSamples += lights[i].getNumSamples();
+        }
+        // initialize gi engine
+        if (giEngine != null) {
+            if (!giEngine.init(options, scene)) {
+                return false;
+            }
+        }
+
+        if (!calculatePhotons(causticPhotonMap, "caustic", 0, options)) {
+            return false;
+        }
+        t.end();
+        UI.printInfo(Module.LIGHT, "Light Server stats:");
+        UI.printInfo(Module.LIGHT, "  * Light sources found: %d", lights.length);
+        UI.printInfo(Module.LIGHT, "  * Light samples:       %d", numLightSamples);
+        UI.printInfo(Module.LIGHT, "  * Max raytrace depth:");
+        UI.printInfo(Module.LIGHT, "      - Diffuse          %d", maxDiffuseDepth);
+        UI.printInfo(Module.LIGHT, "      - Reflection       %d", maxReflectionDepth);
+        UI.printInfo(Module.LIGHT, "      - Refraction       %d", maxRefractionDepth);
+        UI.printInfo(Module.LIGHT, "  * GI engine            %s", giEngineType == null ? "none" : giEngineType);
+        UI.printInfo(Module.LIGHT, "  * Caustics:            %s", caustics == null ? "none" : caustics);
+        UI.printInfo(Module.LIGHT, "  * Shader override:     %b", shaderOverride);
+        UI.printInfo(Module.LIGHT, "  * Photon override:     %b", shaderOverridePhotons);
+        UI.printInfo(Module.LIGHT, "  * Build time:          %s", t.toString());
+        return true;
+    }
+
+    void showStats() {
+    }
+
+    boolean calculatePhotons(final PhotonStore map, String type, final int seed, Options options) {
+        if (map == null) {
+            return true;
+        }
+        if (lights.length == 0) {
+            UI.printError(Module.LIGHT, "Unable to trace %s photons, no lights in scene", type);
+            return false;
+        }
+        final float[] histogram = new float[lights.length];
+        histogram[0] = lights[0].getPower();
+        for (int i = 1; i < lights.length; i++) {
+            histogram[i] = histogram[i - 1] + lights[i].getPower();
+        }
+        UI.printInfo(Module.LIGHT, "Tracing %s photons ...", type);
+        map.prepare(options, scene.getBounds());
+        int numEmittedPhotons = map.numEmit();
+        if (numEmittedPhotons <= 0 || histogram[histogram.length - 1] <= 0) {
+            UI.printError(Module.LIGHT, "Photon mapping enabled, but no %s photons to emit", type);
+            return false;
+        }
+        UI.taskStart("Tracing " + type + " photons", 0, numEmittedPhotons);
+        Thread[] photonThreads = new Thread[scene.getThreads()];
+        final float scale = 1.0f / numEmittedPhotons;
+        int delta = numEmittedPhotons / photonThreads.length;
+        photonCounter = 0;
+        Timer photonTimer = new Timer();
+        photonTimer.start();
+        for (int i = 0; i < photonThreads.length; i++) {
+            final int threadID = i;
+            final int start = threadID * delta;
+            final int end = (threadID == (photonThreads.length - 1)) ? numEmittedPhotons : (threadID + 1) * delta;
+            photonThreads[i] = new Thread(new Runnable() {
+                public void run() {
+                    IntersectionState istate = new IntersectionState();
+                    for (int i = start; i < end; i++) {
+                        synchronized (LightServer.this) {
+                            UI.taskUpdate(photonCounter);
+                            photonCounter++;
+                            if (UI.taskCanceled()) {
+                                return;
+                            }
+                        }
+
+                        int qmcI = i + seed;
+
+                        double rand = QMC.halton(0, qmcI) * histogram[histogram.length - 1];
+                        int j = 0;
+                        while (rand >= histogram[j] && j < histogram.length) {
+                            j++;
+                        }
+                        // make sure we didn't pick a zero-probability light
+                        if (j == histogram.length) {
+                            continue;
+                        }
+
+                        double randX1 = (j == 0) ? rand / histogram[0] : (rand - histogram[j]) / (histogram[j] - histogram[j - 1]);
+                        double randY1 = QMC.halton(1, qmcI);
+                        double randX2 = QMC.halton(2, qmcI);
+                        double randY2 = QMC.halton(3, qmcI);
+                        Point3 pt = new Point3();
+                        Vector3 dir = new Vector3();
+                        Color power = new Color();
+                        lights[j].getPhoton(randX1, randY1, randX2, randY2, pt, dir, power);
+                        power.mul(scale);
+                        Ray r = new Ray(pt, dir);
+                        scene.trace(r, istate);
+                        if (istate.hit()) {
+                            shadePhoton(ShadingState.createPhotonState(r, istate, qmcI, map, LightServer.this), power);
+                        }
+                    }
+                }
+            });
+            photonThreads[i].setPriority(scene.getThreadPriority());
+            photonThreads[i].start();
+        }
+        for (int i = 0; i < photonThreads.length; i++) {
+            try {
+                photonThreads[i].join();
+            } catch (InterruptedException e) {
+                UI.printError(Module.LIGHT, "Photon thread %d of %d was interrupted", i + 1, photonThreads.length);
+                return false;
+            }
+        }
+        if (UI.taskCanceled()) {
+            UI.taskStop(); // shut down task cleanly
+            return false;
+        }
+        photonTimer.end();
+        UI.taskStop();
+        UI.printInfo(Module.LIGHT, "Tracing time for %s photons: %s", type, photonTimer.toString());
+        map.init();
+        return true;
+    }
+
+    void shadePhoton(ShadingState state, Color power) {
+        state.getInstance().prepareShadingState(state);
+        Shader shader = getPhotonShader(state);
+        // scatter photon
+        if (shader != null) {
+            shader.scatterPhoton(state, power);
+        }
+    }
+
+    void traceDiffusePhoton(ShadingState previous, Ray r, Color power) {
+        if (previous.getDiffuseDepth() >= maxDiffuseDepth) {
+            return;
+        }
+        IntersectionState istate = previous.getIntersectionState();
+        scene.trace(r, istate);
+        if (previous.getIntersectionState().hit()) {
+            // create a new shading context
+            ShadingState state = ShadingState.createDiffuseBounceState(previous, r, 0);
+            shadePhoton(state, power);
+        }
+    }
+
+    void traceReflectionPhoton(ShadingState previous, Ray r, Color power) {
+        if (previous.getReflectionDepth() >= maxReflectionDepth) {
+            return;
+        }
+        IntersectionState istate = previous.getIntersectionState();
+        scene.trace(r, istate);
+        if (previous.getIntersectionState().hit()) {
+            // create a new shading context
+            ShadingState state = ShadingState.createReflectionBounceState(previous, r, 0);
+            shadePhoton(state, power);
+        }
+    }
+
+    void traceRefractionPhoton(ShadingState previous, Ray r, Color power) {
+        if (previous.getRefractionDepth() >= maxRefractionDepth) {
+            return;
+        }
+        IntersectionState istate = previous.getIntersectionState();
+        scene.trace(r, istate);
+        if (previous.getIntersectionState().hit()) {
+            // create a new shading context
+            ShadingState state = ShadingState.createRefractionBounceState(previous, r, 0);
+            shadePhoton(state, power);
+        }
+    }
+
+    private Shader getShader(ShadingState state) {
+        return shaderOverride != null ? shaderOverride : state.getShader();
+    }
+
+    private Shader getPhotonShader(ShadingState state) {
+        return (shaderOverride != null && shaderOverridePhotons) ? shaderOverride : state.getShader();
+
+    }
+
+    ShadingState getRadiance(float rx, float ry, float time, int i, int d, Ray r, IntersectionState istate, ShadingCache cache) {
+        // set this value once - will stay constant for the entire ray-tree
+        istate.time = time;
+        scene.trace(r, istate);
+        if (istate.hit()) {
+            ShadingState state = ShadingState.createState(istate, rx, ry, time, r, i, d, this);
+            state.getInstance().prepareShadingState(state);
+            Shader shader = getShader(state);
+            if (shader == null) {
+                state.setResult(Color.BLACK);
+                return state;
+            }
+            if (cache != null) {
+                Color c = cache.lookup(state, shader);
+                if (c != null) {
+                    state.setResult(c);
+                    return state;
+                }
+            }
+            state.setResult(shader.getRadiance(state));
+            if (cache != null) {
+                cache.add(state, shader, state.getResult());
+            }
+            checkNanInf(state.getResult());
+            return state;
+        } else {
+            return null;
+        }
+    }
+
+    private static final void checkNanInf(Color c) {
+        if (c.isNan()) {
+            UI.printWarning(Module.LIGHT, "NaN shading sample!");
+        } else if (c.isInf()) {
+            UI.printWarning(Module.LIGHT, "Inf shading sample!");
+        }
+    }
+
+    void shadeBakeResult(ShadingState state) {
+        Shader shader = getShader(state);
+        if (shader != null) {
+            state.setResult(shader.getRadiance(state));
+        } else {
+            state.setResult(Color.BLACK);
+        }
+    }
+
+    Color shadeHit(ShadingState state) {
+        state.getInstance().prepareShadingState(state);
+        Shader shader = getShader(state);
+        return (shader != null) ? shader.getRadiance(state) : Color.BLACK;
+    }
+
+    Color traceGlossy(ShadingState previous, Ray r, int i) {
+        // limit path depth and disable caustic paths
+        if (previous.getReflectionDepth() >= maxReflectionDepth || previous.getDiffuseDepth() > 0) {
+            return Color.BLACK;
+        }
+        IntersectionState istate = previous.getIntersectionState();
+        istate.numGlossyRays++;
+        scene.trace(r, istate);
+        return istate.hit() ? shadeHit(ShadingState.createGlossyBounceState(previous, r, i)) : Color.BLACK;
+    }
+
+    Color traceReflection(ShadingState previous, Ray r, int i) {
+        // limit path depth and disable caustic paths
+        if (previous.getReflectionDepth() >= maxReflectionDepth || previous.getDiffuseDepth() > 0) {
+            return Color.BLACK;
+        }
+        IntersectionState istate = previous.getIntersectionState();
+        istate.numReflectionRays++;
+        scene.trace(r, istate);
+        return istate.hit() ? shadeHit(ShadingState.createReflectionBounceState(previous, r, i)) : Color.BLACK;
+    }
+
+    Color traceRefraction(ShadingState previous, Ray r, int i) {
+        // limit path depth and disable caustic paths
+        if (previous.getRefractionDepth() >= maxRefractionDepth || previous.getDiffuseDepth() > 0) {
+            return Color.BLACK;
+        }
+        IntersectionState istate = previous.getIntersectionState();
+        istate.numRefractionRays++;
+        scene.trace(r, istate);
+        return istate.hit() ? shadeHit(ShadingState.createRefractionBounceState(previous, r, i)) : Color.BLACK;
+    }
+
+    ShadingState traceFinalGather(ShadingState previous, Ray r, int i) {
+        if (previous.getDiffuseDepth() >= maxDiffuseDepth) {
+            return null;
+        }
+        IntersectionState istate = previous.getIntersectionState();
+        scene.trace(r, istate);
+        return istate.hit() ? ShadingState.createFinalGatherState(previous, r, i) : null;
+    }
+
+    Color getGlobalRadiance(ShadingState state) {
+        if (giEngine == null) {
+            return Color.BLACK;
+        }
+        return giEngine.getGlobalRadiance(state);
+    }
+
+    Color getIrradiance(ShadingState state, Color diffuseReflectance) {
+        // no gi engine, or we have already exceeded number of available bounces
+        if (giEngine == null || state.getDiffuseDepth() >= maxDiffuseDepth) {
+            return Color.BLACK;
+        }
+        return giEngine.getIrradiance(state, diffuseReflectance);
+    }
+
+    void initLightSamples(ShadingState state) {
+        for (LightSource l : lights) {
+            l.getSamples(state);
+        }
+    }
+
+    void initCausticSamples(ShadingState state) {
+        if (causticPhotonMap != null) {
+            causticPhotonMap.getSamples(state);
+        }
+    }
+}