joonsrenderer 1.1-java

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

@@ -0,0 +1,62 @@
+package org.sunflow.core;
+
+import org.sunflow.image.Color;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Vector3;
+
+/**
+ * Describes an object which can store photons.
+ */
+public interface PhotonStore {
+
+    /**
+     * Number of photons to emit from this surface.
+     *
+     * @return number of photons
+     */
+    int numEmit();
+
+    /**
+     * Initialize this object for the specified scene size.
+     *
+     * @param sceneBounds scene bounding box
+     */
+    void prepare(Options options, BoundingBox sceneBounds);
+
+    /**
+     * Store the specified photon.
+     *
+     * @param state shading state
+     * @param dir photon direction
+     * @param power photon power
+     * @param diffuse diffuse color at the hit point
+     */
+    void store(ShadingState state, Vector3 dir, Color power, Color diffuse);
+
+    /**
+     * Initialize the map after all photons have been stored. This can be used
+     * to balance a kd-tree based photon map for example.
+     */
+    void init();
+
+    /**
+     * Allow photons reflected diffusely?
+     *
+     * @return <code>true</code> if diffuse bounces should be traced
+     */
+    boolean allowDiffuseBounced();
+
+    /**
+     * Allow specularly reflected photons?
+     *
+     * @return <code>true</code> if specular reflection bounces should be traced
+     */
+    boolean allowReflectionBounced();
+
+    /**
+     * Allow refracted photons?
+     *
+     * @return <code>true</code> if refracted bounces should be traced
+     */
+    boolean allowRefractionBounced();
+}

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

@@ -0,0 +1,70 @@
+package org.sunflow.core;
+
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+
+/**
+ * This class represents an object made up of many primitives.
+ */
+public interface PrimitiveList extends RenderObject {
+
+    /**
+     * Compute a bounding box of this object in world space, using the specified
+     * object-to-world transformation matrix. The bounds should be as exact as
+     * possible, if they are difficult or expensive to compute exactly, you may
+     * use {@link Matrix4#transform(BoundingBox)}. If the matrix is
+     * <code>null</code> no transformation is needed, and object space is
+     * equivalent to world space.
+     *
+     * @param o2w object to world transformation matrix
+     * @return object bounding box in world space
+     */
+    public BoundingBox getWorldBounds(Matrix4 o2w);
+
+    /**
+     * Returns the number of individual primtives in this aggregate object.
+     *
+     * @return number of primitives
+     */
+    public int getNumPrimitives();
+
+    /**
+     * Retrieve the bounding box component of a particular primitive in object
+     * space. Even indexes get minimum values, while odd indexes get the maximum
+     * values for each axis.
+     *
+     * @param primID primitive index
+     * @param i bounding box side index
+     * @return value of the request bound
+     */
+    public float getPrimitiveBound(int primID, int i);
+
+    /**
+     * Intersect the specified primitive in local space.
+     *
+     * @param r ray in the object's local space
+     * @param primID primitive index to intersect
+     * @param state intersection state
+     * @see Ray#setMax(float)
+     * @see IntersectionState#setIntersection(int, float, float)
+     */
+    public void intersectPrimitive(Ray r, int primID, IntersectionState state);
+
+    /**
+     * Prepare the specified {@link ShadingState} by setting all of its internal
+     * parameters.
+     *
+     * @param state shading state to fill in
+     */
+    public void prepareShadingState(ShadingState state);
+
+    /**
+     * Create a new {@link PrimitiveList} object suitable for baking lightmaps.
+     * This means a set of primitives laid out in the unit square UV space. This
+     * method is optional, objects which do not support it should simply return
+     * <code>null</code>.
+     *
+     * @return a list of baking primitives
+     */
+    public PrimitiveList getBakingPrimitives();
+}

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

