joonsrenderer 1.1-java

data/src/main/java/org/sunflow/SunflowAPIInterface.java

@@ -0,0 +1,277 @@
+package org.sunflow;
+
+import org.sunflow.core.Display;
+import org.sunflow.core.PrimitiveList;
+import org.sunflow.core.RenderObject;
+import org.sunflow.core.Tesselatable;
+import org.sunflow.core.ParameterList.InterpolationType;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.Point2;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+
+/**
+ * This interface represents the entry point for rendering scenes using Sunflow.
+ * Classes which implement this interface are able to receive input from any of
+ * the Sunflow parsers.
+ */
+public interface SunflowAPIInterface {
+
+    /**
+     * Reset the state of the API completely. The object table is cleared, and
+     * all search paths are set back to their default values.
+     */
+    public void reset();
+
+    /**
+     * Declare a plugin of the specified type with the given name from a java
+     * code string. The code will be compiled with Janino and registered as a
+     * new plugin type upon success.
+     *
+     * @param type
+     * @param name
+     * @param code
+     */
+    public void plugin(String type, String name, String code);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, String value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, boolean value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, int value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, float value);
+
+    /**
+     * Declare a color parameter in the given colorspace using the specified
+     * name and value. This parameter will be added to the currently active
+     * parameter list.
+     *
+     * @param name parameter name
+     * @param colorspace color space or <code>null</code> to assume internal
+     * color space
+     * @param data floating point color data
+     */
+    public void parameter(String name, String colorspace, float... data);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, Point3 value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, Vector3 value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, Point2 value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, Matrix4 value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, int[] value);
+
+    /**
+     * Declare a parameter with the specified name and value. This parameter
+     * will be added to the currently active parameter list.
+     *
+     * @param name parameter name
+     * @param value parameter value
+     */
+    public void parameter(String name, String[] value);
+
+    /**
+     * Declare a parameter with the specified name. The type may be one of the
+     * follow: "float", "point", "vector", "texcoord", "matrix". The
+     * interpolation determines how the parameter is to be interpreted over
+     * surface (see {@link InterpolationType}). The data is specified in a
+     * flattened float array.
+     *
+     * @param name parameter name
+     * @param type parameter data type
+     * @param interpolation parameter interpolation mode
+     * @param data raw floating point data
+     */
+    public void parameter(String name, String type, String interpolation, float[] data);
+
+    /**
+     * Remove the specified render object. Note that this may cause the removal
+     * of other objects which depended on it.
+     *
+     * @param name name of the object to remove
+     */
+    public void remove(String name);
+
+    /**
+     * Add the specified path to the list of directories which are searched
+     * automatically to resolve scene filenames or textures. Currently the
+     * supported searchpath types are: "include" and "texture". All other types
+     * will be ignored.
+     *
+     * @param type
+     * @param path
+     */
+    public void searchpath(String type, String path);
+
+    /**
+     * Defines a shader with a given name. If the shader type name is left
+     * <code>null</code>, the shader with the given name will be updated (if it
+     * exists).
+     *
+     * @param name a unique name given to the shader
+     * @param shaderType a shader plugin type
+     */
+    public void shader(String name, String shaderType);
+
+    /**
+     * Defines a modifier with a given name. If the modifier type name is left
+     * <code>null</code>, the modifier with the given name will be updated (if
+     * it exists).
+     *
+     * @param name a unique name given to the modifier
+     * @param modifierType a modifier plugin type name
+     */
+    public void modifier(String name, String modifierType);
+
+    /**
+     * Defines a geometry with a given name. The geometry is built from the
+     * specified type. Note that geometries may be created from
+     * {@link Tesselatable} objects or {@link PrimitiveList} objects. This means
+     * that two seperate plugin lists will be searched for the geometry type.
+     * {@link Tesselatable} objects are search first. If the type name is left
+     * <code>null</code>, the geometry with the given name will be updated (if
+     * it exists).
+     *
+     * @param name a unique name given to the geometry
+     * @param typeName a tesselatable or primitive plugin type name
+     */
+    public void geometry(String name, String typeName);
+
+    /**
+     * Instance the specified geometry into the scene. If geoname is
+     * <code>null</code>, the specified instance object will be updated (if it
+     * exists). In order to change the instancing relationship of an existing
+     * instance, you should use the "geometry" string attribute.
+     *
+     * @param name instance name
+     * @param geoname name of the geometry to instance
+     */
+    public void instance(String name, String geoname);
+
+    /**
+     * Defines a light source with a given name. If the light type name is left
+     * <code>null</code>, the light source with the given name will be updated
+     * (if it exists).
+     *
+     * @param name a unique name given to the light source
+     * @param lightType a light source plugin type name
+     */
+    public void light(String name, String lightType);
+
+    /**
+     * Defines a camera with a given name. The camera is built from the
+     * specified camera lens type plugin. If the lens type name is left
+     * <code>null</code>, the camera with the given name will be updated (if it
+     * exists). It is not currently possible to change the lens of a camera
+     * after it has been created.
+     *
+     * @param name camera name
+     * @param lensType a camera lens plugin type name
+     */
+    public void camera(String name, String lensType);
+
+    /**
+     * Defines an option object to hold the current parameters. If the object
+     * already exists, the values will simply override previous ones.
+     *
+     * @param name
+     */
+    public void options(String name);
+
+    /**
+     * Render using the specified options and the specified display. If the
+     * specified options do not exist - defaults will be used.
+     *
+     * @param optionsName name of the {@link RenderObject} which contains the
+     * options
+     * @param display display object
+     */
+    public void render(String optionsName, Display display);
+
+    /**
+     * Parse the specified filename. The include paths are searched first. The
+     * contents of the file are simply added to the active scene. This allows to
+     * break up a scene into parts, even across file formats. The appropriate
+     * parser is chosen based on file extension.
+     *
+     * @param filename filename to load
+     * @return <code>true</code> upon sucess, <code>false</code> if an error
+     * occured.
+     */
+    public boolean include(String filename);
+
+    /**
+     * Set the value of the current frame. This value is intended only for
+     * procedural animation creation. It is not used by the Sunflow core in
+     * anyway. The default value is 1.
+     *
+     * @param currentFrame current frame number
+     */
+    public void currentFrame(int currentFrame);
+}

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

