joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/shader/IDShader.java

@@ -0,0 +1,27 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.Vector3;
+
+public class IDShader implements Shader {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        Vector3 n = state.getNormal();
+        float f = n == null ? 1.0f : Math.abs(state.getRay().dot(n));
+        return new Color(state.getInstance().hashCode()).mul(f);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

data/src/main/java/org/sunflow/core/shader/MirrorShader.java

@@ -0,0 +1,68 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.Vector3;
+
+public class MirrorShader implements Shader {
+
+    private Color color;
+
+    public MirrorShader() {
+        color = Color.WHITE;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        color = pl.getColor("color", color);
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        if (!state.includeSpecular()) {
+            return Color.BLACK;
+        }
+        state.faceforward();
+        float cos = state.getCosND();
+        float dn = 2 * cos;
+        Vector3 refDir = new Vector3();
+        refDir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
+        refDir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
+        refDir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
+        Ray refRay = new Ray(state.getPoint(), refDir);
+
+        // compute Fresnel term
+        cos = 1 - cos;
+        float cos2 = cos * cos;
+        float cos5 = cos2 * cos2 * cos;
+        Color ret = Color.white();
+        ret.sub(color);
+        ret.mul(cos5);
+        ret.add(color);
+        return ret.mul(state.traceReflection(refRay, 0));
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+        float avg = color.getAverage();
+        double rnd = state.getRandom(0, 0, 1);
+        if (rnd >= avg) {
+            return;
+        }
+        state.faceforward();
+        float cos = state.getCosND();
+        power.mul(color).mul(1.0f / avg);
+        // photon is reflected
+        float dn = 2 * cos;
+        Vector3 dir = new Vector3();
+        dir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
+        dir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
+        dir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
+        state.traceReflectionPhoton(new Ray(state.getPoint(), dir), power);
+    }
+}

data/src/main/java/org/sunflow/core/shader/NormalShader.java

@@ -0,0 +1,32 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.Vector3;
+
+public class NormalShader implements Shader {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        Vector3 n = state.getNormal();
+        if (n == null) {
+            return Color.BLACK;
+        }
+        float r = (n.x + 1) * 0.5f;
+        float g = (n.y + 1) * 0.5f;
+        float b = (n.z + 1) * 0.5f;
+        return new Color(r, g, b);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

data/src/main/java/org/sunflow/core/shader/PhongShader.java

@@ -0,0 +1,89 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Vector3;
+
+public class PhongShader implements Shader {
+
+    private Color diff;
+    private Color spec;
+    private float power;
+    private int numRays;
+
+    public PhongShader() {
+        diff = Color.GRAY;
+        spec = Color.GRAY;
+        power = 20;
+        numRays = 4;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        diff = pl.getColor("diffuse", diff);
+        spec = pl.getColor("specular", spec);
+        power = pl.getFloat("power", power);
+        numRays = pl.getInt("samples", numRays);
+        return true;
+    }
+
+    protected Color getDiffuse(ShadingState state) {
+        return diff;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        // make sure we are on the right side of the material
+        state.faceforward();
+        // setup lighting
+        state.initLightSamples();
+        state.initCausticSamples();
+        // execute shader
+        return state.diffuse(getDiffuse(state)).add(state.specularPhong(spec, power, numRays));
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+        // make sure we are on the right side of the material
+        state.faceforward();
+        Color d = getDiffuse(state);
+        state.storePhoton(state.getRay().getDirection(), power, d);
+        float avgD = d.getAverage();
+        float avgS = spec.getAverage();
+        double rnd = state.getRandom(0, 0, 1);
+        if (rnd < avgD) {
+            // photon is scattered diffusely
+            power.mul(d).mul(1.0f / avgD);
+            OrthoNormalBasis onb = state.getBasis();
+            double u = 2 * Math.PI * rnd / avgD;
+            double v = state.getRandom(0, 1, 1);
+            float s = (float) Math.sqrt(v);
+            float s1 = (float) Math.sqrt(1.0f - v);
+            Vector3 w = new Vector3((float) Math.cos(u) * s, (float) Math.sin(u) * s, s1);
+            w = onb.transform(w, new Vector3());
+            state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
+        } else if (rnd < avgD + avgS) {
+            // photon is scattered specularly
+            float dn = 2.0f * state.getCosND();
+            // reflected direction
+            Vector3 refDir = new Vector3();
+            refDir.x = (dn * state.getNormal().x) + state.getRay().dx;
+            refDir.y = (dn * state.getNormal().y) + state.getRay().dy;
+            refDir.z = (dn * state.getNormal().z) + state.getRay().dz;
+            power.mul(spec).mul(1.0f / avgS);
+            OrthoNormalBasis onb = state.getBasis();
+            double u = 2 * Math.PI * (rnd - avgD) / avgS;
+            double v = state.getRandom(0, 1, 1);
+            float s = (float) Math.pow(v, 1 / (this.power + 1));
+            float s1 = (float) Math.sqrt(1 - s * s);
+            Vector3 w = new Vector3((float) Math.cos(u) * s1, (float) Math.sin(u) * s1, s);
+            w = onb.transform(w, new Vector3());
+            state.traceReflectionPhoton(new Ray(state.getPoint(), w), power);
+        }
+    }
+}

data/src/main/java/org/sunflow/core/shader/PrimIDShader.java

@@ -0,0 +1,30 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.Vector3;
+
+public class PrimIDShader implements Shader {
+
+    private static final Color[] BORDERS = {Color.RED, Color.GREEN,
+        Color.BLUE, Color.YELLOW, Color.CYAN, Color.MAGENTA};
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        Vector3 n = state.getNormal();
+        float f = n == null ? 1.0f : Math.abs(state.getRay().dot(n));
+        return BORDERS[state.getPrimitiveID() % BORDERS.length].copy().mul(f);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

data/src/main/java/org/sunflow/core/shader/QuickGrayShader.java

@@ -0,0 +1,63 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Vector3;
+
+public class QuickGrayShader implements Shader {
+
+    public QuickGrayShader() {
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        if (state.getNormal() == null) {
+            // if this shader has been applied to an infinite instance because
+            // of shader overrides
+            // run the default shader, otherwise, just shade black
+            return state.getShader() != this ? state.getShader().getRadiance(state) : Color.BLACK;
+        }
+        // make sure we are on the right side of the material
+        state.faceforward();
+        // setup lighting
+        state.initLightSamples();
+        state.initCausticSamples();
+        return state.diffuse(Color.GRAY);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+        Color diffuse;
+        // make sure we are on the right side of the material
+        if (Vector3.dot(state.getNormal(), state.getRay().getDirection()) > 0.0) {
+            state.getNormal().negate();
+            state.getGeoNormal().negate();
+        }
+        diffuse = Color.GRAY;
+        state.storePhoton(state.getRay().getDirection(), power, diffuse);
+        float avg = diffuse.getAverage();
+        double rnd = state.getRandom(0, 0, 1);
+        if (rnd < avg) {
+            // photon is scattered
+            power.mul(diffuse).mul(1.0f / avg);
+            OrthoNormalBasis onb = state.getBasis();
+            double u = 2 * Math.PI * rnd / avg;
+            double v = state.getRandom(0, 1, 1);
+            float s = (float) Math.sqrt(v);
+            float s1 = (float) Math.sqrt(1.0 - v);
+            Vector3 w = new Vector3((float) Math.cos(u) * s, (float) Math.sin(u) * s, s1);
+            w = onb.transform(w, new Vector3());
+            state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
+        }
+    }
+}

data/src/main/java/org/sunflow/core/shader/ShinyDiffuseShader.java

@@ -0,0 +1,98 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Vector3;
+
+public class ShinyDiffuseShader implements Shader {
+
+    private Color diff;
+    private float refl;
+
+    public ShinyDiffuseShader() {
+        diff = Color.GRAY;
+        refl = 0.5f;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        diff = pl.getColor("diffuse", diff);
+        refl = pl.getFloat("shiny", refl);
+        return true;
+    }
+
+    public Color getDiffuse(ShadingState state) {
+        return diff;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        // make sure we are on the right side of the material
+        state.faceforward();
+        // direct lighting
+        state.initLightSamples();
+        state.initCausticSamples();
+        Color d = getDiffuse(state);
+        Color lr = state.diffuse(d);
+        if (!state.includeSpecular()) {
+            return lr;
+        }
+        float cos = state.getCosND();
+        float dn = 2 * cos;
+        Vector3 refDir = new Vector3();
+        refDir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
+        refDir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
+        refDir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
+        Ray refRay = new Ray(state.getPoint(), refDir);
+        // compute Fresnel term
+        cos = 1 - cos;
+        float cos2 = cos * cos;
+        float cos5 = cos2 * cos2 * cos;
+
+        Color ret = Color.white();
+        Color r = d.copy().mul(refl);
+        ret.sub(r);
+        ret.mul(cos5);
+        ret.add(r);
+        return lr.add(ret.mul(state.traceReflection(refRay, 0)));
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+        Color diffuse;
+        // make sure we are on the right side of the material
+        state.faceforward();
+        diffuse = getDiffuse(state);
+        state.storePhoton(state.getRay().getDirection(), power, diffuse);
+        float d = diffuse.getAverage();
+        float r = d * refl;
+        double rnd = state.getRandom(0, 0, 1);
+        if (rnd < d) {
+            // photon is scattered
+            power.mul(diffuse).mul(1.0f / d);
+            OrthoNormalBasis onb = state.getBasis();
+            double u = 2 * Math.PI * rnd / d;
+            double v = state.getRandom(0, 1, 1);
+            float s = (float) Math.sqrt(v);
+            float s1 = (float) Math.sqrt(1.0 - v);
+            Vector3 w = new Vector3((float) Math.cos(u) * s, (float) Math.sin(u) * s, s1);
+            w = onb.transform(w, new Vector3());
+            state.traceDiffusePhoton(new Ray(state.getPoint(), w), power);
+        } else if (rnd < d + r) {
+            float cos = -Vector3.dot(state.getNormal(), state.getRay().getDirection());
+            power.mul(diffuse).mul(1.0f / d);
+            // photon is reflected
+            float dn = 2 * cos;
+            Vector3 dir = new Vector3();
+            dir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
+            dir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
+            dir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
+            state.traceReflectionPhoton(new Ray(state.getPoint(), dir), power);
+        }
+    }
+}

data/src/main/java/org/sunflow/core/shader/SimpleShader.java

@@ -0,0 +1,24 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+
+public class SimpleShader implements Shader {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        return new Color(Math.abs(state.getRay().dot(state.getNormal())));
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

data/src/main/java/org/sunflow/core/shader/TexturedAmbientOcclusionShader.java

@@ -0,0 +1,31 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.ShadingState;
+import org.sunflow.core.Texture;
+import org.sunflow.core.TextureCache;
+import org.sunflow.image.Color;
+
+public class TexturedAmbientOcclusionShader extends AmbientOcclusionShader {
+
+    private Texture tex;
+
+    public TexturedAmbientOcclusionShader() {
+        tex = null;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        String filename = pl.getString("texture", null);
+        if (filename != null) {
+            tex = TextureCache.getTexture(api.resolveTextureFilename(filename), false);
+        }
+        return tex != null && super.update(pl, api);
+    }
+
+    @Override
+    public Color getBrightColor(ShadingState state) {
+        return tex.getPixel(state.getUV().x, state.getUV().y);
+    }
+}