joonsrenderer 1.1-java

data/src/main/java/org/sunflow/math/PerlinVector.java

@@ -0,0 +1,132 @@
+package org.sunflow.math;
+
+/**
+ * Vector versions of the standard noise functions. These are provided to
+ * emulate standard renderman calls.This code was adapted mainly from the
+ * mrclasses package by Gonzalo Garramuno
+ * (http://sourceforge.net/projects/mrclasses/).
+ */
+public class PerlinVector {
+
+    private static final float P1x = 0.34f;
+    private static final float P1y = 0.66f;
+    private static final float P1z = 0.237f;
+    private static final float P2x = 0.011f;
+    private static final float P2y = 0.845f;
+    private static final float P2z = 0.037f;
+    private static final float P3x = 0.34f;
+    private static final float P3y = 0.12f;
+    private static final float P3z = 0.9f;
+
+    public static final Vector3 snoise(float x) {
+        return new Vector3(PerlinScalar.snoise(x + P1x), PerlinScalar.snoise(x + P2x), PerlinScalar.snoise(x + P3x));
+    }
+
+    public static final Vector3 snoise(float x, float y) {
+        return new Vector3(PerlinScalar.snoise(x + P1x, y + P1y), PerlinScalar.snoise(x + P2x, y + P2y), PerlinScalar.snoise(x + P3x, y + P3y));
+    }
+
+    public static final Vector3 snoise(float x, float y, float z) {
+        return new Vector3(PerlinScalar.snoise(x + P1x, y + P1y, z + P1z), PerlinScalar.snoise(x + P2x, y + P2y, z + P2z), PerlinScalar.snoise(x + P3x, y + P3y, z + P3z));
+    }
+
+    public static final Vector3 snoise(float x, float y, float z, float t) {
+        return new Vector3(PerlinScalar.snoise(x + P1x, y + P1y, z + P1z, t), PerlinScalar.snoise(x + P2x, y + P2y, z + P2z, t), PerlinScalar.snoise(x + P3x, y + P3y, z + P3z, t));
+    }
+
+    public static final Vector3 snoise(Point2 p) {
+        return snoise(p.x, p.y);
+    }
+
+    public static final Vector3 snoise(Point3 p) {
+        return snoise(p.x, p.y, p.z);
+    }
+
+    public static final Vector3 snoise(Point3 p, float t) {
+        return snoise(p.x, p.y, p.z, t);
+    }
+
+    public static final Vector3 noise(float x) {
+        return new Vector3(PerlinScalar.noise(x + P1x), PerlinScalar.noise(x + P2x), PerlinScalar.noise(x + P3x));
+    }
+
+    public static final Vector3 noise(float x, float y) {
+        return new Vector3(PerlinScalar.noise(x + P1x, y + P1y), PerlinScalar.noise(x + P2x, y + P2y), PerlinScalar.noise(x + P3x, y + P3y));
+    }
+
+    public static final Vector3 noise(float x, float y, float z) {
+        return new Vector3(PerlinScalar.noise(x + P1x, y + P1y, z + P1z), PerlinScalar.noise(x + P2x, y + P2y, z + P2z), PerlinScalar.noise(x + P3x, y + P3y, z + P3z));
+    }
+
+    public static final Vector3 noise(float x, float y, float z, float t) {
+        return new Vector3(PerlinScalar.noise(x + P1x, y + P1y, z + P1z, t), PerlinScalar.noise(x + P2x, y + P2y, z + P2z, t), PerlinScalar.noise(x + P3x, y + P3y, z + P3z, t));
+    }
+
+    public static final Vector3 noise(Point2 p) {
+        return noise(p.x, p.y);
+    }
+
+    public static final Vector3 noise(Point3 p) {
+        return noise(p.x, p.y, p.z);
+    }
+
+    public static final Vector3 noise(Point3 p, float t) {
+        return noise(p.x, p.y, p.z, t);
+    }
+
+    public static final Vector3 pnoise(float x, float period) {
+        return new Vector3(PerlinScalar.pnoise(x + P1x, period), PerlinScalar.pnoise(x + P2x, period), PerlinScalar.pnoise(x + P3x, period));
+    }
+
+    public static final Vector3 pnoise(float x, float y, float w, float h) {
+        return new Vector3(PerlinScalar.pnoise(x + P1x, y + P1y, w, h), PerlinScalar.pnoise(x + P2x, y + P2y, w, h), PerlinScalar.pnoise(x + P3x, y + P3y, w, h));
+    }
+
+    public static final Vector3 pnoise(float x, float y, float z, float w, float h, float d) {
+        return new Vector3(PerlinScalar.pnoise(x + P1x, y + P1y, z + P1z, w, h, d), PerlinScalar.pnoise(x + P2x, y + P2y, z + P2z, w, h, d), PerlinScalar.pnoise(x + P3x, y + P3y, z + P3z, w, h, d));
+    }
+
+    public static final Vector3 pnoise(float x, float y, float z, float t, float w, float h, float d, float p) {
+        return new Vector3(PerlinScalar.pnoise(x + P1x, y + P1y, z + P1z, t, w, h, d, p), PerlinScalar.pnoise(x + P2x, y + P2y, z + P2z, t, w, h, d, p), PerlinScalar.pnoise(x + P3x, y + P3y, z + P3z, t, w, h, d, p));
+    }
+
+    public static final Vector3 pnoise(Point2 p, float periodx, float periody) {
+        return pnoise(p.x, p.y, periodx, periody);
+    }
+
+    public static final Vector3 pnoise(Point3 p, Vector3 period) {
+        return pnoise(p.x, p.y, p.z, period.x, period.y, period.z);
+    }
+
+    public static final Vector3 pnoise(Point3 p, float t, Vector3 pperiod, float tperiod) {
+        return pnoise(p.x, p.y, p.z, t, pperiod.x, pperiod.y, pperiod.z, tperiod);
+    }
+
+    public static final Vector3 spnoise(float x, float period) {
+        return new Vector3(PerlinScalar.spnoise(x + P1x, period), PerlinScalar.spnoise(x + P2x, period), PerlinScalar.spnoise(x + P3x, period));
+    }
+
+    public static final Vector3 spnoise(float x, float y, float w, float h) {
+        return new Vector3(PerlinScalar.spnoise(x + P1x, y + P1y, w, h), PerlinScalar.spnoise(x + P2x, y + P2y, w, h), PerlinScalar.spnoise(x + P3x, y + P3y, w, h));
+    }
+
+    public static final Vector3 spnoise(float x, float y, float z, float w, float h, float d) {
+        return new Vector3(PerlinScalar.spnoise(x + P1x, y + P1y, z + P1z, w, h, d), PerlinScalar.spnoise(x + P2x, y + P2y, z + P2z, w, h, d), PerlinScalar.spnoise(x + P3x, y + P3y, z + P3z, w, h, d));
+    }
+
+    public static final Vector3 spnoise(float x, float y, float z, float t, float w, float h, float d, float p) {
+        return new Vector3(PerlinScalar.spnoise(x + P1x, y + P1y, z + P1z, t, w, h, d, p), PerlinScalar.spnoise(x + P2x, y + P2y, z + P2z, t, w, h, d, p), PerlinScalar.spnoise(x + P3x, y + P3y, z + P3z, t, w, h, d, p));
+    }
+
+    public static final Vector3 spnoise(Point2 p, float periodx, float periody) {
+        return spnoise(p.x, p.y, periodx, periody);
+    }
+
+    public static final Vector3 spnoise(Point3 p, Vector3 period) {
+        return spnoise(p.x, p.y, p.z, period.x, period.y, period.z);
+    }
+
+    public static final Vector3 spnoise(Point3 p, float t, Vector3 pperiod, float tperiod) {
+        return spnoise(p.x, p.y, p.z, t, pperiod.x, pperiod.y, pperiod.z, tperiod);
+    }
+}

