joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/shader/TexturedDiffuseShader.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 TexturedDiffuseShader extends DiffuseShader {
+
+    private Texture tex;
+
+    public TexturedDiffuseShader() {
+        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 getDiffuse(ShadingState state) {
+        return tex.getPixel(state.getUV().x, state.getUV().y);
+    }
+}

data/src/main/java/org/sunflow/core/shader/TexturedPhongShader.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 TexturedPhongShader extends PhongShader {
+
+    private Texture tex;
+
+    public TexturedPhongShader() {
+        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 getDiffuse(ShadingState state) {
+        return tex.getPixel(state.getUV().x, state.getUV().y);
+    }
+}

data/src/main/java/org/sunflow/core/shader/TexturedShinyDiffuseShader.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 TexturedShinyDiffuseShader extends ShinyDiffuseShader {
+
+    private Texture tex;
+
+    public TexturedShinyDiffuseShader() {
+        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 getDiffuse(ShadingState state) {
+        return tex.getPixel(state.getUV().x, state.getUV().y);
+    }
+}

data/src/main/java/org/sunflow/core/shader/TexturedWardShader.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 TexturedWardShader extends AnisotropicWardShader {
+
+    private Texture tex;
+
+    public TexturedWardShader() {
+        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 getDiffuse(ShadingState state) {
+        return tex.getPixel(state.getUV().x, state.getUV().y);
+    }
+}

data/src/main/java/org/sunflow/core/shader/UVShader.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;
+
+public class UVShader implements Shader {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        if (state.getUV() == null) {
+            return Color.BLACK;
+        }
+        return new Color(state.getUV().x, state.getUV().y, 0);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

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

@@ -0,0 +1,149 @@
+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.core.Texture;
+import org.sunflow.core.TextureCache;
+import org.sunflow.image.Color;
+import org.sunflow.math.MathUtils;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Vector3;
+
+public class UberShader implements Shader {
+
+    private Color diff;
+    private Color spec;
+    private Texture diffmap;
+    private Texture specmap;
+    private float diffBlend;
+    private float specBlend;
+    private float glossyness;
+    private int numSamples;
+
+    public UberShader() {
+        diff = spec = Color.GRAY;
+        diffmap = specmap = null;
+        diffBlend = specBlend = 1;
+        glossyness = 0;
+        numSamples = 4;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        diff = pl.getColor("diffuse", diff);
+        spec = pl.getColor("specular", spec);
+        String filename;
+        filename = pl.getString("diffuse.texture", null);
+        if (filename != null) {
+            diffmap = TextureCache.getTexture(api.resolveTextureFilename(filename), false);
+        }
+        filename = pl.getString("specular.texture", null);
+        if (filename != null) {
+            specmap = TextureCache.getTexture(api.resolveTextureFilename(filename), false);
+        }
+        diffBlend = MathUtils.clamp(pl.getFloat("diffuse.blend", diffBlend), 0, 1);
+        specBlend = MathUtils.clamp(pl.getFloat("specular.blend", diffBlend), 0, 1);
+        glossyness = MathUtils.clamp(pl.getFloat("glossyness", glossyness), 0, 1);
+        numSamples = pl.getInt("samples", numSamples);
+        return true;
+    }
+
+    public Color getDiffuse(ShadingState state) {
+        return diffmap == null ? diff : Color.blend(diff, diffmap.getPixel(state.getUV().x, state.getUV().y), diffBlend);
+    }
+
+    public Color getSpecular(ShadingState state) {
+        return specmap == null ? spec : Color.blend(spec, specmap.getPixel(state.getUV().x, state.getUV().y), specBlend);
+    }
+
+    @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;
+        }
+        if (glossyness == 0) {
+            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 specular = getSpecular(state);
+            Color ret = Color.white();
+            ret.sub(specular);
+            ret.mul(cos5);
+            ret.add(specular);
+            return lr.add(ret.mul(state.traceReflection(refRay, 0)));
+        } else {
+            return lr.add(state.specularPhong(getSpecular(state), 2 / glossyness, numSamples));
+        }
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+        Color diffuse, specular;
+        // make sure we are on the right side of the material
+        state.faceforward();
+        diffuse = getDiffuse(state);
+        specular = getSpecular(state);
+        state.storePhoton(state.getRay().getDirection(), power, diffuse);
+        float d = diffuse.getAverage();
+        float r = specular.getAverage();
+        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) {
+            if (glossyness == 0) {
+                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);
+            } else {
+                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 / r);
+                OrthoNormalBasis onb = state.getBasis();
+                double u = 2 * Math.PI * (rnd - r) / r;
+                double v = state.getRandom(0, 1, 1);
+                float s = (float) Math.pow(v, 1 / ((1.0f / glossyness) + 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/ViewCausticsShader.java

@@ -0,0 +1,33 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.LightSample;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.image.Color;
+
+public class ViewCausticsShader implements Shader {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        state.faceforward();
+        state.initCausticSamples();
+        // integrate a diffuse function
+        Color lr = Color.black();
+        for (LightSample sample : state) {
+            lr.madd(sample.dot(state.getNormal()), sample.getDiffuseRadiance());
+        }
+        return lr.mul(1.0f / (float) Math.PI);
+
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

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

@@ -0,0 +1,25 @@
+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 ViewGlobalPhotonsShader implements Shader {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        state.faceforward();
+        return state.getGlobalRadiance();
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

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

@@ -0,0 +1,25 @@
+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 ViewIrradianceShader implements Shader {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        state.faceforward();
+        return new Color().set(state.getIrradiance(Color.WHITE)).mul(1.0f / (float) Math.PI);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

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

@@ -0,0 +1,83 @@
+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.Matrix4;
+import org.sunflow.math.Point3;
+
+public class WireframeShader implements Shader {
+
+    private Color lineColor;
+    private Color fillColor;
+    private float width;
+    private float cosWidth;
+
+    public WireframeShader() {
+        lineColor = Color.BLACK;
+        fillColor = Color.WHITE;
+        // pick a very small angle - should be roughly the half the angular
+        // width of a
+        // pixel
+        width = (float) (Math.PI * 0.5 / 4096);
+        cosWidth = (float) Math.cos(width);
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        lineColor = pl.getColor("line", lineColor);
+        fillColor = pl.getColor("fill", fillColor);
+        width = pl.getFloat("width", width);
+        cosWidth = (float) Math.cos(width);
+        return true;
+    }
+
+    public Color getFillColor(ShadingState state) {
+        return fillColor;
+    }
+
+    public Color getLineColor(ShadingState state) {
+        return lineColor;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        Point3[] p = new Point3[3];
+        if (!state.getTrianglePoints(p)) {
+            return getFillColor(state);
+        }
+        // transform points into camera space
+        Point3 center = state.getPoint();
+        Matrix4 w2c = state.getWorldToCamera();
+        center = w2c.transformP(center);
+        for (int i = 0; i < 3; i++) {
+            p[i] = w2c.transformP(state.transformObjectToWorld(p[i]));
+        }
+        float cn = 1.0f / (float) Math.sqrt(center.x * center.x + center.y * center.y + center.z * center.z);
+        for (int i = 0, i2 = 2; i < 3; i2 = i, i++) {
+            // compute orthogonal projection of the shading point onto each
+            // triangle edge as in:
+            // http://mathworld.wolfram.com/Point-LineDistance3-Dimensional.html
+            float t = (center.x - p[i].x) * (p[i2].x - p[i].x);
+            t += (center.y - p[i].y) * (p[i2].y - p[i].y);
+            t += (center.z - p[i].z) * (p[i2].z - p[i].z);
+            t /= p[i].distanceToSquared(p[i2]);
+            float projx = (1 - t) * p[i].x + t * p[i2].x;
+            float projy = (1 - t) * p[i].y + t * p[i2].y;
+            float projz = (1 - t) * p[i].z + t * p[i2].z;
+            float n = 1.0f / (float) Math.sqrt(projx * projx + projy * projy + projz * projz);
+            // check angular width
+            float dot = projx * center.x + projy * center.y + projz * center.z;
+            if (dot * n * cn >= cosWidth) {
+                return getLineColor(state);
+            }
+        }
+        return getFillColor(state);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}