joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/primitive/CubeGrid.java

@@ -0,0 +1,318 @@
+package org.sunflow.core.primitive;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.Instance;
+import org.sunflow.core.IntersectionState;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.PrimitiveList;
+import org.sunflow.core.Ray;
+import org.sunflow.core.ShadingState;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Vector3;
+
+public abstract class CubeGrid implements PrimitiveList {
+
+    private int nx, ny, nz;
+    private float voxelwx, voxelwy, voxelwz;
+    private float invVoxelwx, invVoxelwy, invVoxelwz;
+    private final BoundingBox bounds;
+
+    public CubeGrid() {
+        nx = ny = nz = 1;
+        bounds = new BoundingBox(1);
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        nx = pl.getInt("resolutionX", nx);
+        ny = pl.getInt("resolutionY", ny);
+        nz = pl.getInt("resolutionZ", nz);
+        voxelwx = 2.0f / nx;
+        voxelwy = 2.0f / ny;
+        voxelwz = 2.0f / nz;
+        invVoxelwx = 1 / voxelwx;
+        invVoxelwy = 1 / voxelwy;
+        invVoxelwz = 1 / voxelwz;
+        return true;
+    }
+
+    protected abstract boolean inside(int x, int y, int z);
+
+    public BoundingBox getBounds() {
+        return bounds;
+    }
+
+    @Override
+    public void prepareShadingState(ShadingState state) {
+        state.init();
+        state.getRay().getPoint(state.getPoint());
+        Instance parent = state.getInstance();
+        Vector3 normal;
+        switch (state.getPrimitiveID()) {
+            case 0:
+                normal = new Vector3(-1, 0, 0);
+                break;
+            case 1:
+                normal = new Vector3(1, 0, 0);
+                break;
+            case 2:
+                normal = new Vector3(0, -1, 0);
+                break;
+            case 3:
+                normal = new Vector3(0, 1, 0);
+                break;
+            case 4:
+                normal = new Vector3(0, 0, -1);
+                break;
+            case 5:
+                normal = new Vector3(0, 0, 1);
+                break;
+            default:
+                normal = new Vector3(0, 0, 0);
+                break;
+        }
+        state.getNormal().set(state.transformNormalObjectToWorld(normal));
+        state.getGeoNormal().set(state.getNormal());
+        state.setBasis(OrthoNormalBasis.makeFromW(state.getNormal()));
+        state.setShader(parent.getShader(0));
+        state.setModifier(parent.getModifier(0));
+    }
+
+    @Override
+    public void intersectPrimitive(Ray r, int primID, IntersectionState state) {
+        float intervalMin = r.getMin();
+        float intervalMax = r.getMax();
+        float orgX = r.ox;
+        float orgY = r.oy;
+        float orgZ = r.oz;
+        float dirX = r.dx, invDirX = 1 / dirX;
+        float dirY = r.dy, invDirY = 1 / dirY;
+        float dirZ = r.dz, invDirZ = 1 / dirZ;
+        float t1, t2;
+        t1 = (-1 - orgX) * invDirX;
+        t2 = (+1 - orgX) * invDirX;
+        int curr = -1;
+        if (invDirX > 0) {
+            if (t1 > intervalMin) {
+                intervalMin = t1;
+                curr = 0;
+            }
+            if (t2 < intervalMax) {
+                intervalMax = t2;
+            }
+            if (intervalMin > intervalMax) {
+                return;
+            }
+        } else {
+            if (t2 > intervalMin) {
+                intervalMin = t2;
+                curr = 1;
+            }
+            if (t1 < intervalMax) {
+                intervalMax = t1;
+            }
+            if (intervalMin > intervalMax) {
+                return;
+            }
+        }
+        t1 = (-1 - orgY) * invDirY;
+        t2 = (+1 - orgY) * invDirY;
+        if (invDirY > 0) {
+            if (t1 > intervalMin) {
+                intervalMin = t1;
+                curr = 2;
+            }
+            if (t2 < intervalMax) {
+                intervalMax = t2;
+            }
+            if (intervalMin > intervalMax) {
+                return;
+            }
+        } else {
+            if (t2 > intervalMin) {
+                intervalMin = t2;
+                curr = 3;
+            }
+            if (t1 < intervalMax) {
+                intervalMax = t1;
+            }
+            if (intervalMin > intervalMax) {
+                return;
+            }
+        }
+        t1 = (-1 - orgZ) * invDirZ;
+        t2 = (+1 - orgZ) * invDirZ;
+        if (invDirZ > 0) {
+            if (t1 > intervalMin) {
+                intervalMin = t1;
+                curr = 4;
+            }
+            if (t2 < intervalMax) {
+                intervalMax = t2;
+            }
+            if (intervalMin > intervalMax) {
+                return;
+            }
+        } else {
+            if (t2 > intervalMin) {
+                intervalMin = t2;
+                curr = 5;
+            }
+            if (t1 < intervalMax) {
+                intervalMax = t1;
+            }
+            if (intervalMin > intervalMax) {
+                return;
+            }
+        }
+        // box is hit at [intervalMin, intervalMax]
+        orgX += intervalMin * dirX;
+        orgY += intervalMin * dirY;
+        orgZ += intervalMin * dirZ;
+        // locate starting point inside the grid
+        // and set up 3D-DDA vars
+        int indxX, indxY, indxZ;
+        int stepX, stepY, stepZ;
+        int stopX, stopY, stopZ;
+        float deltaX, deltaY, deltaZ;
+        float tnextX, tnextY, tnextZ;
+        // stepping factors along X
+        indxX = (int) ((orgX + 1) * invVoxelwx);
+        if (indxX < 0) {
+            indxX = 0;
+        } else if (indxX >= nx) {
+            indxX = nx - 1;
+        }
+        if (Math.abs(dirX) < 1e-6f) {
+            stepX = 0;
+            stopX = indxX;
+            deltaX = 0;
+            tnextX = Float.POSITIVE_INFINITY;
+        } else if (dirX > 0) {
+            stepX = 1;
+            stopX = nx;
+            deltaX = voxelwx * invDirX;
+            tnextX = intervalMin + ((indxX + 1) * voxelwx - 1 - orgX) * invDirX;
+        } else {
+            stepX = -1;
+            stopX = -1;
+            deltaX = -voxelwx * invDirX;
+            tnextX = intervalMin + (indxX * voxelwx - 1 - orgX) * invDirX;
+        }
+        // stepping factors along Y
+        indxY = (int) ((orgY + 1) * invVoxelwy);
+        if (indxY < 0) {
+            indxY = 0;
+        } else if (indxY >= ny) {
+            indxY = ny - 1;
+        }
+        if (Math.abs(dirY) < 1e-6f) {
+            stepY = 0;
+            stopY = indxY;
+            deltaY = 0;
+            tnextY = Float.POSITIVE_INFINITY;
+        } else if (dirY > 0) {
+            stepY = 1;
+            stopY = ny;
+            deltaY = voxelwy * invDirY;
+            tnextY = intervalMin + ((indxY + 1) * voxelwy - 1 - orgY) * invDirY;
+        } else {
+            stepY = -1;
+            stopY = -1;
+            deltaY = -voxelwy * invDirY;
+            tnextY = intervalMin + (indxY * voxelwy - 1 - orgY) * invDirY;
+        }
+        // stepping factors along Z
+        indxZ = (int) ((orgZ + 1) * invVoxelwz);
+        if (indxZ < 0) {
+            indxZ = 0;
+        } else if (indxZ >= nz) {
+            indxZ = nz - 1;
+        }
+        if (Math.abs(dirZ) < 1e-6f) {
+            stepZ = 0;
+            stopZ = indxZ;
+            deltaZ = 0;
+            tnextZ = Float.POSITIVE_INFINITY;
+        } else if (dirZ > 0) {
+            stepZ = 1;
+            stopZ = nz;
+            deltaZ = voxelwz * invDirZ;
+            tnextZ = intervalMin + ((indxZ + 1) * voxelwz - 1 - orgZ) * invDirZ;
+        } else {
+            stepZ = -1;
+            stopZ = -1;
+            deltaZ = -voxelwz * invDirZ;
+            tnextZ = intervalMin + (indxZ * voxelwz - 1 - orgZ) * invDirZ;
+        }
+        // are we starting inside the cube
+        boolean isInside = inside(indxX, indxY, indxZ) && bounds.contains(r.ox, r.oy, r.oz);
+        // trace through the grid
+        for (;;) {
+            if (inside(indxX, indxY, indxZ) != isInside) {
+                // we hit a boundary
+                r.setMax(intervalMin);
+                // if we are inside, the last bit needs to be flipped
+                if (isInside) {
+                    curr ^= 1;
+                }
+                state.setIntersection(curr);
+                return;
+            }
+            if (tnextX < tnextY && tnextX < tnextZ) {
+                curr = dirX > 0 ? 0 : 1;
+                intervalMin = tnextX;
+                if (intervalMin > intervalMax) {
+                    return;
+                }
+                indxX += stepX;
+                if (indxX == stopX) {
+                    return;
+                }
+                tnextX += deltaX;
+            } else if (tnextY < tnextZ) {
+                curr = dirY > 0 ? 2 : 3;
+                intervalMin = tnextY;
+                if (intervalMin > intervalMax) {
+                    return;
+                }
+                indxY += stepY;
+                if (indxY == stopY) {
+                    return;
+                }
+                tnextY += deltaY;
+            } else {
+                curr = dirZ > 0 ? 4 : 5;
+                intervalMin = tnextZ;
+                if (intervalMin > intervalMax) {
+                    return;
+                }
+                indxZ += stepZ;
+                if (indxZ == stopZ) {
+                    return;
+                }
+                tnextZ += deltaZ;
+            }
+        }
+    }
+
+    @Override
+    public int getNumPrimitives() {
+        return 1;
+    }
+
+    @Override
+    public float getPrimitiveBound(int primID, int i) {
+        return ((i & 1) == 0) ? -1 : 1;
+    }
+
+    @Override
+    public BoundingBox getWorldBounds(Matrix4 o2w) {
+        if (o2w == null) {
+            return bounds;
+        }
+        return o2w.transform(bounds);
+    }
+}