@@ -0,0 +1,20 @@
+package org.sunflow.core;
+
+public interface AccelerationStructure {
+
+    /**
+     * Construct an acceleration structure for the specified primitive list.
+     *
+     * @param primitives
+     */
+    public void build(PrimitiveList primitives);
+
+    /**
+     * Intersect the specified ray with the geometry in local space. The ray
+     * will be provided in local space.
+     *
+     * @param r ray in local space
+     * @param istate state to store the intersection into
+     */
+    public void intersect(Ray r, IntersectionState istate);
+}

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

@@ -0,0 +1,36 @@
+package org.sunflow.core;
+
+import org.sunflow.PluginRegistry;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+class AccelerationStructureFactory {
+
+    static AccelerationStructure create(String name, int n, boolean primitives) {
+        if (name == null || name.equals("auto")) {
+            if (primitives) {
+                if (n > 20000000) {
+                    name = "uniformgrid";
+                } else if (n > 2000000) {
+                    name = "bih";
+                } else if (n > 2) {
+                    name = "kdtree";
+                } else {
+                    name = "null";
+                }
+            } else {
+                if (n > 2) {
+                    name = "bih";
+                } else {
+                    name = "null";
+                }
+            }
+        }
+        AccelerationStructure accel = PluginRegistry.ACCEL_PLUGINS.createObject(name);
+        if (accel == null) {
+            UI.printWarning(Module.ACCEL, "Unrecognized intersection accelerator \"%s\" - using auto", name);
+            return create(null, n, primitives);
+        }
+        return accel;
+    }
+}

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

@@ -0,0 +1,21 @@
+package org.sunflow.core;
+
+/**
+ * Creates an array of coordinates that iterate over the tiled screen. Classes
+ * which implement this interface are responsible for guarenteeing the entire
+ * screen is tiled. No attempt is made to check for duplicates or incomplete
+ * coverage.
+ */
+public interface BucketOrder {
+
+    /**
+     * Computes the order in which each coordinate on the screen should be
+     * visited.
+     *
+     * @param nbw number of buckets in the X direction
+     * @param nbh number of buckets in the Y direction
+     * @return array of coordinates with interleaved X, Y of the positions of
+     * buckets to be rendered.
+     */
+    int[] getBucketSequence(int nbw, int nbh);
+}

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

