joonsrenderer 1.1-java

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

@@ -0,0 +1,29 @@
+package org.sunflow.core;
+
+/**
+ * Represents a mapping from the 3D scene onto the final image. A camera lens is
+ * responsible for determining what ray to cast through each pixel.
+ */
+public interface CameraLens extends RenderObject {
+
+    /**
+     * Create a new {@link Ray ray}to be cast through pixel (x,y) on the image
+     * plane. Two sampling parameters are provided for lens sampling. They are
+     * guarenteed to be in the interval [0,1). They can be used to perturb the
+     * position of the source of the ray on the lens of the camera for DOF
+     * effects. A third sampling parameter is provided for motion blur effects.
+     * Note that the {@link Camera} class already handles camera movement motion
+     * blur. Rays should be generated in camera space - that is, with the eye at
+     * the origin, looking down the -Z axis, with +Y pointing up.
+     *
+     * @param x x coordinate of the (sub)pixel
+     * @param y y coordinate of the (sub)pixel
+     * @param imageWidth image width in pixels
+     * @param imageHeight image height in pixels
+     * @param lensX x lens sampling parameter
+     * @param lensY y lens sampling parameter
+     * @param time time sampling parameter
+     * @return a new ray passing through the given pixel
+     */
+    public Ray getRay(float x, float y, int imageWidth, int imageHeight, double lensX, double lensY, double time);
+}

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

@@ -0,0 +1,15 @@
+package org.sunflow.core;
+
+/**
+ * This class is a generic interface to caustic photon mapping capabilities.
+ */
+public interface CausticPhotonMapInterface extends PhotonStore {
+
+    /**
+     * Retrieve caustic photons at the specified shading location and add them
+     * as diffuse light samples.
+     *
+     * @param state
+     */
+    void getSamples(ShadingState state);
+}

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

@@ -0,0 +1,78 @@
+package org.sunflow.core;
+
+import org.sunflow.image.Color;
+
+/**
+ * Represents an image output device.
+ */
+public interface Display {
+
+    /**
+     * This is called before an image is rendered to indicate how large the
+     * rendered image will be. This allows the display driver to write out image
+     * headers or allocate surfaces. Bucket size will be 0 when called from a
+     * non-bucket based source.
+     *
+     * @param w width of the rendered image in pixels
+     * @param h height of the rendered image in pixels
+     * @param bucketSize size of the buckets in pixels
+     */
+    void imageBegin(int w, int h, int bucketSize);
+
+    /**
+     * Prepare the specified area to be rendered. This may be used to highlight
+     * the work in progress area or simply to setup the display driver to
+     * receive the specified portion of the image
+     *
+     * @param x x coordinate of the bucket within the image
+     * @param y y coordinate of the bucket within the image
+     * @param w width of the bucket in pixels
+     * @param h height of the bucket in pixels
+     * @param id unique identifier corresponding to the thread which invoked
+     * this call
+     */
+    void imagePrepare(int x, int y, int w, int h, int id);
+
+    /**
+     * Update the current image with a bucket of data. The region is guarenteed
+     * to be within the bounds created by the call to imageBegin. No clipping is
+     * necessary. Colors are passed in unprocessed. It is up the display driver
+     * to do any type of quantization, gamma compensation or tone-mapping
+     * needed. The array of colors will be exactly
+     * <code>w * h</code> long and in row major order.
+     *
+     * @param x x coordinate of the bucket within the image
+     * @param y y coordinate of the bucket within the image
+     * @param w width of the bucket in pixels
+     * @param h height of the bucket in pixels
+     * @param data bucket data, this array will be exactly <code>w * h</code>
+     * long
+     * @param alpha pixel coverage data, this array will be exactly
+     * <code>w * h</code> long
+     */
+    void imageUpdate(int x, int y, int w, int h, Color[] data, float[] alpha);
+
+    /**
+     * Update the current image with a region of flat color. This is used by
+     * progressive rendering to render progressively smaller regions of the
+     * screen which will overlap. The region is guarenteed to be within the
+     * bounds created by the call to imageBegin. No clipping is necessary.
+     * Colors are passed in unprocessed. It is up the display driver to do any
+     * type of quantization , gamma compensation or tone-mapping needed.
+     *
+     * @param x x coordinate of the region within the image
+     * @param y y coordinate of the region within the image
+     * @param w with of the region in pixels
+     * @param h height of the region in pixels
+     * @param c color to fill the region with
+     * @param alpha pixel coverage
+     */
+    void imageFill(int x, int y, int w, int h, Color c, float alpha);
+
+    /**
+     * This call is made after the image has been rendered. This allows the
+     * display driver to close any open files, write the image to disk or flush
+     * any other type of buffers.
+     */
+    void imageEnd();
+}

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