data/src/main/java/org/sunflow/core/primitive/Cylinder.java

@@ -0,0 +1,104 @@
+package org.sunflow.core.primitive;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.Instance;
+import org.sunflow.core.IntersectionState;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.PrimitiveList;
+import org.sunflow.core.Ray;
+import org.sunflow.core.ShadingState;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Solvers;
+import org.sunflow.math.Vector3;
+
+public class Cylinder implements PrimitiveList {
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        return true;
+    }
+
+    @Override
+    public BoundingBox getWorldBounds(Matrix4 o2w) {
+        BoundingBox bounds = new BoundingBox(1);
+        if (o2w != null) {
+            bounds = o2w.transform(bounds);
+        }
+        return bounds;
+    }
+
+    @Override
+    public float getPrimitiveBound(int primID, int i) {
+        return (i & 1) == 0 ? -1 : 1;
+    }
+
+    @Override
+    public int getNumPrimitives() {
+        return 1;
+    }
+
+    @Override
+    public void prepareShadingState(ShadingState state) {
+        state.init();
+        state.getRay().getPoint(state.getPoint());
+        Instance parent = state.getInstance();
+        Point3 localPoint = state.transformWorldToObject(state.getPoint());
+        state.getNormal().set(localPoint.x, localPoint.y, 0);
+        state.getNormal().normalize();
+
+        float phi = (float) Math.atan2(state.getNormal().y, state.getNormal().x);
+        if (phi < 0) {
+            phi += 2 * Math.PI;
+        }
+        state.getUV().x = phi / (float) (2 * Math.PI);
+        state.getUV().y = (localPoint.z + 1) * 0.5f;
+        state.setShader(parent.getShader(0));
+        state.setModifier(parent.getModifier(0));
+        // into world space
+        Vector3 worldNormal = state.transformNormalObjectToWorld(state.getNormal());
+        Vector3 v = state.transformVectorObjectToWorld(new Vector3(0, 0, 1));
+        state.getNormal().set(worldNormal);
+        state.getNormal().normalize();
+        state.getGeoNormal().set(state.getNormal());
+        // compute basis in world space
+        state.setBasis(OrthoNormalBasis.makeFromWV(state.getNormal(), v));
+    }
+
+    @Override
+    public void intersectPrimitive(Ray r, int primID, IntersectionState state) {
+        // intersect in local space
+        float qa = r.dx * r.dx + r.dy * r.dy;
+        float qb = 2 * ((r.dx * r.ox) + (r.dy * r.oy));
+        float qc = ((r.ox * r.ox) + (r.oy * r.oy)) - 1;
+        double[] t = Solvers.solveQuadric(qa, qb, qc);
+        if (t != null) {
+            // early rejection
+            if (t[0] >= r.getMax() || t[1] <= r.getMin()) {
+                return;
+            }
+            if (t[0] > r.getMin()) {
+                float z = r.oz + (float) t[0] * r.dz;
+                if (z >= -1 && z <= 1) {
+                    r.setMax((float) t[0]);
+                    state.setIntersection(0);
+                    return;
+                }
+            }
+            if (t[1] < r.getMax()) {
+                float z = r.oz + (float) t[1] * r.dz;
+                if (z >= -1 && z <= 1) {
+                    r.setMax((float) t[1]);
+                    state.setIntersection(0);
+                }
+            }
+        }
+    }
+
+    @Override
+    public PrimitiveList getBakingPrimitives() {
+        return null;
+    }
+}