@@ -0,0 +1,219 @@
+package org.sunflow.core;
+
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+
+/**
+ * This class represents a ray as a oriented half line segment. The ray
+ * direction is always normalized. The valid region is delimted by two distances
+ * along the ray, tMin and tMax.
+ */
+public final class Ray {
+
+    public float ox, oy, oz;
+    public float dx, dy, dz;
+    private float tMin;
+    private float tMax;
+    private static final float EPSILON = 0;// 0.01f;
+
+    private Ray() {
+    }
+
+    /**
+     * Creates a new ray that points from the given origin to the given
+     * direction. The ray has infinite length. The direction vector is
+     * normalized.
+     *
+     * @param ox ray origin x
+     * @param oy ray origin y
+     * @param oz ray origin z
+     * @param dx ray direction x
+     * @param dy ray direction y
+     * @param dz ray direction z
+     */
+    public Ray(float ox, float oy, float oz, float dx, float dy, float dz) {
+        this.ox = ox;
+        this.oy = oy;
+        this.oz = oz;
+        this.dx = dx;
+        this.dy = dy;
+        this.dz = dz;
+        float in = 1.0f / (float) Math.sqrt(dx * dx + dy * dy + dz * dz);
+        this.dx *= in;
+        this.dy *= in;
+        this.dz *= in;
+        tMin = EPSILON;
+        tMax = Float.POSITIVE_INFINITY;
+    }
+
+    /**
+     * Creates a new ray that points from the given origin to the given
+     * direction. The ray has infinite length. The direction vector is
+     * normalized.
+     *
+     * @param o ray origin
+     * @param d ray direction (need not be normalized)
+     */
+    public Ray(Point3 o, Vector3 d) {
+        ox = o.x;
+        oy = o.y;
+        oz = o.z;
+        dx = d.x;
+        dy = d.y;
+        dz = d.z;
+        float in = 1.0f / (float) Math.sqrt(dx * dx + dy * dy + dz * dz);
+        dx *= in;
+        dy *= in;
+        dz *= in;
+        tMin = EPSILON;
+        tMax = Float.POSITIVE_INFINITY;
+    }
+
+    /**
+     * Creates a new ray that points from point a to point b. The created ray
+     * will set tMin and tMax to limit the ray to the segment (a,b)
+     * (non-inclusive of a and b). This is often used to create shadow rays.
+     *
+     * @param a start point
+     * @param b end point
+     */
+    public Ray(Point3 a, Point3 b) {
+        ox = a.x;
+        oy = a.y;
+        oz = a.z;
+        dx = b.x - ox;
+        dy = b.y - oy;
+        dz = b.z - oz;
+        tMin = EPSILON;
+        float n = (float) Math.sqrt(dx * dx + dy * dy + dz * dz);
+        float in = 1.0f / n;
+        dx *= in;
+        dy *= in;
+        dz *= in;
+        tMax = n - EPSILON;
+    }
+
+    /**
+     * Create a new ray by transforming the supplied one by the given matrix. If
+     * the matrix is
+     * <code>null</code>, the original ray is returned.
+     *
+     * @param m matrix to transform the ray by
+     */
+    public Ray transform(Matrix4 m) {
+        if (m == null) {
+            return this;
+        }
+        Ray r = new Ray();
+        r.ox = m.transformPX(ox, oy, oz);
+        r.oy = m.transformPY(ox, oy, oz);
+        r.oz = m.transformPZ(ox, oy, oz);
+        r.dx = m.transformVX(dx, dy, dz);
+        r.dy = m.transformVY(dx, dy, dz);
+        r.dz = m.transformVZ(dx, dy, dz);
+        r.tMin = tMin;
+        r.tMax = tMax;
+        return r;
+    }
+
+    /**
+     * Normalize the direction component of the ray.
+     */
+    public void normalize() {
+        float in = 1.0f / (float) Math.sqrt(dx * dx + dy * dy + dz * dz);
+        dx *= in;
+        dy *= in;
+        dz *= in;
+    }
+
+    /**
+     * Gets the minimum distance along the ray - usually 0.
+     *
+     * @return value of the smallest distance along the ray
+     */
+    public final float getMin() {
+        return tMin;
+    }
+
+    /**
+     * Gets the maximum distance along the ray. May be infinite.
+     *
+     * @return value of the largest distance along the ray
+     */
+    public final float getMax() {
+        return tMax;
+    }
+
+    /**
+     * Creates a vector to represent the direction of the ray.
+     *
+     * @return a vector equal to the direction of this ray
+     */
+    public final Vector3 getDirection() {
+        return new Vector3(dx, dy, dz);
+    }
+
+    /**
+     * Checks to see if the specified distance falls within the valid range on
+     * this ray. This should always be used before an intersection with the ray
+     * is detected.
+     *
+     * @param t distance to be tested
+     * @return <code>true</code> if t falls between the minimum and maximum
+     * distance of this ray, <code>false</code> otherwise
+     */
+    public final boolean isInside(float t) {
+        return (tMin < t) && (t < tMax);
+    }
+
+    /**
+     * Gets the end point of the ray. A reference to
+     * <code>dest</code> is returned to support chaining.
+     *
+     * @param dest reference to the point to store
+     * @return reference to <code>dest</code>
+     */
+    public final Point3 getPoint(Point3 dest) {
+        dest.x = ox + (tMax * dx);
+        dest.y = oy + (tMax * dy);
+        dest.z = oz + (tMax * dz);
+        return dest;
+    }
+
+    /**
+     * Computes the dot product of an arbitrary vector with the direction of the
+     * ray. This method avoids having to call getDirection() which would
+     * instantiate a new Vector object.
+     *
+     * @param v vector
+     * @return dot product of the ray direction and the specified vector
+     */
+    public final float dot(Vector3 v) {
+        return dx * v.x + dy * v.y + dz * v.z;
+    }
+
+    /**
+     * Computes the dot product of an arbitrary vector with the direction of the
+     * ray. This method avoids having to call getDirection() which would
+     * instantiate a new Vector object.
+     *
+     * @param vx vector x coordinate
+     * @param vy vector y coordinate
+     * @param vz vector z coordinate
+     * @return dot product of the ray direction and the specified vector
+     */
+    public final float dot(float vx, float vy, float vz) {
+        return dx * vx + dy * vy + dz * vz;
+    }
+
+    /**
+     * Updates the maximum to the specified distance if and only if the new
+     * distance is smaller than the current one.
+     *
+     * @param t new maximum distance
+     */
+    public final void setMax(float t) {
+        tMax = t;
+    }
+}

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

