joonsrenderer 1.1-java

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

@@ -0,0 +1,125 @@
+package org.sunflow;
+
+import org.sunflow.core.Display;
+import org.sunflow.core.display.FastDisplay;
+import org.sunflow.core.display.FileDisplay;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.Timer;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+import org.sunflow.system.ui.ConsoleInterface;
+
+public class RealtimeBenchmark extends SunflowAPI {
+    final String CAMERA = "camera";
+    final String TRANSFORM = "transform";
+    public RealtimeBenchmark(boolean showGUI, int threads) {
+        Display display = showGUI ? new FastDisplay() : new FileDisplay(false);
+        UI.printInfo(Module.BENCH, "Preparing benchmarking scene ...");
+        // settings
+        parameter("threads", threads);
+        // spawn regular priority threads
+        parameter("threads.lowPriority", false);
+        parameter("resolutionX", 512);
+        parameter("resolutionY", 512);
+        parameter("aa.min", -3);
+        parameter("aa.max", 0);
+        parameter("depths.diffuse", 1);
+        parameter("depths.reflection", 1);
+        parameter("depths.refraction", 0);
+        parameter("bucket.order", "hilbert");
+        parameter("bucket.size", 32);
+        options(SunflowAPI.DEFAULT_OPTIONS);
+        // camera
+        Point3 eye = new Point3(30, 0, 10.967f);
+        Point3 target = new Point3(0, 0, 5.4f);
+        Vector3 up = new Vector3(0, 0, 1);
+        parameter(TRANSFORM, Matrix4.lookAt(eye, target, up));
+        parameter("fov", 45.0f);
+        camera(CAMERA, "pinhole");
+        parameter(CAMERA, CAMERA);
+        options(SunflowAPI.DEFAULT_OPTIONS);
+        // geometry
+        createGeometry();
+        // this first render is not timed, it caches the acceleration data
+        // structures and tesselations so they won't be
+        // included in the main timing
+        UI.printInfo(Module.BENCH, "Rendering warmup frame ...");
+        render(SunflowAPI.DEFAULT_OPTIONS, display);
+        // now disable all output - and run the benchmark
+        UI.set(null);
+        Timer t = new Timer();
+        t.start();
+        float phi = 0;
+        int frames = 0;
+        while (phi < 4 * Math.PI) {
+            eye.x = 30 * (float) Math.cos(phi);
+            eye.y = 30 * (float) Math.sin(phi);
+            phi += Math.PI / 30;
+            frames++;
+            // update camera
+            parameter(TRANSFORM, Matrix4.lookAt(eye, target, up));
+            camera(CAMERA, null);
+            render(SunflowAPI.DEFAULT_OPTIONS, display);
+        }
+        t.end();
+        UI.set(new ConsoleInterface());
+        UI.printInfo(Module.BENCH, "Benchmark results:");
+        UI.printInfo(Module.BENCH, "  * Average FPS:         %.2f", frames / t.seconds());
+        UI.printInfo(Module.BENCH, "  * Total time:          %s", t);
+    }
+
+    private void createGeometry() {
+        // light source
+        parameter("source", new Point3(-15.5945f, -30.0581f, 45.967f));
+        parameter("dir", new Vector3(15.5945f, 30.0581f, -45.967f));
+        parameter("radius", 60.0f);
+        parameter("radiance", null, 3, 3, 3);
+        light("light", "directional");
+
+        // gi-engine
+        parameter("gi.engine", "fake");
+        parameter("gi.fake.sky", null, 0.25f, 0.25f, 0.25f);
+        parameter("gi.fake.ground", null, 0.01f, 0.01f, 0.5f);
+        parameter("gi.fake.up", new Vector3(0, 0, 1));
+        options(DEFAULT_OPTIONS);
+
+        // shaders
+        parameter("diffuse", null, 0.5f, 0.5f, 0.5f);
+        shader("default", "diffuse");
+        parameter("diffuse", null, 0.5f, 0.5f, 0.5f);
+        parameter("shiny", 0.2f);
+        shader("refl", "shiny_diffuse");
+        // objects
+
+        // teapot
+        parameter("subdivs", 10);
+        geometry("teapot", "teapot");
+        parameter("shaders", "default");
+        Matrix4 m = Matrix4.IDENTITY;
+        m = Matrix4.scale(0.075f).multiply(m);
+        m = Matrix4.rotateZ((float) Math.toRadians(-45f)).multiply(m);
+        m = Matrix4.translation(-7, 0, 0).multiply(m);
+        parameter(TRANSFORM, m);
+        instance("teapot.instance", "teapot");
+
+        // gumbo
+        parameter("subdivs", 10);
+        geometry("gumbo", "gumbo");
+        m = Matrix4.IDENTITY;
+        m = Matrix4.scale(0.5f).multiply(m);
+        m = Matrix4.rotateZ((float) Math.toRadians(25f)).multiply(m);
+        m = Matrix4.translation(3, -7, 0).multiply(m);
+        parameter("shaders", "default");
+        parameter(TRANSFORM, m);
+        instance("gumbo.instance", "gumbo");
+
+        // ground plane
+        parameter("center", new Point3(0, 0, 0));
+        parameter("normal", new Vector3(0, 0, 1));
+        geometry("ground", "plane");
+        parameter("shaders", "refl");
+        instance("ground.instance", "ground");
+    }
+}

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