data/src/main/java/org/sunflow/core/primitive/Hair.java

@@ -0,0 +1,275 @@
+package org.sunflow.core.primitive;
+
+import java.util.Locale;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.Instance;
+import org.sunflow.core.IntersectionState;
+import org.sunflow.core.LightSample;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.PrimitiveList;
+import org.sunflow.core.Ray;
+import org.sunflow.core.Shader;
+import org.sunflow.core.ShadingState;
+import org.sunflow.core.ParameterList.FloatParameter;
+import org.sunflow.core.ParameterList.InterpolationType;
+import org.sunflow.image.Color;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.OrthoNormalBasis;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class Hair implements PrimitiveList, Shader {
+
+    private int numSegments;
+    private float[] points;
+    private FloatParameter widths;
+
+    public Hair() {
+        numSegments = 1;
+        points = null;
+        widths = new FloatParameter(1.0f);
+    }
+
+    @Override
+    public int getNumPrimitives() {
+        return numSegments * (points.length / (3 * (numSegments + 1)));
+    }
+
+    @Override
+    public float getPrimitiveBound(int primID, int i) {
+        int hair = primID / numSegments;
+        int line = primID % numSegments;
+        int vn = hair * (numSegments + 1) + line;
+        int vRoot = hair * 3 * (numSegments + 1);
+        int v0 = vRoot + line * 3;
+        int v1 = v0 + 3;
+        int axis = i >>> 1;
+        if ((i & 1) == 0) {
+            return Math.min(points[v0 + axis] - 0.5f * getWidth(vn), points[v1 + axis] - 0.5f * getWidth(vn + 1));
+        } else {
+            return Math.max(points[v0 + axis] + 0.5f * getWidth(vn), points[v1 + axis] + 0.5f * getWidth(vn + 1));
+        }
+    }
+
+    @Override
+    public BoundingBox getWorldBounds(Matrix4 o2w) {
+        BoundingBox bounds = new BoundingBox();
+        for (int i = 0, j = 0; i < points.length; i += 3, j++) {
+            float w = 0.5f * getWidth(j);
+            bounds.include(points[i] - w, points[i + 1] - w, points[i + 2] - w);
+            bounds.include(points[i] + w, points[i + 1] + w, points[i + 2] + w);
+        }
+        if (o2w != null) {
+            bounds = o2w.transform(bounds);
+        }
+        return bounds;
+    }
+
+    private float getWidth(int i) {
+        switch (widths.interp) {
+            case NONE:
+                return widths.data[0];
+            case VERTEX:
+                return widths.data[i];
+            default:
+                return 0;
+        }
+    }
+
+    private Vector3 getTangent(int line, int v0, float v) {
+        Vector3 vcurr = new Vector3(points[v0 + 3] - points[v0 + 0], points[v0 + 4] - points[v0 + 1], points[v0 + 5] - points[v0 + 2]);
+        vcurr.normalize();
+        if (line == 0 || line == numSegments - 1) {
+            return vcurr;
+        }
+        if (v <= 0.5f) {
+            // get previous segment
+            Vector3 vprev = new Vector3(points[v0 + 0] - points[v0 - 3], points[v0 + 1] - points[v0 - 2], points[v0 + 2] - points[v0 - 1]);
+            vprev.normalize();
+            float t = v + 0.5f;
+            float s = 1 - t;
+            float vx = vprev.x * s + vcurr.x * t;
+            float vy = vprev.y * s + vcurr.y * t;
+            float vz = vprev.z * s + vcurr.z * t;
+            return new Vector3(vx, vy, vz);
+        } else {
+            // get next segment
+            v0 += 3;
+            Vector3 vnext = new Vector3(points[v0 + 3] - points[v0 + 0], points[v0 + 4] - points[v0 + 1], points[v0 + 5] - points[v0 + 2]);
+            vnext.normalize();
+            float t = 1.5f - v;
+            float s = 1 - t;
+            float vx = vnext.x * s + vcurr.x * t;
+            float vy = vnext.y * s + vcurr.y * t;
+            float vz = vnext.z * s + vcurr.z * t;
+            return new Vector3(vx, vy, vz);
+        }
+    }
+
+    @Override
+    public void intersectPrimitive(Ray r, int primID, IntersectionState state) {
+        int hair = primID / numSegments;
+        int line = primID % numSegments;
+        int vRoot = hair * 3 * (numSegments + 1);
+        int v0 = vRoot + line * 3;
+        int v1 = v0 + 3;
+        float vx = points[v1 + 0] - points[v0 + 0];
+        float vy = points[v1 + 1] - points[v0 + 1];
+        float vz = points[v1 + 2] - points[v0 + 2];
+        float ux = r.dy * vz - r.dz * vy;
+        float uy = r.dz * vx - r.dx * vz;
+        float uz = r.dx * vy - r.dy * vx;
+        float nx = uy * vz - uz * vy;
+        float ny = uz * vx - ux * vz;
+        float nz = ux * vy - uy * vx;
+        float tden = 1 / (nx * r.dx + ny * r.dy + nz * r.dz);
+        float tnum = nx * (points[v0 + 0] - r.ox) + ny * (points[v0 + 1] - r.oy) + nz * (points[v0 + 2] - r.oz);
+        float t = tnum * tden;
+        if (r.isInside(t)) {
+            int vn = hair * (numSegments + 1) + line;
+            float px = r.ox + t * r.dx;
+            float py = r.oy + t * r.dy;
+            float pz = r.oz + t * r.dz;
+            float qx = px - points[v0 + 0];
+            float qy = py - points[v0 + 1];
+            float qz = pz - points[v0 + 2];
+            float q = (vx * qx + vy * qy + vz * qz) / (vx * vx + vy * vy + vz * vz);
+            if (q <= 0) {
+                // don't included rounded tip at root
+                if (line == 0) {
+                    return;
+                }
+                float dx = points[v0 + 0] - px;
+                float dy = points[v0 + 1] - py;
+                float dz = points[v0 + 2] - pz;
+                float d2 = dx * dx + dy * dy + dz * dz;
+                float width = getWidth(vn);
+                if (d2 < (width * width * 0.25f)) {
+                    r.setMax(t);
+                    state.setIntersection(primID, 0, 0);
+                }
+            } else if (q >= 1) {
+                float dx = points[v1 + 0] - px;
+                float dy = points[v1 + 1] - py;
+                float dz = points[v1 + 2] - pz;
+                float d2 = dx * dx + dy * dy + dz * dz;
+                float width = getWidth(vn + 1);
+                if (d2 < (width * width * 0.25f)) {
+                    r.setMax(t);
+                    state.setIntersection(primID, 0, 1);
+                }
+            } else {
+                float dx = points[v0 + 0] + q * vx - px;
+                float dy = points[v0 + 1] + q * vy - py;
+                float dz = points[v0 + 2] + q * vz - pz;
+                float d2 = dx * dx + dy * dy + dz * dz;
+                float width = (1 - q) * getWidth(vn) + q * getWidth(vn + 1);
+                if (d2 < (width * width * 0.25f)) {
+                    r.setMax(t);
+                    state.setIntersection(primID, 0, q);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void prepareShadingState(ShadingState state) {
+        state.init();
+        Instance i = state.getInstance();
+        state.getRay().getPoint(state.getPoint());
+        Ray r = state.getRay();
+        Shader s = i.getShader(0);
+        state.setShader(s != null ? s : this);
+        int primID = state.getPrimitiveID();
+        int hair = primID / numSegments;
+        int line = primID % numSegments;
+        int vRoot = hair * 3 * (numSegments + 1);
+        int v0 = vRoot + line * 3;
+
+        // tangent vector
+        Vector3 v = getTangent(line, v0, state.getV());
+        v = state.transformVectorObjectToWorld(v);
+        state.setBasis(OrthoNormalBasis.makeFromWV(v, new Vector3(-r.dx, -r.dy, -r.dz)));
+        state.getBasis().swapVW();
+        // normal
+        state.getNormal().set(0, 0, 1);
+        state.getBasis().transform(state.getNormal());
+        state.getGeoNormal().set(state.getNormal());
+
+        state.getUV().set(0, (line + state.getV()) / numSegments);
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        numSegments = pl.getInt("segments", numSegments);
+        if (numSegments < 1) {
+            UI.printError(Module.HAIR, "Invalid number of segments: %d", numSegments);
+            return false;
+        }
+        FloatParameter pointsP = pl.getPointArray("points");
+        if (pointsP != null) {
+            if (pointsP.interp != InterpolationType.VERTEX) {
+                UI.printError(Module.HAIR, "Point interpolation type must be set to \"vertex\" - was \"%s\"", pointsP.interp.name().toLowerCase(Locale.ENGLISH));
+            } else {
+                points = pointsP.data;
+            }
+        }
+        if (points == null) {
+            UI.printError(Module.HAIR, "Unabled to update hair - vertices are missing");
+            return false;
+        }
+
+        pl.setVertexCount(points.length / 3);
+        FloatParameter widthsP = pl.getFloatArray("widths");
+        if (widthsP != null) {
+            if (widthsP.interp == InterpolationType.NONE || widthsP.interp == InterpolationType.VERTEX) {
+                widths = widthsP;
+            } else {
+                UI.printWarning(Module.HAIR, "Width interpolation type %s is not supported -- ignoring", widthsP.interp.name().toLowerCase(Locale.ENGLISH));
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public Color getRadiance(ShadingState state) {
+        // don't use these - gather lights for sphere of directions
+        // gather lights
+        state.initLightSamples();
+        state.initCausticSamples();
+        Vector3 v = state.getRay().getDirection();
+        v.negate();
+        Vector3 h = new Vector3();
+        Vector3 t = state.getBasis().transform(new Vector3(0, 1, 0));
+        Color diff = Color.black();
+        Color spec = Color.black();
+        for (LightSample ls : state) {
+            Vector3 l = ls.getShadowRay().getDirection();
+            float dotTL = Vector3.dot(t, l);
+            float sinTL = (float) Math.sqrt(1 - dotTL * dotTL);
+            // float dotVL = Vector3.dot(v, l);
+            diff.madd(sinTL, ls.getDiffuseRadiance());
+            Vector3.add(v, l, h);
+            h.normalize();
+            float dotTH = Vector3.dot(t, h);
+            float sinTH = (float) Math.sqrt(1 - dotTH * dotTH);
+            float s = (float) Math.pow(sinTH, 10.0f);
+            spec.madd(s, ls.getSpecularRadiance());
+        }
+        Color c = Color.add(diff, spec, new Color());
+        // transparency
+        return Color.blend(c, state.traceTransparency(), state.getV(), new Color());
+    }
+
+    @Override
+    public void scatterPhoton(ShadingState state, Color power) {
+    }
+
+    @Override
+    public PrimitiveList getBakingPrimitives() {
+        return null;
+    }
+}