@@ -0,0 +1,27 @@
+package org.sunflow.core;
+
+/**
+ * Represents a multi-pixel image filter kernel.
+ */
+public interface Filter {
+
+    /**
+     * Width in pixels of the filter extents. The filter will be applied to the
+     * range of pixels within a box of
+     * <code>+/- getSize() / 2</code> around the center of the pixel.
+     *
+     * @return width in pixels
+     */
+    public float getSize();
+
+    /**
+     * Get value of the filter at offset (x, y). The filter should never be
+     * called with values beyond its extents but should return 0 in those cases
+     * anyway.
+     *
+     * @param x x offset in pixels
+     * @param y y offset in pixels
+     * @return value of the filter at the specified location
+     */
+    public float get(float x, float y);
+}

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

@@ -0,0 +1,42 @@
+package org.sunflow.core;
+
+import org.sunflow.image.Color;
+
+/**
+ * This represents a global illumination algorithm. It provides an interface to
+ * compute indirect diffuse bounces of light and make those results available to
+ * shaders.
+ */
+public interface GIEngine {
+
+    /**
+     * This is an optional method for engines that contain a secondary
+     * illumination engine which can return an approximation of the global
+     * radiance in the scene (like a photon map). Engines can safely return
+     * <code>Color.BLACK</code> if they can't or don't wish to support this.
+     *
+     * @param state shading state
+     * @return color approximating global radiance
+     */
+    public Color getGlobalRadiance(ShadingState state);
+
+    /**
+     * Initialize the engine. This is called before rendering begins.
+     *
+     * @return <code>true</code> if the init phase succeeded, <code>false</code>
+     * otherwise
+     */
+    public boolean init(Options options, Scene scene);
+
+    /**
+     * Return the incomming irradiance due to indirect diffuse illumination at
+     * the specified surface point.
+     *
+     * @param state current render state describing the point to be computed
+     * @param diffuseReflectance diffuse albedo of the point being shaded, this
+     * can be used for importance tracking
+     * @return irradiance from indirect diffuse illumination at the specified
+     * point
+     */
+    public Color getIrradiance(ShadingState state, Color diffuseReflectance);
+}

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

@@ -0,0 +1,157 @@
+package org.sunflow.core;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.accel.NullAccelerator;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+/**
+ * This class represent a geometric object in its native object space. These
+ * object are not rendered directly, they must be instanced via
+ * {@link Instance}. This class performs all the bookkeeping needed for
+ * on-demand tesselation and acceleration structure building.
+ */
+public class Geometry implements RenderObject {
+
+    private Tesselatable tesselatable;
+    private PrimitiveList primitives;
+    private AccelerationStructure accel;
+    private int builtAccel;
+    private int builtTess;
+    private String acceltype;
+
+    /**
+     * Create a geometry from the specified tesselatable object. The actual
+     * renderable primitives will be generated on demand.
+     *
+     * @param tesselatable tesselation object
+     */
+    public Geometry(Tesselatable tesselatable) {
+        this.tesselatable = tesselatable;
+        primitives = null;
+        accel = null;
+        builtAccel = 0;
+        builtTess = 0;
+        acceltype = null;
+    }
+
+    /**
+     * Create a geometry from the specified primitive aggregate. The
+     * acceleration structure for this object will be built on demand.
+     *
+     * @param primitives primitive list object
+     */
+    public Geometry(PrimitiveList primitives) {
+        tesselatable = null;
+        this.primitives = primitives;
+        accel = null;
+        builtAccel = 0;
+        builtTess = 1; // already tesselated
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        acceltype = pl.getString("accel", acceltype);
+        // clear up old tesselation if it exists
+        if (tesselatable != null) {
+            primitives = null;
+            builtTess = 0;
+        }
+        // clear acceleration structure so it will be rebuilt
+        accel = null;
+        builtAccel = 0;
+        if (tesselatable != null) {
+            return tesselatable.update(pl, api);
+        }
+        // update primitives
+        return primitives.update(pl, api);
+    }
+
+    int getNumPrimitives() {
+        return primitives == null ? 0 : primitives.getNumPrimitives();
+    }
+
+    BoundingBox getWorldBounds(Matrix4 o2w) {
+        if (primitives == null) {
+
+            BoundingBox b = tesselatable.getWorldBounds(o2w);
+            if (b != null) {
+                return b;
+            }
+            if (builtTess == 0) {
+                tesselate();
+            }
+            if (primitives == null) {
+                return null; // failed tesselation, return infinite bounding
+            }            // box
+        }
+        return primitives.getWorldBounds(o2w);
+    }
+
+    void intersect(Ray r, IntersectionState state) {
+        if (builtTess == 0) {
+            tesselate();
+        }
+        if (builtAccel == 0) {
+            build();
+        }
+        accel.intersect(r, state);
+    }
+
+    private synchronized void tesselate() {
+        // double check flag
+        if (builtTess != 0) {
+            return;
+        }
+        if (tesselatable != null && primitives == null) {
+            UI.printInfo(Module.GEOM, "Tesselating geometry ...");
+            primitives = tesselatable.tesselate();
+            if (primitives == null) {
+                UI.printError(Module.GEOM, "Tesselation failed - geometry will be discarded");
+            } else {
+                UI.printDetailed(Module.GEOM, "Tesselation produced %d primitives", primitives.getNumPrimitives());
+            }
+        }
+        builtTess = 1;
+    }
+
+    private synchronized void build() {
+        // double check flag
+        if (builtAccel != 0) {
+            return;
+        }
+        if (primitives != null) {
+            int n = primitives.getNumPrimitives();
+            if (n >= 1000) {
+                UI.printInfo(Module.GEOM, "Building acceleration structure for %d primitives ...", n);
+            }
+            accel = AccelerationStructureFactory.create(acceltype, n, true);
+            accel.build(primitives);
+        } else {
+            // create an empty accelerator to avoid having to check for null
+            // pointers in the intersect method
+            accel = new NullAccelerator();
+        }
+        builtAccel = 1;
+    }
+
+    void prepareShadingState(ShadingState state) {
+        primitives.prepareShadingState(state);
+    }
+
+    PrimitiveList getBakingPrimitives() {
+        if (builtTess == 0) {
+            tesselate();
+        }
+        if (primitives == null) {
+            return null;
+        }
+        return primitives.getBakingPrimitives();
+    }
+
+    PrimitiveList getPrimitiveList() {
+        return primitives;
+    }
+}

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

