joonsrenderer 1.1-java

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

@@ -0,0 +1,142 @@
+package org.sunflow.math;
+
+public final class Solvers {
+
+    /**
+     * Solves the equation ax^2+bx+c=0. Solutions are returned in a sorted array
+     * if they exist.
+     *
+     * @param a coefficient of x^2
+     * @param b coefficient of x^1
+     * @param c coefficient of x^0
+     * @return an array containing the two real roots, or <code>null</code> if
+     * no real solutions exist
+     */
+    public static double[] solveQuadric(double a, double b, double c) {
+        double disc = b * b - 4 * a * c;
+        if (disc < 0) {
+            return null;
+        }
+        disc = Math.sqrt(disc);
+        double q = ((b < 0) ? -0.5 * (b - disc) : -0.5 * (b + disc));
+        double t0 = q / a;
+        double t1 = c / q;
+        // return sorted array
+        return (t0 > t1) ? new double[]{t1, t0} : new double[]{t0, t1};
+    }
+
+    /**
+     * Solve a quartic equation of the form ax^4+bx^3+cx^2+cx^1+d=0. The roots
+     * are returned in a sorted array of doubles in increasing order.
+     *
+     * @param a coefficient of x^4
+     * @param b coefficient of x^3
+     * @param c coefficient of x^2
+     * @param d coefficient of x^1
+     * @param e coefficient of x^0
+     * @return a sorted array of roots, or <code>null</code> if no solutions
+     * exist
+     */
+    public static double[] solveQuartic(double a, double b, double c, double d, double e) {
+        double inva = 1 / a;
+        double c1 = b * inva;
+        double c2 = c * inva;
+        double c3 = d * inva;
+        double c4 = e * inva;
+        // cubic resolvant
+        double c12 = c1 * c1;
+        double p = -0.375 * c12 + c2;
+        double q = 0.125 * c12 * c1 - 0.5 * c1 * c2 + c3;
+        double r = -0.01171875 * c12 * c12 + 0.0625 * c12 * c2 - 0.25 * c1 * c3 + c4;
+        double z = solveCubicForQuartic(-0.5 * p, -r, 0.5 * r * p - 0.125 * q * q);
+        double d1 = 2.0 * z - p;
+        if (d1 < 0) {
+            if (d1 > 1.0e-10) {
+                d1 = 0;
+            } else {
+                return null;
+            }
+        }
+        double d2;
+        if (d1 < 1.0e-10) {
+            d2 = z * z - r;
+            if (d2 < 0) {
+                return null;
+            }
+            d2 = Math.sqrt(d2);
+        } else {
+            d1 = Math.sqrt(d1);
+            d2 = 0.5 * q / d1;
+        }
+        // setup usefull values for the quadratic factors
+        double q1 = d1 * d1;
+        double q2 = -0.25 * c1;
+        double pm = q1 - 4 * (z - d2);
+        double pp = q1 - 4 * (z + d2);
+        if (pm >= 0 && pp >= 0) {
+            // 4 roots (!)
+            pm = Math.sqrt(pm);
+            pp = Math.sqrt(pp);
+            double[] results = new double[4];
+            results[0] = -0.5 * (d1 + pm) + q2;
+            results[1] = -0.5 * (d1 - pm) + q2;
+            results[2] = 0.5 * (d1 + pp) + q2;
+            results[3] = 0.5 * (d1 - pp) + q2;
+            // tiny insertion sort
+            for (int i = 1; i < 4; i++) {
+                for (int j = i; j > 0 && results[j - 1] > results[j]; j--) {
+                    double t = results[j];
+                    results[j] = results[j - 1];
+                    results[j - 1] = t;
+                }
+            }
+            return results;
+        } else if (pm >= 0) {
+            pm = Math.sqrt(pm);
+            double[] results = new double[2];
+            results[0] = -0.5 * (d1 + pm) + q2;
+            results[1] = -0.5 * (d1 - pm) + q2;
+            return results;
+        } else if (pp >= 0) {
+            pp = Math.sqrt(pp);
+            double[] results = new double[2];
+            results[0] = 0.5 * (d1 - pp) + q2;
+            results[1] = 0.5 * (d1 + pp) + q2;
+            return results;
+        }
+        return null;
+    }
+
+    /**
+     * Return only one root for the specified cubic equation. This routine is
+     * only meant to be called by the quartic solver. It assumes the cubic is of
+     * the form: x^3+px^2+qx+r.
+     *
+     * @param p
+     * @param q
+     * @param r
+     * @return
+     */
+    private static double solveCubicForQuartic(double p, double q, double r) {
+        double A2 = p * p;
+        double Q = (A2 - 3.0 * q) / 9.0;
+        double R = (p * (A2 - 4.5 * q) + 13.5 * r) / 27.0;
+        double Q3 = Q * Q * Q;
+        double R2 = R * R;
+        double d = Q3 - R2;
+        double an = p / 3.0;
+        if (d >= 0) {
+            d = R / Math.sqrt(Q3);
+            double theta = Math.acos(d) / 3.0;
+            double sQ = -2.0 * Math.sqrt(Q);
+            return sQ * Math.cos(theta) - an;
+        } else {
+            double sQ = Math.pow(Math.sqrt(R2 - Q3) + Math.abs(R), 1.0 / 3.0);
+            if (R < 0) {
+                return (sQ + Q / sQ) - an;
+            } else {
+                return -(sQ + Q / sQ) - an;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,197 @@
+package org.sunflow.math;
+
+public final class Vector3 {
+
+    private static final float[] COS_THETA = new float[256];
+    private static final float[] SIN_THETA = new float[256];
+    private static final float[] COS_PHI = new float[256];
+    private static final float[] SIN_PHI = new float[256];
+    public float x, y, z;
+
+    static {
+        // precompute tables to compress unit vectors
+        for (int i = 0; i < 256; i++) {
+            double angle = (i * Math.PI) / 256.0;
+            COS_THETA[i] = (float) Math.cos(angle);
+            SIN_THETA[i] = (float) Math.sin(angle);
+            COS_PHI[i] = (float) Math.cos(2 * angle);
+            SIN_PHI[i] = (float) Math.sin(2 * angle);
+        }
+    }
+
+    public Vector3() {
+    }
+
+    public Vector3(float x, float y, float z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public Vector3(Vector3 v) {
+        x = v.x;
+        y = v.y;
+        z = v.z;
+    }
+
+    public static final Vector3 decode(short n, Vector3 dest) {
+        int t = (n & 0xFF00) >>> 8;
+        int p = n & 0xFF;
+        dest.x = SIN_THETA[t] * COS_PHI[p];
+        dest.y = SIN_THETA[t] * SIN_PHI[p];
+        dest.z = COS_THETA[t];
+        return dest;
+    }
+
+    public static final Vector3 decode(short n) {
+        return decode(n, new Vector3());
+    }
+
+    public final short encode() {
+        int theta = (int) (Math.acos(z) * (256.0 / Math.PI));
+        if (theta > 255) {
+            theta = 255;
+        }
+        int phi = (int) (Math.atan2(y, x) * (128.0 / Math.PI));
+        if (phi < 0) {
+            phi += 256;
+        } else if (phi > 255) {
+            phi = 255;
+        }
+        return (short) (((theta & 0xFF) << 8) | (phi & 0xFF));
+    }
+
+    public float get(int i) {
+        switch (i) {
+            case 0:
+                return x;
+            case 1:
+                return y;
+            default:
+                return z;
+        }
+    }
+
+    public final float length() {
+        return (float) Math.sqrt((x * x) + (y * y) + (z * z));
+    }
+
+    public final float lengthSquared() {
+        return (x * x) + (y * y) + (z * z);
+    }
+
+    public final Vector3 negate() {
+        x = -x;
+        y = -y;
+        z = -z;
+        return this;
+    }
+
+    public final Vector3 negate(Vector3 dest) {
+        dest.x = -x;
+        dest.y = -y;
+        dest.z = -z;
+        return dest;
+    }
+
+    public final Vector3 mul(float s) {
+        x *= s;
+        y *= s;
+        z *= s;
+        return this;
+    }
+
+    public final Vector3 mul(float s, Vector3 dest) {
+        dest.x = x * s;
+        dest.y = y * s;
+        dest.z = z * s;
+        return dest;
+    }
+
+    public final Vector3 div(float d) {
+        x /= d;
+        y /= d;
+        z /= d;
+        return this;
+    }
+
+    public final Vector3 div(float d, Vector3 dest) {
+        dest.x = x / d;
+        dest.y = y / d;
+        dest.z = z / d;
+        return dest;
+    }
+
+    public final float normalizeLength() {
+        float n = (float) Math.sqrt(x * x + y * y + z * z);
+        float in = 1.0f / n;
+        x *= in;
+        y *= in;
+        z *= in;
+        return n;
+    }
+
+    public final Vector3 normalize() {
+        float in = 1.0f / (float) Math.sqrt((x * x) + (y * y) + (z * z));
+        x *= in;
+        y *= in;
+        z *= in;
+        return this;
+    }
+
+    public final Vector3 normalize(Vector3 dest) {
+        float in = 1.0f / (float) Math.sqrt((x * x) + (y * y) + (z * z));
+        dest.x = x * in;
+        dest.y = y * in;
+        dest.z = z * in;
+        return dest;
+    }
+
+    public final Vector3 set(float x, float y, float z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+    }
+
+    public final Vector3 set(Vector3 v) {
+        x = v.x;
+        y = v.y;
+        z = v.z;
+        return this;
+    }
+
+    public final float dot(float vx, float vy, float vz) {
+        return vx * x + vy * y + vz * z;
+    }
+
+    public static final float dot(Vector3 v1, Vector3 v2) {
+        return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
+    }
+
+    public static final Vector3 cross(Vector3 v1, Vector3 v2, Vector3 dest) {
+        dest.x = (v1.y * v2.z) - (v1.z * v2.y);
+        dest.y = (v1.z * v2.x) - (v1.x * v2.z);
+        dest.z = (v1.x * v2.y) - (v1.y * v2.x);
+        return dest;
+    }
+
+    public static final Vector3 add(Vector3 v1, Vector3 v2, Vector3 dest) {
+        dest.x = v1.x + v2.x;
+        dest.y = v1.y + v2.y;
+        dest.z = v1.z + v2.z;
+        return dest;
+    }
+
+    public static final Vector3 sub(Vector3 v1, Vector3 v2, Vector3 dest) {
+        dest.x = v1.x - v2.x;
+        dest.y = v1.y - v2.y;
+        dest.z = v1.z - v2.z;
+        return dest;
+    }
+
+    @Override
+    public final String toString() {
+        return String.format("(%.2f, %.2f, %.2f)", x, y, z);
+    }
+}

data/src/main/java/org/sunflow/system/BenchmarkFramework.java

@@ -0,0 +1,73 @@
+package org.sunflow.system;
+
+import org.sunflow.system.UI.Module;
+
+/**
+ * This class provides a very simple framework for running a BenchmarkTest
+ * kernel several times and time the results.
+ */
+public class BenchmarkFramework {
+
+    private Timer[] timers;
+    private int timeLimit; // time limit in seconds
+
+    public BenchmarkFramework(int iterations, int timeLimit) {
+        this.timeLimit = timeLimit;
+        timers = new Timer[iterations];
+    }
+
+    public void execute(BenchmarkTest test) {
+        // clear previous results
+        for (int i = 0; i < timers.length; i++) {
+            timers[i] = null;
+        }
+        // loop for the specified number of iterations or until the time limit
+        long startTime = System.nanoTime();
+        for (int i = 0; i < timers.length && ((System.nanoTime() - startTime) / 1000000000) < timeLimit; i++) {
+            UI.printInfo(Module.BENCH, "Running iteration %d", (i + 1));
+            timers[i] = new Timer();
+            test.kernelBegin();
+            timers[i].start();
+            test.kernelMain();
+            timers[i].end();
+            test.kernelEnd();
+        }
+        // report stats
+        double avg = 0;
+        double min = Double.POSITIVE_INFINITY;
+        double max = Double.NEGATIVE_INFINITY;
+        int n = 0;
+        for (Timer t : timers) {
+            if (t == null) {
+                break;
+            }
+            double s = t.seconds();
+            min = Math.min(min, s);
+            max = Math.max(max, s);
+            avg += s;
+            n++;
+        }
+        if (n == 0) {
+            return;
+        }
+        avg /= n;
+        double stdDev = 0;
+        for (Timer t : timers) {
+            if (t == null) {
+                break;
+            }
+            double s = t.seconds();
+            stdDev += (s - avg) * (s - avg);
+        }
+        stdDev = Math.sqrt(stdDev / n);
+        UI.printInfo(Module.BENCH, "Benchmark results:");
+        UI.printInfo(Module.BENCH, "  * Iterations: %d", n);
+        UI.printInfo(Module.BENCH, "  * Average:    %s", Timer.toString(avg));
+        UI.printInfo(Module.BENCH, "  * Fastest:    %s", Timer.toString(min));
+        UI.printInfo(Module.BENCH, "  * Longest:    %s", Timer.toString(max));
+        UI.printInfo(Module.BENCH, "  * Deviation:  %s", Timer.toString(stdDev));
+        for (int i = 0; i < timers.length && timers[i] != null; i++) {
+            UI.printDetailed(Module.BENCH, "  * Iteration %d: %s", i + 1, timers[i]);
+        }
+    }
+}

data/src/main/java/org/sunflow/system/BenchmarkTest.java

@@ -0,0 +1,17 @@
+package org.sunflow.system;
+
+/**
+ * This interface is used to represent a piece of code which is to be
+ * benchmarked by repeatedly running and timing the kernel code. The begin/end
+ * routines are called per-iteration to do any local initialization which is not
+ * meant to be taken into acount in the timing (like preparing or destroying
+ * data structures).
+ */
+public interface BenchmarkTest {
+
+    public void kernelBegin();
+
+    public void kernelMain();
+
+    public void kernelEnd();
+}

data/src/main/java/org/sunflow/system/ByteUtil.java

@@ -0,0 +1,119 @@
+package org.sunflow.system;
+
+public class ByteUtil {
+
+    public static byte[] get2Bytes(int i) {
+        byte[] b = new byte[2];
+
+        b[0] = (byte) (i & 0xFF);
+        b[1] = (byte) ((i >> 8) & 0xFF);
+
+        return b;
+    }
+
+    public static byte[] get4Bytes(int i) {
+        byte[] b = new byte[4];
+
+        b[0] = (byte) (i & 0xFF);
+        b[1] = (byte) ((i >> 8) & 0xFF);
+        b[2] = (byte) ((i >> 16) & 0xFF);
+        b[3] = (byte) ((i >> 24) & 0xFF);
+
+        return b;
+    }
+
+    public static byte[] get4BytesInv(int i) {
+        byte[] b = new byte[4];
+
+        b[3] = (byte) (i & 0xFF);
+        b[2] = (byte) ((i >> 8) & 0xFF);
+        b[1] = (byte) ((i >> 16) & 0xFF);
+        b[0] = (byte) ((i >> 24) & 0xFF);
+
+        return b;
+    }
+
+    public static byte[] get8Bytes(long i) {
+        byte[] b = new byte[8];
+
+        b[0] = (byte) (i & 0xFF);
+        b[1] = (byte) ((i >> 8) & 0xFF);
+        b[2] = (byte) ((i >> 16) & 0xFF);
+        b[3] = (byte) ((i >> 24) & 0xFF);
+
+        b[4] = (byte) ((i >> 32) & 0xFF);
+        b[5] = (byte) ((i >> 40) & 0xFF);
+        b[6] = (byte) ((i >> 48) & 0xFF);
+        b[7] = (byte) ((i >> 56) & 0xFF);
+
+        return b;
+    }
+
+    public static long toLong(byte[] in) {
+        return (((toInt(in[0], in[1], in[2], in[3]))) | ((long) (toInt(in[4], in[5], in[6], in[7])) << (long) 32));
+    }
+
+    public static int toInt(byte in0, byte in1, byte in2, byte in3) {
+        return (in0 & 0xFF) | ((in1 & 0xFF) << 8) | ((in2 & 0xFF) << 16) | ((in3 & 0xFF) << 24);
+    }
+
+    public static int toInt(byte[] in) {
+        return toInt(in[0], in[1], in[2], in[3]);
+    }
+
+    public static int toInt(byte[] in, int ofs) {
+        return toInt(in[ofs + 0], in[ofs + 1], in[ofs + 2], in[ofs + 3]);
+    }
+
+    public static int floatToHalf(float f) {
+        int i = Float.floatToRawIntBits(f);
+        // unpack the s, e and m of the float
+        int s = (i >> 16) & 0x00008000;
+        int e = ((i >> 23) & 0x000000ff) - (127 - 15);
+        int m = i & 0x007fffff;
+        // pack them back up, forming a half
+        if (e <= 0) {
+            if (e < -10) {
+                // E is less than -10. The absolute value of f is less than
+                // HALF_MIN
+                // convert f to 0
+                return 0;
+            }
+            // E is between -10 and 0.
+            m = (m | 0x00800000) >> (1 - e);
+            // Round to nearest, round "0.5" up.
+            if ((m & 0x00001000) == 0x00001000) {
+                m += 0x00002000;
+            }
+            // Assemble the half from s, e (zero) and m.
+            return s | (m >> 13);
+        } else if (e == 0xff - (127 - 15)) {
+            if (m == 0) {
+                // F is an infinity; convert f to a half infinity
+                return s | 0x7c00;
+            } else {
+                // F is a NAN; we produce a half NAN that preserves the sign bit
+                // and the 10 leftmost bits of the significand of f
+                m >>= 13;
+                return s | 0x7c00 | m | ((m == 0) ? 0 : 1);
+            }
+        } else {
+            // E is greater than zero. F is a normalized float. Round to
+            // nearest, round "0.5" up
+            if ((m & 0x00001000) == 0x00001000) {
+                m += 0x00002000;
+                if ((m & 0x00800000) == 0x00800000) {
+                    m = 0;
+                    e += 1;
+                }
+            }
+            // Handle exponent overflow
+            if (e > 30) {
+                // overflow (); // Cause a hardware floating point overflow;
+                return s | 0x7c00; // if this returns, the half becomes an
+            } // infinity with the same sign as f.
+            // Assemble the half from s, e and m.
+            return s | (e << 10) | (m >> 13);
+        }
+    }
+}