@@ -0,0 +1,125 @@
+package org.sunflow.core;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.MovingMatrix4;
+import org.sunflow.math.Point3;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+/**
+ * This class represents a camera to the renderer. It handles the mapping of
+ * camera space to world space, as well as the mounting of {@link CameraLens}
+ * objects which compute the actual projection.
+ */
+public class Camera implements RenderObject {
+
+    private final CameraLens lens;
+    private float shutterOpen;
+    private float shutterClose;
+    private MovingMatrix4 c2w;
+    private MovingMatrix4 w2c;
+
+    public Camera(CameraLens lens) {
+        this.lens = lens;
+        c2w = new MovingMatrix4(null);
+        w2c = new MovingMatrix4(null);
+        shutterOpen = shutterClose = 0;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        shutterOpen = pl.getFloat("shutter.open", shutterOpen);
+        shutterClose = pl.getFloat("shutter.close", shutterClose);
+        c2w = pl.getMovingMatrix("transform", c2w);
+        w2c = c2w.inverse();
+        if (w2c == null) {
+            UI.printWarning(Module.CAM, "Unable to compute camera's inverse transform");
+            return false;
+        }
+        return lens.update(pl, api);
+    }
+
+    /**
+     * Computes actual time from a time sample in the interval [0,1). This
+     * random number is mapped somewhere between the shutterOpen and
+     * shutterClose times.
+     *
+     * @param time
+     * @return
+     */
+    public float getTime(float time) {
+        if (shutterOpen >= shutterClose) {
+            return shutterOpen;
+        }
+        // warp the time sample by a tent filter - this helps simulates the
+        // behaviour of a standard shutter as explained here:
+        // "Shutter Efficiency and Temporal Sampling" by "Ian Stephenson"
+        // http://www.dctsystems.co.uk/Text/shutter.pdf
+        if (time < 0.5) {
+            time = -1 + (float) Math.sqrt(2 * time);
+        } else {
+            time = 1 - (float) Math.sqrt(2 - 2 * time);
+        }
+        time = 0.5f * (time + 1);
+        return (1 - time) * shutterOpen + time * shutterClose;
+    }
+
+    /**
+     * Generate a ray passing though the specified point on the image plane.
+     * Additional random variables are provided for the lens to optionally
+     * compute depth-of-field or motion blur effects. Note that the camera may
+     * return
+     * <code>null</code> for invalid arguments or for pixels which don't project
+     * to anything.
+     *
+     * @param x x pixel coordinate
+     * @param y y pixel coordinate
+     * @param imageWidth width of the image in pixels
+     * @param imageHeight height of the image in pixels
+     * @param lensX a random variable in [0,1) to be used for DOF sampling
+     * @param lensY a random variable in [0,1) to be used for DOF sampling
+     * @param time a random variable in [0,1) to be used for motion blur
+     * sampling
+     * @return a ray passing through the specified pixel, or <code>null</code>
+     */
+    public Ray getRay(float x, float y, int imageWidth, int imageHeight, double lensX, double lensY, float time) {
+        Ray r = lens.getRay(x, y, imageWidth, imageHeight, lensX, lensY, time);
+        if (r != null) {
+            // transform from camera space to world space
+            r = r.transform(c2w.sample(time));
+            // renormalize to account for scale factors embeded in the transform
+            r.normalize();
+        }
+        return r;
+    }
+
+    /**
+     * Generate a ray from the origin of camera space toward the specified
+     * point.
+     *
+     * @param p point in world space
+     * @return ray from the origin of camera space to the specified point
+     */
+    Ray getRay(Point3 p, float time) {
+        return new Ray(c2w == null ? new Point3(0, 0, 0) : c2w.sample(time).transformP(new Point3(0, 0, 0)), p);
+    }
+
+    /**
+     * Returns a transformation matrix mapping camera space to world space.
+     *
+     * @return a transformation matrix
+     */
+    Matrix4 getCameraToWorld(float time) {
+        return c2w == null ? Matrix4.IDENTITY : c2w.sample(time);
+    }
+
+    /**
+     * Returns a transformation matrix mapping world space to camera space.
+     *
+     * @return a transformation matrix
+     */
+    Matrix4 getWorldToCamera(float time) {
+        return w2c == null ? Matrix4.IDENTITY : w2c.sample(time);
+    }
+}