@@ -0,0 +1,21 @@
+package org.sunflow.core;
+
+import org.sunflow.image.Color;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+
+/**
+ * Represents a global photon map. This is a structure which can return a rough
+ * approximation of the diffuse radiance at a given surface point.
+ */
+public interface GlobalPhotonMapInterface extends PhotonStore {
+
+    /**
+     * Lookup the global diffuse radiance at the specified surface point.
+     *
+     * @param p surface position
+     * @param n surface normal
+     * @return an approximation of global diffuse radiance at this point
+     */
+    public Color getRadiance(Point3 p, Vector3 n);
+}

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

@@ -0,0 +1,26 @@
+package org.sunflow.core;
+
+/**
+ * This interface represents an image sampling algorithm capable of rendering
+ * the entire image. Implementations are responsible for anti-aliasing and
+ * filtering.
+ */
+public interface ImageSampler {
+
+    /**
+     * Prepare the sampler for rendering an image of w x h pixels
+     *
+     * @param w width of the image
+     * @param h height of the image
+     */
+    public boolean prepare(Options options, Scene scene, int w, int h);
+
+    /**
+     * Render the image to the specified display. The sampler can assume the
+     * display has been opened and that it will be closed after the method
+     * returns.
+     *
+     * @param display Display driver to send image data to
+     */
+    public void render(Display display);
+}

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

