joonsrenderer 1.1-java

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

@@ -0,0 +1,53 @@
+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 AmbientOcclusionShader implements Shader {
+
+    private Color bright;
+    private Color dark;
+    private int samples;
+    private float maxDist;
+
+    public AmbientOcclusionShader() {
+        bright = Color.WHITE;
+        dark = Color.BLACK;
+        samples = 32;
+        maxDist = Float.POSITIVE_INFINITY;
+    }
+
+    public AmbientOcclusionShader(Color c, float d) {
+        this();
+        bright = c;
+        maxDist = d;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        bright = pl.getColor("bright", bright);
+        dark = pl.getColor("dark", dark);
+        samples = pl.getInt("samples", samples);
+        maxDist = pl.getFloat("maxdist", maxDist);
+        if (maxDist <= 0) {
+            maxDist = Float.POSITIVE_INFINITY;
+        }
+        return true;
+    }
+
+    public Color getBrightColor(ShadingState state) {
+        return bright;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        return state.occlusion(samples, maxDist, getBrightColor(state), dark);
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

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

@@ -0,0 +1,216 @@
+package org.sunflow.core.shader;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.LightSample;
+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 AnisotropicWardShader implements Shader {
+
+    private Color rhoD; // diffuse reflectance
+    private Color rhoS; // specular reflectance
+    private float alphaX;
+    private float alphaY;
+    private int numRays;
+
+    public AnisotropicWardShader() {
+        rhoD = Color.GRAY;
+        rhoS = Color.GRAY;
+        alphaX = 1;
+        alphaY = 1;
+        numRays = 4;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        rhoD = pl.getColor("diffuse", rhoD);
+        rhoS = pl.getColor("specular", rhoS);
+        alphaX = pl.getFloat("roughnessX", alphaX);
+        alphaY = pl.getFloat("roughnessY", alphaY);
+        numRays = pl.getInt("samples", numRays);
+        return true;
+    }
+
+    protected Color getDiffuse(ShadingState state) {
+        return rhoD;
+    }
+
+    private float brdf(Vector3 i, Vector3 o, OrthoNormalBasis basis) {
+        float fr = 4 * (float) Math.PI * alphaX * alphaY;
+        float p = basis.untransformZ(i) * basis.untransformZ(o);
+        if (p > 0) {
+            fr *= (float) Math.sqrt(p);
+        } else {
+            fr = 0;
+        }
+        Vector3 h = Vector3.add(i, o, new Vector3());
+        basis.untransform(h);
+        float hx = h.x / alphaX;
+        hx *= hx;
+        float hy = h.y / alphaY;
+        hy *= hy;
+        float hn = h.z * h.z;
+        if (fr > 0) {
+            fr = (float) Math.exp(-(hx + hy) / hn) / fr;
+        }
+        return fr;
+    }
+
+    public Color getRadiance(ShadingState state) {
+        // make sure we are on the right side of the material
+        state.faceforward();
+        OrthoNormalBasis onb = state.getBasis();
+        // direct lighting and caustics
+        state.initLightSamples();
+        state.initCausticSamples();
+        Color lr = Color.black();
+        // compute specular contribution
+        if (state.includeSpecular()) {
+            Vector3 in = state.getRay().getDirection().negate(new Vector3());
+            for (LightSample sample : state) {
+                float cosNL = sample.dot(state.getNormal());
+                float fr = brdf(in, sample.getShadowRay().getDirection(), onb);
+                lr.madd(cosNL * fr, sample.getSpecularRadiance());
+            }
+
+            // indirect lighting - specular
+            if (numRays > 0) {
+                int n = state.getDepth() == 0 ? numRays : 1;
+                for (int i = 0; i < n; i++) {
+                    // specular indirect lighting
+                    double r1 = state.getRandom(i, 0, n);
+                    double r2 = state.getRandom(i, 1, n);
+
+                    float alphaRatio = alphaY / alphaX;
+                    float phi = 0;
+                    if (r1 < 0.25) {
+                        double val = 4 * r1;
+                        phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+                    } else if (r1 < 0.5) {
+                        double val = 1 - 4 * (0.5 - r1);
+                        phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+                        phi = (float) Math.PI - phi;
+                    } else if (r1 < 0.75) {
+                        double val = 4 * (r1 - 0.5);
+                        phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+                        phi += Math.PI;
+                    } else {
+                        double val = 1 - 4 * (1 - r1);
+                        phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+                        phi = 2 * (float) Math.PI - phi;
+                    }
+
+                    float cosPhi = (float) Math.cos(phi);
+                    float sinPhi = (float) Math.sin(phi);
+
+                    float denom = (cosPhi * cosPhi) / (alphaX * alphaX) + (sinPhi * sinPhi) / (alphaY * alphaY);
+                    float theta = (float) Math.atan(Math.sqrt(-Math.log(1 - r2) / denom));
+
+                    float sinTheta = (float) Math.sin(theta);
+                    float cosTheta = (float) Math.cos(theta);
+
+                    Vector3 h = new Vector3();
+                    h.x = sinTheta * cosPhi;
+                    h.y = sinTheta * sinPhi;
+                    h.z = cosTheta;
+                    onb.transform(h);
+
+                    Vector3 o = new Vector3();
+                    float ih = Vector3.dot(h, in);
+                    o.x = 2 * ih * h.x - in.x;
+                    o.y = 2 * ih * h.y - in.y;
+                    o.z = 2 * ih * h.z - in.z;
+
+                    float no = onb.untransformZ(o);
+                    float ni = onb.untransformZ(in);
+                    float w = ih * cosTheta * cosTheta * cosTheta * (float) Math.sqrt(Math.abs(no / ni));
+
+                    Ray r = new Ray(state.getPoint(), o);
+                    lr.madd(w / n, state.traceGlossy(r, i));
+                }
+            }
+            lr.mul(rhoS);
+        }
+        // add diffuse contribution
+        lr.add(state.diffuse(getDiffuse(state)));
+        return lr;
+    }
+
+    @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 = rhoS.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
+            power.mul(rhoS).mul(1 / avgS);
+            OrthoNormalBasis basis = state.getBasis();
+            Vector3 in = state.getRay().getDirection().negate(new Vector3());
+            double r1 = rnd / avgS;
+            double r2 = state.getRandom(0, 1, 1);
+
+            float alphaRatio = alphaY / alphaX;
+            float phi = 0;
+            if (r1 < 0.25) {
+                double val = 4 * r1;
+                phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+            } else if (r1 < 0.5) {
+                double val = 1 - 4 * (0.5 - r1);
+                phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+                phi = (float) Math.PI - phi;
+            } else if (r1 < 0.75) {
+                double val = 4 * (r1 - 0.5);
+                phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+                phi += Math.PI;
+            } else {
+                double val = 1 - 4 * (1 - r1);
+                phi = (float) Math.atan(alphaRatio * Math.tan(Math.PI / 2 * val));
+                phi = 2 * (float) Math.PI - phi;
+            }
+
+            float cosPhi = (float) Math.cos(phi);
+            float sinPhi = (float) Math.sin(phi);
+
+            float denom = (cosPhi * cosPhi) / (alphaX * alphaX) + (sinPhi * sinPhi) / (alphaY * alphaY);
+            float theta = (float) Math.atan(Math.sqrt(-Math.log(1 - r2) / denom));
+
+            float sinTheta = (float) Math.sin(theta);
+            float cosTheta = (float) Math.cos(theta);
+
+            Vector3 h = new Vector3();
+            h.x = sinTheta * cosPhi;
+            h.y = sinTheta * sinPhi;
+            h.z = cosTheta;
+            basis.transform(h);
+
+            Vector3 o = new Vector3();
+            float ih = Vector3.dot(h, in);
+            o.x = 2 * ih * h.x - in.x;
+            o.y = 2 * ih * h.y - in.y;
+            o.z = 2 * ih * h.z - in.z;
+
+            Ray r = new Ray(state.getPoint(), o);
+            state.traceReflectionPhoton(r, power);
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+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 ConstantShader implements Shader {
+
+    private Color c;
+
+    public ConstantShader() {
+        c = Color.WHITE;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        c = pl.getColor("color", c);
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        return c;
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+}

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

@@ -0,0 +1,65 @@
+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 DiffuseShader implements Shader {
+
+    private Color diff;
+
+    public DiffuseShader() {
+        diff = Color.WHITE;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        diff = pl.getColor("diffuse", diff);
+        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();
+        // setup lighting
+        state.initLightSamples();
+        state.initCausticSamples();
+        return state.diffuse(getDiffuse(state));
+    }
+
+    @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 = getDiffuse(state);
+        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/GlassShader.java

@@ -0,0 +1,147 @@
+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 GlassShader implements Shader {
+
+    private float eta; // refraction index ratio
+    private float f0; // fresnel normal incidence
+    private Color color;
+    private float absorptionDistance;
+    private Color absorptionColor;
+
+    public GlassShader() {
+        eta = 1.3f;
+        color = Color.WHITE;
+        absorptionDistance = 0; // disabled by default
+        absorptionColor = Color.GRAY; // 50% absorbtion
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        color = pl.getColor("color", color);
+        eta = pl.getFloat("eta", eta);
+        f0 = (1 - eta) / (1 + eta);
+        f0 = f0 * f0;
+        absorptionDistance = pl.getFloat("absorption.distance", absorptionDistance);
+        absorptionColor = pl.getColor("absorption.color", absorptionColor);
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        if (!state.includeSpecular()) {
+            return Color.BLACK;
+        }
+        Vector3 reflDir = new Vector3();
+        Vector3 refrDir = new Vector3();
+        state.faceforward();
+        float cos = state.getCosND();
+        boolean inside = state.isBehind();
+        float neta = inside ? eta : 1.0f / eta;
+
+        float dn = 2 * cos;
+        reflDir.x = (dn * state.getNormal().x) + state.getRay().getDirection().x;
+        reflDir.y = (dn * state.getNormal().y) + state.getRay().getDirection().y;
+        reflDir.z = (dn * state.getNormal().z) + state.getRay().getDirection().z;
+
+        // refracted ray
+        float arg = 1 - (neta * neta * (1 - (cos * cos)));
+        boolean tir = arg < 0;
+        if (tir) {
+            refrDir.x = refrDir.y = refrDir.z = 0;
+        } else {
+            float nK = (neta * cos) - (float) Math.sqrt(arg);
+            refrDir.x = (neta * state.getRay().dx) + (nK * state.getNormal().x);
+            refrDir.y = (neta * state.getRay().dy) + (nK * state.getNormal().y);
+            refrDir.z = (neta * state.getRay().dz) + (nK * state.getNormal().z);
+        }
+
+        // compute Fresnel terms
+        float cosTheta1 = Vector3.dot(state.getNormal(), reflDir);
+        float cosTheta2 = -Vector3.dot(state.getNormal(), refrDir);
+
+        float pPara = (cosTheta1 - eta * cosTheta2) / (cosTheta1 + eta * cosTheta2);
+        float pPerp = (eta * cosTheta1 - cosTheta2) / (eta * cosTheta1 + cosTheta2);
+        float kr = 0.5f * (pPara * pPara + pPerp * pPerp);
+        float kt = 1 - kr;
+
+        Color absorbtion = null;
+        if (inside && absorptionDistance > 0) {
+            // this ray is inside the object and leaving it
+            // compute attenuation that occured along the ray
+            absorbtion = Color.mul(-state.getRay().getMax() / absorptionDistance, absorptionColor.copy().opposite()).exp();
+            if (absorbtion.isBlack()) {
+                return Color.BLACK; // nothing goes through
+            }
+        }
+        // refracted ray
+        Color ret = Color.black();
+        if (!tir) {
+            ret.madd(kt, state.traceRefraction(new Ray(state.getPoint(), refrDir), 0)).mul(color);
+        }
+        if (!inside || tir) {
+            ret.add(Color.mul(kr, state.traceReflection(new Ray(state.getPoint(), reflDir), 0)).mul(color));
+        }
+        return absorbtion != null ? ret.mul(absorbtion) : ret;
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+        Color refr = Color.mul(1 - f0, color);
+        Color refl = Color.mul(f0, color);
+        float avgR = refl.getAverage();
+        float avgT = refr.getAverage();
+        double rnd = state.getRandom(0, 0, 1);
+        if (rnd < avgR) {
+            state.faceforward();
+            // don't reflect internally
+            if (state.isBehind()) {
+                return;
+            }
+            // photon is reflected
+            float cos = state.getCosND();
+            power.mul(refl).mul(1.0f / avgR);
+            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 if (rnd < avgR + avgT) {
+            state.faceforward();
+            // photon is refracted
+            float cos = state.getCosND();
+            float neta = state.isBehind() ? eta : 1.0f / eta;
+            power.mul(refr).mul(1.0f / avgT);
+            float wK = -neta;
+            float arg = 1 - (neta * neta * (1 - (cos * cos)));
+            Vector3 dir = new Vector3();
+            if (state.isBehind() && absorptionDistance > 0) {
+                // this ray is inside the object and leaving it
+                // compute attenuation that occured along the ray
+                power.mul(Color.mul(-state.getRay().getMax() / absorptionDistance, absorptionColor.copy().opposite()).exp());
+            }
+            if (arg < 0) {
+                // TIR
+                float dn = 2 * cos;
+                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 nK = (neta * cos) - (float) Math.sqrt(arg);
+                dir.x = (-wK * state.getRay().dx) + (nK * state.getNormal().x);
+                dir.y = (-wK * state.getRay().dy) + (nK * state.getNormal().y);
+                dir.z = (-wK * state.getRay().dz) + (nK * state.getNormal().z);
+                state.traceRefractionPhoton(new Ray(state.getPoint(), dir), power);
+            }
+        }
+    }
+}