data/src/main/java/org/sunflow/math/Point2.java

@@ -0,0 +1,36 @@
+package org.sunflow.math;
+
+public final class Point2 {
+
+    public float x, y;
+
+    public Point2() {
+    }
+
+    public Point2(float x, float y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public Point2(Point2 p) {
+        x = p.x;
+        y = p.y;
+    }
+
+    public final Point2 set(float x, float y) {
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+
+    public final Point2 set(Point2 p) {
+        x = p.x;
+        y = p.y;
+        return this;
+    }
+
+    @Override
+    public final String toString() {
+        return String.format("(%.2f, %.2f)", x, y);
+    }
+}

data/src/main/java/org/sunflow/math/Point3.java

@@ -0,0 +1,133 @@
+package org.sunflow.math;
+
+public final class Point3 {
+
+    public float x, y, z;
+
+    public Point3() {
+    }
+
+    public Point3(float x, float y, float z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public Point3(Point3 p) {
+        x = p.x;
+        y = p.y;
+        z = p.z;
+    }
+
+    public float get(int i) {
+        switch (i) {
+            case 0:
+                return x;
+            case 1:
+                return y;
+            default:
+                return z;
+        }
+    }
+
+    public final float distanceTo(Point3 p) {
+        float dx = x - p.x;
+        float dy = y - p.y;
+        float dz = z - p.z;
+        return (float) Math.sqrt((dx * dx) + (dy * dy) + (dz * dz));
+    }
+
+    public final float distanceTo(float px, float py, float pz) {
+        float dx = x - px;
+        float dy = y - py;
+        float dz = z - pz;
+        return (float) Math.sqrt((dx * dx) + (dy * dy) + (dz * dz));
+    }
+
+    public final float distanceToSquared(Point3 p) {
+        float dx = x - p.x;
+        float dy = y - p.y;
+        float dz = z - p.z;
+        return (dx * dx) + (dy * dy) + (dz * dz);
+    }
+
+    public final float distanceToSquared(float px, float py, float pz) {
+        float dx = x - px;
+        float dy = y - py;
+        float dz = z - pz;
+        return (dx * dx) + (dy * dy) + (dz * dz);
+    }
+
+    public final Point3 set(float x, float y, float z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+
+    public final Point3 set(Point3 p) {
+        x = p.x;
+        y = p.y;
+        z = p.z;
+        return this;
+    }
+
+    public static final Point3 add(Point3 p, Vector3 v, Point3 dest) {
+        dest.x = p.x + v.x;
+        dest.y = p.y + v.y;
+        dest.z = p.z + v.z;
+        return dest;
+    }
+
+    public static final Vector3 sub(Point3 p1, Point3 p2, Vector3 dest) {
+        dest.x = p1.x - p2.x;
+        dest.y = p1.y - p2.y;
+        dest.z = p1.z - p2.z;
+        return dest;
+    }
+
+    public static final Point3 mid(Point3 p1, Point3 p2, Point3 dest) {
+        dest.x = 0.5f * (p1.x + p2.x);
+        dest.y = 0.5f * (p1.y + p2.y);
+        dest.z = 0.5f * (p1.z + p2.z);
+        return dest;
+    }
+
+    public static final Point3 blend(Point3 p0, Point3 p1, float blend, Point3 dest) {
+        dest.x = (1 - blend) * p0.x + blend * p1.x;
+        dest.y = (1 - blend) * p0.y + blend * p1.y;
+        dest.z = (1 - blend) * p0.z + blend * p1.z;
+        return dest;
+    }
+
+    public static final Vector3 normal(Point3 p0, Point3 p1, Point3 p2) {
+        float edge1x = p1.x - p0.x;
+        float edge1y = p1.y - p0.y;
+        float edge1z = p1.z - p0.z;
+        float edge2x = p2.x - p0.x;
+        float edge2y = p2.y - p0.y;
+        float edge2z = p2.z - p0.z;
+        float nx = edge1y * edge2z - edge1z * edge2y;
+        float ny = edge1z * edge2x - edge1x * edge2z;
+        float nz = edge1x * edge2y - edge1y * edge2x;
+        return new Vector3(nx, ny, nz);
+    }
+
+    public static final Vector3 normal(Point3 p0, Point3 p1, Point3 p2, Vector3 dest) {
+        float edge1x = p1.x - p0.x;
+        float edge1y = p1.y - p0.y;
+        float edge1z = p1.z - p0.z;
+        float edge2x = p2.x - p0.x;
+        float edge2y = p2.y - p0.y;
+        float edge2z = p2.z - p0.z;
+        dest.x = edge1y * edge2z - edge1z * edge2y;
+        dest.y = edge1z * edge2x - edge1x * edge2z;
+        dest.z = edge1x * edge2y - edge1y * edge2x;
+        return dest;
+    }
+
+    @Override
+    public final String toString() {
+        return String.format("(%.2f, %.2f, %.2f)", x, y, z);
+    }
+}

data/src/main/java/org/sunflow/math/QMC.java

@@ -0,0 +1,209 @@
+package org.sunflow.math;
+
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public final class QMC {
+
+    public static final int MAX_SIGMA_ORDER = 15;
+    private static final int NUM = 128;
+    private static final int[][] SIGMA = new int[NUM][];
+    private static final int[] PRIMES = new int[NUM];
+    private static final int[] FIBONACCI = new int[47];
+    private static final double[] FIBONACCI_INV = new double[FIBONACCI.length];
+    private static final double[] KOROBOV = new double[NUM];
+
+    static {
+        UI.printInfo(Module.QMC, "Initializing Faure scrambling tables ...");
+        // build table of first primes
+        PRIMES[0] = 2;
+        for (int i = 1; i < PRIMES.length; i++) {
+            PRIMES[i] = nextPrime(PRIMES[i - 1]);
+        }
+        int[][] table = new int[PRIMES[PRIMES.length - 1] + 1][];
+        table[2] = new int[2];
+        table[2][0] = 0;
+        table[2][1] = 1;
+        for (int i = 3; i <= PRIMES[PRIMES.length - 1]; i++) {
+            table[i] = new int[i];
+            if ((i & 1) == 0) {
+                int[] prev = table[i >> 1];
+                for (int j = 0; j < prev.length; j++) {
+                    table[i][j] = 2 * prev[j];
+                }
+                for (int j = 0; j < prev.length; j++) {
+                    table[i][prev.length + j] = 2 * prev[j] + 1;
+                }
+            } else {
+                int[] prev = table[i - 1];
+                int med = (i - 1) >> 1;
+                for (int j = 0; j < med; j++) {
+                    table[i][j] = prev[j] + ((prev[j] >= med) ? 1 : 0);
+                }
+                table[i][med] = med;
+                for (int j = 0; j < med; j++) {
+                    table[i][med + j + 1] = prev[j + med] + ((prev[j + med] >= med) ? 1 : 0);
+                }
+            }
+        }
+        for (int i = 0; i < PRIMES.length; i++) {
+            int p = PRIMES[i];
+            SIGMA[i] = new int[p];
+            System.arraycopy(table[p], 0, SIGMA[i], 0, p);
+        }
+        UI.printInfo(Module.QMC, "Initializing lattice tables ...");
+        FIBONACCI[0] = 0;
+        FIBONACCI[1] = 1;
+        for (int i = 2; i < FIBONACCI.length; i++) {
+            FIBONACCI[i] = FIBONACCI[i - 1] + FIBONACCI[i - 2];
+            FIBONACCI_INV[i] = 1.0 / FIBONACCI[i];
+        }
+        KOROBOV[0] = 1;
+        for (int i = 1; i < KOROBOV.length; i++) {
+            KOROBOV[i] = 203 * KOROBOV[i - 1];
+        }
+    }
+
+    private static final int nextPrime(int p) {
+        p = p + (p & 1) + 1;
+        while (true) {
+            int div = 3;
+            boolean isPrime = true;
+            while (isPrime && ((div * div) <= p)) {
+                isPrime = ((p % div) != 0);
+                div += 2;
+            }
+            if (isPrime) {
+                return p;
+            }
+            p += 2;
+        }
+    }
+
+    private QMC() {
+    }
+
+    public static double riVDC(int bits, int r) {
+        bits = (bits << 16) | (bits >>> 16);
+        bits = ((bits & 0x00ff00ff) << 8) | ((bits & 0xff00ff00) >>> 8);
+        bits = ((bits & 0x0f0f0f0f) << 4) | ((bits & 0xf0f0f0f0) >>> 4);
+        bits = ((bits & 0x33333333) << 2) | ((bits & 0xcccccccc) >>> 2);
+        bits = ((bits & 0x55555555) << 1) | ((bits & 0xaaaaaaaa) >>> 1);
+        bits ^= r;
+        return (double) (bits & 0xFFFFFFFFL) / (double) 0x100000000L;
+    }
+
+    public static double riS(int i, int r) {
+        for (int v = 1 << 31; i != 0; i >>>= 1, v ^= v >>> 1) {
+            if ((i & 1) != 0) {
+                r ^= v;
+            }
+        }
+        return (double) (r & 0xFFFFFFFFL) / (double) 0x100000000L;
+    }
+
+    public static double riLP(int i, int r) {
+        for (int v = 1 << 31; i != 0; i >>>= 1, v |= v >>> 1) {
+            if ((i & 1) != 0) {
+                r ^= v;
+            }
+        }
+        return (double) (r & 0xFFFFFFFFL) / (double) 0x100000000L;
+    }
+
+    public static final double halton(int d, int i) {
+        // generalized Halton sequence
+        switch (d) {
+            case 0: {
+                i = (i << 16) | (i >>> 16);
+                i = ((i & 0x00ff00ff) << 8) | ((i & 0xff00ff00) >>> 8);
+                i = ((i & 0x0f0f0f0f) << 4) | ((i & 0xf0f0f0f0) >>> 4);
+                i = ((i & 0x33333333) << 2) | ((i & 0xcccccccc) >>> 2);
+                i = ((i & 0x55555555) << 1) | ((i & 0xaaaaaaaa) >>> 1);
+                return (double) (i & 0xFFFFFFFFL) / (double) 0x100000000L;
+            }
+            case 1: {
+                double v = 0;
+                double inv = 1.0 / 3;
+                double p;
+                int n;
+                for (p = inv, n = i; n != 0; p *= inv, n /= 3) {
+                    v += (n % 3) * p;
+                }
+                return v;
+            }
+            default:
+        }
+        int base = PRIMES[d];
+        int[] perm = SIGMA[d];
+        double v = 0;
+        double inv = 1.0 / base;
+        double p;
+        int n;
+        for (p = inv, n = i; n != 0; p *= inv, n /= base) {
+            v += perm[n % base] * p;
+        }
+        return v;
+    }
+
+    /**
+     * Compute mod(x,1), assuming that x is positive or 0.
+     *
+     * @param x any number >= 0
+     * @return mod(x,1)
+     */
+    public static final double mod1(double x) {
+        // assumes x >= 0
+        return x - (int) x;
+    }
+
+    /**
+     * Compute sigma function used to seed QMC sequence trees. The sigma table
+     * is exactly 2^order elements long, and therefore i should be in the: [0,
+     * 2^order) interval. This function is equal to 2^order*halton(0,i)
+     *
+     * @param i index
+     * @param order
+     * @return sigma function
+     */
+    public static final int sigma(int i, int order) {
+        assert order > 0 && order < 32;
+        assert i >= 0 && i < (1 << order);
+        i = (i << 16) | (i >>> 16);
+        i = ((i & 0x00ff00ff) << 8) | ((i & 0xff00ff00) >>> 8);
+        i = ((i & 0x0f0f0f0f) << 4) | ((i & 0xf0f0f0f0) >>> 4);
+        i = ((i & 0x33333333) << 2) | ((i & 0xcccccccc) >>> 2);
+        i = ((i & 0x55555555) << 1) | ((i & 0xaaaaaaaa) >>> 1);
+        return i >>> (32 - order);
+    }
+
+    public static final int getFibonacciRank(int n) {
+        int k = 3;
+        while (FIBONACCI[k] <= n) {
+            k++;
+        }
+        return k - 1;
+    }
+
+    public static final int fibonacci(int k) {
+        return FIBONACCI[k];
+    }
+
+    public static final double fibonacciLattice(int k, int i, int d) {
+        return d == 0 ? i * FIBONACCI_INV[k] : mod1((i * FIBONACCI[k - 1]) * FIBONACCI_INV[k]);
+    }
+
+    public static final double reducedCPRotation(int k, int d, double x0, double x1) {
+        int j1 = FIBONACCI[2 * ((k - 1) >> 2) + 1];
+        int j2 = FIBONACCI[2 * ((k + 1) >> 2)];
+        if (d == 1) {
+            j1 = ((j1 * FIBONACCI[k - 1]) % FIBONACCI[k]);
+            j2 = ((j2 * FIBONACCI[k - 1]) % FIBONACCI[k]) - FIBONACCI[k];
+        }
+        return (x0 * j1 + x1 * j2) * FIBONACCI_INV[k];
+    }
+
+    public static final double korobovLattice(int m, int i, int d) {
+        return mod1(i * KOROBOV[d] / (1 << m));
+    }
+}