@@ -0,0 +1,25 @@
+package org.sunflow.core;
+
+import org.sunflow.SunflowAPI;
+
+/**
+ * This is the base interface for all public rendering object interfaces. It
+ * handles incremental updates via {@link ParameterList} objects.
+ */
+public interface RenderObject {
+
+    /**
+     * Update this object given a list of parameters. This method is guarenteed
+     * to be called at least once on every object, but it should correctly
+     * handle empty parameter lists. This means that the object should be in a
+     * valid state from the time it is constructed. This method should also
+     * return true or false depending on whether the update was succesfull or
+     * not.
+     *
+     * @param pl list of parameters to read from
+     * @param api reference to the current scene
+     * @return <code>true</code> if the update is succesfull, <code>false</code>
+     * otherwise
+     */
+    public boolean update(ParameterList pl, SunflowAPI api);
+}

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

@@ -0,0 +1,377 @@
+package org.sunflow.core;
+
+import java.util.ArrayList;
+
+import org.sunflow.core.display.FrameDisplay;
+import org.sunflow.image.Color;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.MathUtils;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+/**
+ * Represents a entire scene, defined as a collection of instances viewed by a
+ * camera.
+ */
+public class Scene {
+    // scene storage
+
+    private LightServer lightServer;
+    private InstanceList instanceList;
+    private InstanceList infiniteInstanceList;
+    private Camera camera;
+    private AccelerationStructure intAccel;
+    private String acceltype;
+    private Statistics stats;
+    // baking
+    private boolean bakingViewDependent;
+    private Instance bakingInstance;
+    private PrimitiveList bakingPrimitives;
+    private AccelerationStructure bakingAccel;
+    private boolean rebuildAccel;
+    // image size
+    private int imageWidth;
+    private int imageHeight;
+    // global options
+    private int threads;
+    private boolean lowPriority;
+
+    /**
+     * Creates an empty scene.
+     */
+    public Scene() {
+        lightServer = new LightServer(this);
+        instanceList = new InstanceList();
+        infiniteInstanceList = new InstanceList();
+        acceltype = "auto";
+        stats = new Statistics();
+
+        bakingViewDependent = false;
+        bakingInstance = null;
+        bakingPrimitives = null;
+        bakingAccel = null;
+
+        camera = null;
+        imageWidth = 640;
+        imageHeight = 480;
+        threads = 0;
+        lowPriority = true;
+
+        rebuildAccel = true;
+    }
+
+    /**
+     * Get number of allowed threads for multi-threaded operations.
+     *
+     * @return number of threads that can be started
+     */
+    public int getThreads() {
+        return threads <= 0 ? Runtime.getRuntime().availableProcessors() : threads;
+    }
+
+    /**
+     * Get the priority level to assign to multi-threaded operations.
+     *
+     * @return thread priority
+     */
+    public int getThreadPriority() {
+        return lowPriority ? Thread.MIN_PRIORITY : Thread.NORM_PRIORITY;
+    }
+
+    /**
+     * Sets the current camera (no support for multiple cameras yet).
+     *
+     * @param camera camera to be used as the viewpoint for the scene
+     */
+    public void setCamera(Camera camera) {
+        this.camera = camera;
+    }
+
+    Camera getCamera() {
+        return camera;
+    }
+
+    /**
+     * Update the instance lists for this scene.
+     *
+     * @param instances regular instances
+     * @param infinite infinite instances (no bounds)
+     */
+    public void setInstanceLists(Instance[] instances, Instance[] infinite) {
+        infiniteInstanceList = new InstanceList(infinite);
+        instanceList = new InstanceList(instances);
+        rebuildAccel = true;
+    }
+
+    /**
+     * Update the light list for this scene.
+     *
+     * @param lights array of light source objects
+     */
+    public void setLightList(LightSource[] lights) {
+        lightServer.setLights(lights);
+    }
+
+    /**
+     * Enables shader overiding (set null to disable). The specified shader will
+     * be used to shade all surfaces
+     *
+     * @param shader shader to run over all surfaces, or <code>null</code> to
+     * disable overriding
+     * @param photonOverride <code>true</code> to override photon scattering
+     * with this shader or <code>false</code> to run the regular shaders
+     */
+    public void setShaderOverride(Shader shader, boolean photonOverride) {
+        lightServer.setShaderOverride(shader, photonOverride);
+    }
+
+    /**
+     * The provided instance will be considered for lightmap baking. If the
+     * specified instance is
+     * <code>null</code>, lightmap baking will be disabled and normal rendering
+     * will occur.
+     *
+     * @param instance instance to bake
+     */
+    public void setBakingInstance(Instance instance) {
+        bakingInstance = instance;
+    }
+
+    /**
+     * Get the radiance seen through a particular pixel
+     *
+     * @param istate intersection state for ray tracing
+     * @param rx pixel x coordinate
+     * @param ry pixel y coordinate
+     * @param lensU DOF sampling variable
+     * @param lensV DOF sampling variable
+     * @param time motion blur sampling variable
+     * @param instance QMC instance seed
+     * @return a shading state for the intersected primitive, or
+     * <code>null</code> if nothing is seen through the specifieFd point
+     */
+    public ShadingState getRadiance(IntersectionState istate, float rx, float ry, double lensU, double lensV, double time, int instance, int dim, ShadingCache cache) {
+        istate.numEyeRays++;
+        float sceneTime = camera.getTime((float) time);
+        if (bakingPrimitives == null) {
+            Ray r = camera.getRay(rx, ry, imageWidth, imageHeight, lensU, lensV, sceneTime);
+            return r != null ? lightServer.getRadiance(rx, ry, sceneTime, instance, dim, r, istate, cache) : null;
+        } else {
+            Ray r = new Ray(rx / imageWidth, ry / imageHeight, -1, 0, 0, 1);
+            traceBake(r, istate);
+            if (!istate.hit()) {
+                return null;
+            }
+            ShadingState state = ShadingState.createState(istate, rx, ry, sceneTime, r, instance, dim, lightServer);
+            bakingPrimitives.prepareShadingState(state);
+            if (bakingViewDependent) {
+                state.setRay(camera.getRay(state.getPoint(), sceneTime));
+            } else {
+                Point3 p = state.getPoint();
+                Vector3 n = state.getNormal();
+                // create a ray coming from directly above the point being
+                // shaded
+                Ray incoming = new Ray(p.x + n.x, p.y + n.y, p.z + n.z, -n.x, -n.y, -n.z);
+                incoming.setMax(1);
+                state.setRay(incoming);
+            }
+            lightServer.shadeBakeResult(state);
+            return state;
+        }
+    }
+
+    /**
+     * Get scene world space bounding box.
+     *
+     * @return scene bounding box
+     */
+    public BoundingBox getBounds() {
+        return instanceList.getWorldBounds(null);
+    }
+
+    public void accumulateStats(IntersectionState state) {
+        stats.accumulate(state);
+    }
+
+    public void accumulateStats(ShadingCache cache) {
+        stats.accumulate(cache);
+    }
+
+    void trace(Ray r, IntersectionState state) {
+        // stats
+        state.numRays++;
+        // reset object
+        state.instance = null;
+        state.current = null;
+        for (int i = 0; i < infiniteInstanceList.getNumPrimitives(); i++) {
+            infiniteInstanceList.intersectPrimitive(r, i, state);
+        }
+        // reset for next accel structure
+        state.current = null;
+        intAccel.intersect(r, state);
+    }
+
+    Color traceShadow(Ray r, IntersectionState state) {
+        state.numShadowRays++;
+        trace(r, state);
+        return state.hit() ? Color.WHITE : Color.BLACK;
+    }
+
+    void traceBake(Ray r, IntersectionState state) {
+        // set the instance as if tracing a regular instanced object
+        state.current = bakingInstance;
+        // reset object
+        state.instance = null;
+        bakingAccel.intersect(r, state);
+    }
+
+    private void createAreaLightInstances() {
+        ArrayList<Instance> infiniteAreaLights = null;
+        ArrayList<Instance> areaLights = null;
+        // create an area light instance from each light source if possible
+        for (LightSource l : lightServer.lights) {
+            Instance lightInstance = l.createInstance();
+            if (lightInstance != null) {
+                if (lightInstance.getBounds() == null) {
+                    if (infiniteAreaLights == null) {
+                        infiniteAreaLights = new ArrayList<Instance>();
+                    }
+                    infiniteAreaLights.add(lightInstance);
+                } else {
+                    if (areaLights == null) {
+                        areaLights = new ArrayList<Instance>();
+                    }
+                    areaLights.add(lightInstance);
+                }
+            }
+        }
+        // add area light sources to the list of instances if they exist
+        if (infiniteAreaLights != null && infiniteAreaLights.size() > 0) {
+            infiniteInstanceList.addLightSourceInstances(infiniteAreaLights.toArray(new Instance[infiniteAreaLights.size()]));
+        } else {
+            infiniteInstanceList.clearLightSources();
+        }
+        if (areaLights != null && areaLights.size() > 0) {
+            instanceList.addLightSourceInstances(areaLights.toArray(new Instance[areaLights.size()]));
+        } else {
+            instanceList.clearLightSources();
+        }
+        // FIXME: this _could_ be done incrementally to avoid top-level rebuilds
+        // each frame
+        rebuildAccel = true;
+    }
+
+    private void removeAreaLightInstances() {
+        infiniteInstanceList.clearLightSources();
+        instanceList.clearLightSources();
+    }
+
+    /**
+     * Render the scene using the specified options, image sampler and display.
+     *
+     * @param options rendering options object
+     * @param sampler image sampler
+     * @param display display to send the final image to, a default display will
+     * be created if <code>null</code>
+     */
+    public void render(Options options, ImageSampler sampler, Display display) {
+        stats.reset();
+        if (display == null) {
+            display = new FrameDisplay();
+        }
+
+        if (bakingInstance != null) {
+            UI.printDetailed(Module.SCENE, "Creating primitives for lightmapping ...");
+            bakingPrimitives = bakingInstance.getBakingPrimitives();
+            if (bakingPrimitives == null) {
+                UI.printError(Module.SCENE, "Lightmap baking is not supported for the given instance.");
+                return;
+            }
+            int n = bakingPrimitives.getNumPrimitives();
+            UI.printInfo(Module.SCENE, "Building acceleration structure for lightmapping (%d num primitives) ...", n);
+            bakingAccel = AccelerationStructureFactory.create("auto", n, true);
+            bakingAccel.build(bakingPrimitives);
+        } else {
+            bakingPrimitives = null;
+            bakingAccel = null;
+        }
+        bakingViewDependent = options.getBoolean("baking.viewdep", bakingViewDependent);
+
+        if ((bakingInstance != null && bakingViewDependent && camera == null) || (bakingInstance == null && camera == null)) {
+            UI.printError(Module.SCENE, "No camera found");
+            return;
+        }
+
+        // read from options
+        threads = options.getInt("threads", 0);
+        lowPriority = options.getBoolean("threads.lowPriority", true);
+        imageWidth = options.getInt("resolutionX", 640);
+        imageHeight = options.getInt("resolutionY", 480);
+        // limit resolution to 16k
+        imageWidth = MathUtils.clamp(imageWidth, 1, 1 << 14);
+        imageHeight = MathUtils.clamp(imageHeight, 1, 1 << 14);
+
+        // prepare lights
+        createAreaLightInstances();
+
+        // get acceleration structure info
+        // count scene primitives
+        long numPrimitives = 0;
+        for (int i = 0; i < instanceList.getNumPrimitives(); i++) {
+            numPrimitives += instanceList.getNumPrimitives(i);
+        }
+        UI.printInfo(Module.SCENE, "Scene stats:");
+        UI.printInfo(Module.SCENE, "  * Infinite instances:  %d", infiniteInstanceList.getNumPrimitives());
+        UI.printInfo(Module.SCENE, "  * Instances:           %d", instanceList.getNumPrimitives());
+        UI.printInfo(Module.SCENE, "  * Primitives:          %d", numPrimitives);
+        String accelName = options.getString("accel", null);
+        if (accelName != null) {
+            rebuildAccel = rebuildAccel || !acceltype.equals(accelName);
+            acceltype = accelName;
+        }
+        UI.printInfo(Module.SCENE, "  * Instance accel:      %s", acceltype);
+        if (rebuildAccel) {
+            intAccel = AccelerationStructureFactory.create(acceltype, instanceList.getNumPrimitives(), false);
+            intAccel.build(instanceList);
+            rebuildAccel = false;
+        }
+        UI.printInfo(Module.SCENE, "  * Scene bounds:        %s", getBounds());
+        UI.printInfo(Module.SCENE, "  * Scene center:        %s", getBounds().getCenter());
+        UI.printInfo(Module.SCENE, "  * Scene diameter:      %.2f", getBounds().getExtents().length());
+        UI.printInfo(Module.SCENE, "  * Lightmap bake:       %s", bakingInstance != null ? (bakingViewDependent ? "view" : "ortho") : "off");
+        if (sampler == null) {
+            return;
+        }
+        if (!lightServer.build(options)) {
+            return;
+        }
+        // render
+        UI.printInfo(Module.SCENE, "Rendering ...");
+        stats.setResolution(imageWidth, imageHeight);
+        sampler.prepare(options, this, imageWidth, imageHeight);
+        sampler.render(display);
+        // show statistics
+        stats.displayStats();
+        lightServer.showStats();
+        // discard area lights
+        removeAreaLightInstances();
+        // discard baking tesselation/accel structure
+        bakingPrimitives = null;
+        bakingAccel = null;
+        UI.printInfo(Module.SCENE, "Done.");
+    }
+
+    /**
+     * Create a photon map as prescribed by the given {@link PhotonStore}.
+     *
+     * @param map object that will recieve shot photons
+     * @param type type of photons being shot
+     * @param seed QMC seed parameter
+     * @return <code>true</code> upon success
+     */
+    public boolean calculatePhotons(PhotonStore map, String type, int seed, Options options) {
+        return lightServer.calculatePhotons(map, type, seed, options);
+    }
+}