@@ -0,0 +1,224 @@
+package org.sunflow.core;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.MovingMatrix4;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+/**
+ * This represents an instance of a {@link Geometry} into the scene. This class
+ * maps object space to world space and maintains a list of shaders and
+ * modifiers attached to the surface.
+ */
+public class Instance implements RenderObject {
+
+    private MovingMatrix4 o2w;
+    private MovingMatrix4 w2o;
+    private BoundingBox bounds;
+    private Geometry geometry;
+    private Shader[] shaders;
+    private Modifier[] modifiers;
+
+    public Instance() {
+        o2w = new MovingMatrix4(null);
+        w2o = new MovingMatrix4(null);
+        bounds = null;
+        geometry = null;
+        shaders = null;
+        modifiers = null;
+    }
+
+    public static Instance createTemporary(PrimitiveList primitives, Matrix4 transform, Shader shader) {
+        Instance i = new Instance();
+        i.o2w = new MovingMatrix4(transform);
+        i.w2o = i.o2w.inverse();
+        if (i.w2o == null) {
+            UI.printError(Module.GEOM, "Unable to compute transform inverse");
+            return null;
+        }
+        i.geometry = new Geometry(primitives);
+        i.shaders = new Shader[]{shader};
+        i.updateBounds();
+        return i;
+    }
+
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        String geometryName = pl.getString("geometry", null);
+        if (geometry == null || geometryName != null) {
+            if (geometryName == null) {
+                UI.printError(Module.GEOM, "geometry parameter missing - unable to create instance");
+                return false;
+            }
+            geometry = api.lookupGeometry(geometryName);
+            if (geometry == null) {
+                UI.printError(Module.GEOM, "Geometry \"%s\" was not declared yet - instance is invalid", geometryName);
+                return false;
+            }
+        }
+        String[] shaderNames = pl.getStringArray("shaders", null);
+        if (shaderNames != null) {
+            // new shader names have been provided
+            shaders = new Shader[shaderNames.length];
+            for (int i = 0; i < shaders.length; i++) {
+                shaders[i] = api.lookupShader(shaderNames[i]);
+                if (shaders[i] == null) {
+                    UI.printWarning(Module.GEOM, "Shader \"%s\" was not declared yet - ignoring", shaderNames[i]);
+                }
+            }
+        } else {
+            // re-use existing shader array
+        }
+        String[] modifierNames = pl.getStringArray("modifiers", null);
+        if (modifierNames != null) {
+            // new modifier names have been provided
+            modifiers = new Modifier[modifierNames.length];
+            for (int i = 0; i < modifiers.length; i++) {
+                modifiers[i] = api.lookupModifier(modifierNames[i]);
+                if (modifiers[i] == null) {
+                    UI.printWarning(Module.GEOM, "Modifier \"%s\" was not declared yet - ignoring", modifierNames[i]);
+                }
+            }
+        }
+        o2w = pl.getMovingMatrix("transform", o2w);
+        w2o = o2w.inverse();
+        if (w2o == null) {
+            UI.printError(Module.GEOM, "Unable to compute transform inverse");
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Recompute world space bounding box of this instance.
+     */
+    public void updateBounds() {
+        bounds = geometry.getWorldBounds(o2w.getData(0));
+        for (int i = 1; i < o2w.numSegments(); i++) {
+            bounds.include(geometry.getWorldBounds(o2w.getData(i)));
+        }
+    }
+
+    /**
+     * Checks to see if this instance is relative to the specified geometry.
+     *
+     * @param g geometry to check against
+     * @return <code>true</code> if the instanced geometry is equals to g,
+     * <code>false</code> otherwise
+     */
+    public boolean hasGeometry(Geometry g) {
+        return geometry == g;
+    }
+
+    /**
+     * Remove the specified shader from the instance's list if it is being used.
+     *
+     * @param s shader to remove
+     */
+    public void removeShader(Shader s) {
+        if (shaders != null) {
+            for (int i = 0; i < shaders.length; i++) {
+                if (shaders[i] == s) {
+                    shaders[i] = null;
+                }
+            }
+        }
+    }
+
+    /**
+     * Remove the specified modifier from the instance's list if it is being
+     * used.
+     *
+     * @param m modifier to remove
+     */
+    public void removeModifier(Modifier m) {
+        if (modifiers != null) {
+            for (int i = 0; i < modifiers.length; i++) {
+                if (modifiers[i] == m) {
+                    modifiers[i] = null;
+                }
+            }
+        }
+    }
+
+    /**
+     * Get the world space bounding box for this instance.
+     *
+     * @return bounding box in world space
+     */
+    public BoundingBox getBounds() {
+        return bounds;
+    }
+
+    int getNumPrimitives() {
+        return geometry.getNumPrimitives();
+    }
+
+    void intersect(Ray r, IntersectionState state) {
+        Ray localRay = r.transform(w2o.sample(state.time));
+        state.current = this;
+        geometry.intersect(localRay, state);
+        // FIXME: transfer max distance to current ray
+        r.setMax(localRay.getMax());
+    }
+
+    /**
+     * Prepare the shading state for shader invocation. This also runs the
+     * currently attached surface modifier.
+     *
+     * @param state shading state to be prepared
+     */
+    public void prepareShadingState(ShadingState state) {
+        geometry.prepareShadingState(state);
+        if (state.getNormal() != null && state.getGeoNormal() != null) {
+            state.correctShadingNormal();
+        }
+        // run modifier if it was provided
+        if (state.getModifier() != null) {
+            state.getModifier().modify(state);
+        }
+    }
+
+    /**
+     * Get a shader for the instance's list.
+     *
+     * @param i index into the shader list
+     * @return requested shader, or <code>null</code> if the input is invalid
+     */
+    public Shader getShader(int i) {
+        if (shaders == null || i < 0 || i >= shaders.length) {
+            return null;
+        }
+        return shaders[i];
+    }
+
+    /**
+     * Get a modifier for the instance's list.
+     *
+     * @param i index into the modifier list
+     * @return requested modifier, or <code>null</code> if the input is invalid
+     */
+    public Modifier getModifier(int i) {
+        if (modifiers == null || i < 0 || i >= modifiers.length) {
+            return null;
+        }
+        return modifiers[i];
+    }
+
+    Matrix4 getObjectToWorld(float time) {
+        return o2w.sample(time);
+    }
+
+    Matrix4 getWorldToObject(float time) {
+        return w2o.sample(time);
+    }
+
+    PrimitiveList getBakingPrimitives() {
+        return geometry.getBakingPrimitives();
+    }
+
+    Geometry getGeometry() {
+        return geometry;
+    }
+}