@@ -0,0 +1,344 @@
+package org.sunflow;
+
+import java.util.ArrayList;
+import java.util.Locale;
+
+import org.sunflow.core.Camera;
+import org.sunflow.core.Geometry;
+import org.sunflow.core.Instance;
+import org.sunflow.core.LightSource;
+import org.sunflow.core.Modifier;
+import org.sunflow.core.Options;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.PrimitiveList;
+import org.sunflow.core.RenderObject;
+import org.sunflow.core.Scene;
+import org.sunflow.core.Shader;
+import org.sunflow.core.Tesselatable;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+import org.sunflow.util.FastHashMap;
+
+final class RenderObjectMap {
+
+    private FastHashMap<String, RenderObjectHandle> renderObjects;
+    private boolean rebuildInstanceList;
+    private boolean rebuildLightList;
+
+    private enum RenderObjectType {
+
+        UNKNOWN, SHADER, MODIFIER, GEOMETRY, INSTANCE, LIGHT, CAMERA, OPTIONS
+    }
+
+    RenderObjectMap() {
+        renderObjects = new FastHashMap<>();
+        rebuildInstanceList = rebuildLightList = false;
+    }
+
+    final boolean has(String name) {
+        return renderObjects.containsKey(name);
+    }
+
+    final void remove(String name) {
+        RenderObjectHandle obj = renderObjects.get(name);
+        if (obj == null) {
+            UI.printWarning(Module.API, "Unable to remove \"%s\" - object was not defined yet");
+            return;
+        }
+        UI.printDetailed(Module.API, "Removing object \"%s\"", name);
+        renderObjects.remove(name);
+        // scan through all objects to make sure we don't have any
+        // references to the old object still around
+        switch (obj.type) {
+            case SHADER:
+                Shader s = obj.getShader();
+                for (FastHashMap.Entry<String, RenderObjectHandle> e : renderObjects) {
+                    Instance i = e.getValue().getInstance();
+                    if (i != null) {
+                        UI.printWarning(Module.API, "Removing shader \"%s\" from instance \"%s\"", name, e.getKey());
+                        i.removeShader(s);
+                    }
+                }
+                break;
+            case MODIFIER:
+                Modifier m = obj.getModifier();
+                for (FastHashMap.Entry<String, RenderObjectHandle> e : renderObjects) {
+                    Instance i = e.getValue().getInstance();
+                    if (i != null) {
+                        UI.printWarning(Module.API, "Removing modifier \"%s\" from instance \"%s\"", name, e.getKey());
+                        i.removeModifier(m);
+                    }
+                }
+                break;
+            case GEOMETRY: {
+                Geometry g = obj.getGeometry();
+                for (FastHashMap.Entry<String, RenderObjectHandle> e : renderObjects) {
+                    Instance i = e.getValue().getInstance();
+                    if (i != null && i.hasGeometry(g)) {
+                        UI.printWarning(Module.API, "Removing instance \"%s\" because it referenced geometry \"%s\"", e.getKey(), name);
+                        remove(e.getKey());
+                    }
+                }
+                break;
+            }
+            case INSTANCE:
+                rebuildInstanceList = true;
+                break;
+            case LIGHT:
+                rebuildLightList = true;
+                break;
+            default:
+                // no dependencies
+                break;
+        }
+    }
+
+    final boolean update(String name, ParameterList pl, SunflowAPI api) {
+        RenderObjectHandle obj = renderObjects.get(name);
+        boolean success;
+        if (obj == null) {
+            UI.printError(Module.API, "Unable to update \"%s\" - object was not defined yet", name);
+            success = false;
+        } else {
+            UI.printDetailed(Module.API, "Updating %s object \"%s\"", obj.typeName(), name);
+            success = obj.update(pl, api);
+            if (!success) {
+                UI.printError(Module.API, "Unable to update \"%s\" - removing", name);
+                remove(name);
+            } else {
+                switch (obj.type) {
+                    case GEOMETRY:
+                    case INSTANCE:
+                        rebuildInstanceList = true;
+                        break;
+                    case LIGHT:
+                        rebuildLightList = true;
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        return success;
+    }
+
+    final void updateScene(Scene scene) {
+        if (rebuildInstanceList) {
+            UI.printInfo(Module.API, "Building scene instance list for rendering ...");
+            int numInfinite = 0, numInstance = 0;
+            for (FastHashMap.Entry<String, RenderObjectHandle> e : renderObjects) {
+                Instance i = e.getValue().getInstance();
+                if (i != null) {
+                    i.updateBounds();
+                    if (i.getBounds() == null) {
+                        numInfinite++;
+                    } else if (!i.getBounds().isEmpty()) {
+                        numInstance++;
+                    } else {
+                        UI.printWarning(Module.API, "Ignoring empty instance: \"%s\"", e.getKey());
+                    }
+                }
+            }
+            Instance[] infinite = new Instance[numInfinite];
+            Instance[] instance = new Instance[numInstance];
+            numInfinite = numInstance = 0;
+            for (FastHashMap.Entry<String, RenderObjectHandle> e : renderObjects) {
+                Instance i = e.getValue().getInstance();
+                if (i != null) {
+                    if (i.getBounds() == null) {
+                        infinite[numInfinite] = i;
+                        numInfinite++;
+                    } else if (!i.getBounds().isEmpty()) {
+                        instance[numInstance] = i;
+                        numInstance++;
+                    }
+                }
+            }
+            scene.setInstanceLists(instance, infinite);
+            rebuildInstanceList = false;
+        }
+        if (rebuildLightList) {
+            UI.printInfo(Module.API, "Building scene light list for rendering ...");
+            ArrayList<LightSource> lightList = new ArrayList<>();
+            for (FastHashMap.Entry<String, RenderObjectHandle> e : renderObjects) {
+                LightSource light = e.getValue().getLight();
+                if (light != null) {
+                    lightList.add(light);
+                }
+
+            }
+            scene.setLightList(lightList.toArray(new LightSource[lightList.size()]));
+            rebuildLightList = false;
+        }
+    }
+
+    final void put(String name, Shader shader) {
+        renderObjects.put(name, new RenderObjectHandle(shader));
+    }
+
+    final void put(String name, Modifier modifier) {
+        renderObjects.put(name, new RenderObjectHandle(modifier));
+    }
+
+    final void put(String name, PrimitiveList primitives) {
+        renderObjects.put(name, new RenderObjectHandle(primitives));
+    }
+
+    final void put(String name, Tesselatable tesselatable) {
+        renderObjects.put(name, new RenderObjectHandle(tesselatable));
+    }
+
+    final void put(String name, Instance instance) {
+        renderObjects.put(name, new RenderObjectHandle(instance));
+    }
+
+    final void put(String name, LightSource light) {
+        renderObjects.put(name, new RenderObjectHandle(light));
+    }
+
+    final void put(String name, Camera camera) {
+        renderObjects.put(name, new RenderObjectHandle(camera));
+    }
+
+    final void put(String name, Options options) {
+        renderObjects.put(name, new RenderObjectHandle(options));
+    }
+
+    final Geometry lookupGeometry(String name) {
+        if (name == null) {
+            return null;
+        }
+        RenderObjectHandle handle = renderObjects.get(name);
+        return (handle == null) ? null : handle.getGeometry();
+    }
+
+    final Instance lookupInstance(String name) {
+        if (name == null) {
+            return null;
+        }
+        RenderObjectHandle handle = renderObjects.get(name);
+        return (handle == null) ? null : handle.getInstance();
+    }
+
+    final Camera lookupCamera(String name) {
+        if (name == null) {
+            return null;
+        }
+        RenderObjectHandle handle = renderObjects.get(name);
+        return (handle == null) ? null : handle.getCamera();
+    }
+
+    final Options lookupOptions(String name) {
+        if (name == null) {
+            return null;
+        }
+        RenderObjectHandle handle = renderObjects.get(name);
+        return (handle == null) ? null : handle.getOptions();
+    }
+
+    final Shader lookupShader(String name) {
+        if (name == null) {
+            return null;
+        }
+        RenderObjectHandle handle = renderObjects.get(name);
+        return (handle == null) ? null : handle.getShader();
+    }
+
+    final Modifier lookupModifier(String name) {
+        if (name == null) {
+            return null;
+        }
+        RenderObjectHandle handle = renderObjects.get(name);
+        return (handle == null) ? null : handle.getModifier();
+    }
+
+    final LightSource lookupLight(String name) {
+        if (name == null) {
+            return null;
+        }
+        RenderObjectHandle handle = renderObjects.get(name);
+        return (handle == null) ? null : handle.getLight();
+    }
+
+    private static final class RenderObjectHandle {
+
+        private final RenderObject obj;
+        private final RenderObjectType type;
+
+        private RenderObjectHandle(Shader shader) {
+            obj = shader;
+            type = RenderObjectType.SHADER;
+        }
+
+        private RenderObjectHandle(Modifier modifier) {
+            obj = modifier;
+            type = RenderObjectType.MODIFIER;
+        }
+
+        private RenderObjectHandle(Tesselatable tesselatable) {
+            obj = new Geometry(tesselatable);
+            type = RenderObjectType.GEOMETRY;
+        }
+
+        private RenderObjectHandle(PrimitiveList prims) {
+            obj = new Geometry(prims);
+            type = RenderObjectType.GEOMETRY;
+        }
+
+        private RenderObjectHandle(Instance instance) {
+            obj = instance;
+            type = RenderObjectType.INSTANCE;
+        }
+
+        private RenderObjectHandle(LightSource light) {
+            obj = light;
+            type = RenderObjectType.LIGHT;
+        }
+
+        private RenderObjectHandle(Camera camera) {
+            obj = camera;
+            type = RenderObjectType.CAMERA;
+        }
+
+        private RenderObjectHandle(Options options) {
+            obj = options;
+            type = RenderObjectType.OPTIONS;
+        }
+
+        private boolean update(ParameterList pl, SunflowAPI api) {
+            return obj.update(pl, api);
+        }
+
+        private String typeName() {
+            return type.name().toLowerCase(Locale.ENGLISH);
+        }
+
+        private Shader getShader() {
+            return (type == RenderObjectType.SHADER) ? (Shader) obj : null;
+        }
+
+        private Modifier getModifier() {
+            return (type == RenderObjectType.MODIFIER) ? (Modifier) obj : null;
+        }
+
+        private Geometry getGeometry() {
+            return (type == RenderObjectType.GEOMETRY) ? (Geometry) obj : null;
+        }
+
+        private Instance getInstance() {
+            return (type == RenderObjectType.INSTANCE) ? (Instance) obj : null;
+        }
+
+        private LightSource getLight() {
+            return (type == RenderObjectType.LIGHT) ? (LightSource) obj : null;
+        }
+
+        private Camera getCamera() {
+            return (type == RenderObjectType.CAMERA) ? (Camera) obj : null;
+        }
+
+        private Options getOptions() {
+            return (type == RenderObjectType.OPTIONS) ? (Options) obj : null;
+        }
+    }
+}