joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/tesselatable/BezierMesh.java

@@ -0,0 +1,254 @@
+package org.sunflow.core.tesselatable;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.PrimitiveList;
+import org.sunflow.core.Tesselatable;
+import org.sunflow.core.ParameterList.FloatParameter;
+import org.sunflow.core.ParameterList.InterpolationType;
+import org.sunflow.core.primitive.QuadMesh;
+import org.sunflow.core.primitive.TriangleMesh;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class BezierMesh implements Tesselatable {
+
+    private int subdivs;
+    private boolean smooth;
+    private boolean quads;
+    private float[][] patches;
+
+    public BezierMesh() {
+        this(null);
+    }
+
+    public BezierMesh(float[][] patches) {
+        subdivs = 8;
+        smooth = true;
+        quads = false;
+        // convert to single precision
+        this.patches = patches;
+    }
+
+    @Override
+    public BoundingBox getWorldBounds(Matrix4 o2w) {
+        BoundingBox bounds = new BoundingBox();
+        if (o2w == null) {
+            for (float[] patch : patches) {
+                for (int j = 0; j < patch.length; j += 3) {
+                    bounds.include(patch[j], patch[j + 1], patch[j + 2]);
+                }
+            }
+        } else {
+            // transform vertices first
+            for (float[] patch : patches) {
+                for (int j = 0; j < patch.length; j += 3) {
+                    float x = patch[j];
+                    float y = patch[j + 1];
+                    float z = patch[j + 2];
+                    float wx = o2w.transformPX(x, y, z);
+                    float wy = o2w.transformPY(x, y, z);
+                    float wz = o2w.transformPZ(x, y, z);
+                    bounds.include(wx, wy, wz);
+                }
+            }
+        }
+        return bounds;
+    }
+
+    private float[] bernstein(float u) {
+        float[] b = new float[4];
+        float i = 1 - u;
+        b[0] = i * i * i;
+        b[1] = 3 * u * i * i;
+        b[2] = 3 * u * u * i;
+        b[3] = u * u * u;
+        return b;
+    }
+
+    private float[] bernsteinDeriv(float u) {
+        if (!smooth) {
+            return null;
+        }
+        float[] b = new float[4];
+        float i = 1 - u;
+        b[0] = 3 * (0 - i * i);
+        b[1] = 3 * (i * i - 2 * u * i);
+        b[2] = 3 * (2 * u * i - u * u);
+        b[3] = 3 * (u * u - 0);
+        return b;
+    }
+
+    private void getPatchPoint(float u, float v, float[] ctrl, float[] bu, float[] bv, float[] bdu, float[] bdv, Point3 p, Vector3 n) {
+        float px = 0;
+        float py = 0;
+        float pz = 0;
+        for (int i = 0, index = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++, index += 3) {
+                float scale = bu[j] * bv[i];
+                px += ctrl[index + 0] * scale;
+                py += ctrl[index + 1] * scale;
+                pz += ctrl[index + 2] * scale;
+            }
+        }
+        p.x = px;
+        p.y = py;
+        p.z = pz;
+        if (n != null) {
+            float dpdux = 0;
+            float dpduy = 0;
+            float dpduz = 0;
+            float dpdvx = 0;
+            float dpdvy = 0;
+            float dpdvz = 0;
+            for (int i = 0, index = 0; i < 4; i++) {
+                for (int j = 0; j < 4; j++, index += 3) {
+                    float scaleu = bdu[j] * bv[i];
+                    dpdux += ctrl[index + 0] * scaleu;
+                    dpduy += ctrl[index + 1] * scaleu;
+                    dpduz += ctrl[index + 2] * scaleu;
+                    float scalev = bu[j] * bdv[i];
+                    dpdvx += ctrl[index + 0] * scalev;
+                    dpdvy += ctrl[index + 1] * scalev;
+                    dpdvz += ctrl[index + 2] * scalev;
+                }
+            }
+            // surface normal
+            n.x = (dpduy * dpdvz - dpduz * dpdvy);
+            n.y = (dpduz * dpdvx - dpdux * dpdvz);
+            n.z = (dpdux * dpdvy - dpduy * dpdvx);
+        }
+    }
+
+    @Override
+    public PrimitiveList tesselate() {
+        float[] vertices = new float[patches.length * (subdivs + 1) * (subdivs + 1) * 3];
+        float[] normals = smooth ? new float[patches.length * (subdivs + 1) * (subdivs + 1) * 3] : null;
+        float[] uvs = new float[patches.length * (subdivs + 1) * (subdivs + 1) * 2];
+        int[] indices = new int[patches.length * subdivs * subdivs * (quads ? 4 : (2 * 3))];
+
+        int vidx = 0, pidx = 0;
+        float step = 1.0f / subdivs;
+        int vstride = subdivs + 1;
+        Point3 p = new Point3();
+        Vector3 n = smooth ? new Vector3() : null;
+        for (float[] patch : patches) {
+            // create patch vertices
+            for (int i = 0, voff = 0; i <= subdivs; i++) {
+                float u = i * step;
+                float[] bu = bernstein(u);
+                float[] bdu = bernsteinDeriv(u);
+                for (int j = 0; j <= subdivs; j++, voff += 3) {
+                    float v = j * step;
+                    float[] bv = bernstein(v);
+                    float[] bdv = bernsteinDeriv(v);
+                    getPatchPoint(u, v, patch, bu, bv, bdu, bdv, p, n);
+                    vertices[vidx + voff + 0] = p.x;
+                    vertices[vidx + voff + 1] = p.y;
+                    vertices[vidx + voff + 2] = p.z;
+                    if (smooth) {
+                        normals[vidx + voff + 0] = n.x;
+                        normals[vidx + voff + 1] = n.y;
+                        normals[vidx + voff + 2] = n.z;
+                    }
+                    uvs[(vidx + voff) / 3 * 2 + 0] = u;
+                    uvs[(vidx + voff) / 3 * 2 + 1] = v;
+                }
+            }
+            // generate patch triangles
+            for (int i = 0, vbase = vidx / 3; i < subdivs; i++) {
+                for (int j = 0; j < subdivs; j++) {
+                    int v00 = (i + 0) * vstride + (j + 0);
+                    int v10 = (i + 1) * vstride + (j + 0);
+                    int v01 = (i + 0) * vstride + (j + 1);
+                    int v11 = (i + 1) * vstride + (j + 1);
+                    if (quads) {
+                        indices[pidx + 0] = vbase + v01;
+                        indices[pidx + 1] = vbase + v00;
+                        indices[pidx + 2] = vbase + v10;
+                        indices[pidx + 3] = vbase + v11;
+                        pidx += 4;
+                    } else {
+                        // add 2 triangles
+                        indices[pidx + 0] = vbase + v00;
+                        indices[pidx + 1] = vbase + v10;
+                        indices[pidx + 2] = vbase + v01;
+                        indices[pidx + 3] = vbase + v10;
+                        indices[pidx + 4] = vbase + v11;
+                        indices[pidx + 5] = vbase + v01;
+                        pidx += 6;
+                    }
+                }
+            }
+            vidx += vstride * vstride * 3;
+        }
+        ParameterList pl = new ParameterList();
+        pl.addPoints("points", InterpolationType.VERTEX, vertices);
+        if (quads) {
+            pl.addIntegerArray("quads", indices);
+        } else {
+            pl.addIntegerArray("triangles", indices);
+        }
+        pl.addTexCoords("uvs", InterpolationType.VERTEX, uvs);
+        if (smooth) {
+            pl.addVectors("normals", InterpolationType.VERTEX, normals);
+        }
+        PrimitiveList m = quads ? new QuadMesh() : new TriangleMesh();
+        m.update(pl, null);
+        pl.clear(true);
+        return m;
+    }
+
+    @Override
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        subdivs = pl.getInt("subdivs", subdivs);
+        smooth = pl.getBoolean("smooth", smooth);
+        quads = pl.getBoolean("quads", quads);
+        int nu = pl.getInt("nu", 0);
+        int nv = pl.getInt("nv", 0);
+        pl.setVertexCount(nu * nv);
+        boolean uwrap = pl.getBoolean("uwrap", false);
+        boolean vwrap = pl.getBoolean("vwrap", false);
+        FloatParameter points = pl.getPointArray("points");
+        if (points != null && points.interp == InterpolationType.VERTEX) {
+            int numUPatches = uwrap ? nu / 3 : (nu - 4) / 3 + 1;
+            int numVPatches = vwrap ? nv / 3 : (nv - 4) / 3 + 1;
+            if (numUPatches < 1 || numVPatches < 1) {
+                UI.printError(Module.GEOM, "Invalid number of patches for bezier mesh - ignoring");
+                return false;
+            }
+            // generate patches
+            patches = new float[numUPatches * numVPatches][];
+            for (int v = 0, p = 0; v < numVPatches; v++) {
+                for (int u = 0; u < numUPatches; u++, p++) {
+                    float[] patch = patches[p] = new float[16 * 3];
+                    int up = u * 3;
+                    int vp = v * 3;
+                    for (int pv = 0; pv < 4; pv++) {
+                        for (int pu = 0; pu < 4; pu++) {
+                            int meshU = (up + pu) % nu;
+                            int meshV = (vp + pv) % nv;
+                            // copy point
+                            patch[3 * (pv * 4 + pu) + 0] = points.data[3 * (meshU + nu * meshV) + 0];
+                            patch[3 * (pv * 4 + pu) + 1] = points.data[3 * (meshU + nu * meshV) + 1];
+                            patch[3 * (pv * 4 + pu) + 2] = points.data[3 * (meshU + nu * meshV) + 2];
+                        }
+                    }
+                }
+            }
+        }
+        if (subdivs < 1) {
+            UI.printError(Module.GEOM, "Invalid subdivisions for bezier mesh - ignoring");
+            return false;
+        }
+        if (patches == null) {
+            UI.printError(Module.GEOM, "No patch data present in bezier mesh - ignoring");
+            return false;
+        }
+        return true;
+    }
+}

data/src/main/java/org/sunflow/core/tesselatable/FileMesh.java

@@ -0,0 +1,251 @@
+package org.sunflow.core.tesselatable;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.FileChannel;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.sunflow.SunflowAPI;
+import org.sunflow.core.ParameterList;
+import org.sunflow.core.PrimitiveList;
+import org.sunflow.core.Tesselatable;
+import org.sunflow.core.ParameterList.InterpolationType;
+import org.sunflow.core.primitive.TriangleMesh;
+import org.sunflow.math.BoundingBox;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.Memory;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+import org.sunflow.util.FloatArray;
+import org.sunflow.util.IntArray;
+
+public class FileMesh implements Tesselatable {
+
+    private String filename = null;
+    private boolean smoothNormals = false;
+
+    @Override
+    public BoundingBox getWorldBounds(Matrix4 o2w) {
+        // world bounds can't be computed without reading file
+        // return null so the mesh will be loaded right away
+        return null;
+    }
+
+    @Override
+    public PrimitiveList tesselate() {
+        if (filename.endsWith(".ra3")) {
+            try {
+                UI.printInfo(Module.GEOM, "RA3 - Reading geometry: \"%s\" ...", filename);
+                File file = new File(filename);
+                float[] verts;
+                int[] tris;
+                try (FileInputStream stream = new FileInputStream(filename)) {
+                    MappedByteBuffer map = stream.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.length());
+                    map.order(ByteOrder.LITTLE_ENDIAN);
+                    IntBuffer ints = map.asIntBuffer();
+                    FloatBuffer buffer = map.asFloatBuffer();
+                    int numVerts = ints.get(0);
+                    int numTris = ints.get(1);
+                    UI.printInfo(Module.GEOM, "RA3 -   * Reading %d vertices ...", numVerts);
+                    verts = new float[3 * numVerts];
+                    for (int i = 0; i < verts.length; i++) {
+                        verts[i] = buffer.get(2 + i);
+                    }   UI.printInfo(Module.GEOM, "RA3 -   * Reading %d triangles ...", numTris);
+                    tris = new int[3 * numTris];
+                    for (int i = 0; i < tris.length; i++) {
+                        tris[i] = ints.get(2 + verts.length + i);
+                    }
+                }
+                UI.printInfo(Module.GEOM, "RA3 -   * Creating mesh ...");
+                return generate(tris, verts, smoothNormals);
+            } catch (FileNotFoundException e) {
+                Logger.getLogger(FileMesh.class.getName()).log(Level.SEVERE, null, e);
+                UI.printError(Module.GEOM, "Unable to read mesh file \"%s\" - file not found", filename);
+            } catch (IOException e) {
+                Logger.getLogger(FileMesh.class.getName()).log(Level.SEVERE, null, e);
+                UI.printError(Module.GEOM, "Unable to read mesh file \"%s\" - I/O error occured", filename);
+            }
+        } else if (filename.endsWith(".obj")) {
+            int lineNumber = 1;
+            try {
+                UI.printInfo(Module.GEOM, "OBJ - Reading geometry: \"%s\" ...", filename);
+                FloatArray verts = new FloatArray();
+                IntArray tris = new IntArray();
+                FileReader file = new FileReader(filename);
+                BufferedReader bf = new BufferedReader(file);
+                String line;
+                while ((line = bf.readLine()) != null) {
+                    if (line.startsWith("v")) {
+                        String[] v = line.split("\\s+");
+                        verts.add(Float.parseFloat(v[1]));
+                        verts.add(Float.parseFloat(v[2]));
+                        verts.add(Float.parseFloat(v[3]));
+                    } else if (line.startsWith("f")) {
+                        String[] f = line.split("\\s+");
+                        if (f.length == 5) {
+                            tris.add(Integer.parseInt(f[1]) - 1);
+                            tris.add(Integer.parseInt(f[2]) - 1);
+                            tris.add(Integer.parseInt(f[3]) - 1);
+                            tris.add(Integer.parseInt(f[1]) - 1);
+                            tris.add(Integer.parseInt(f[3]) - 1);
+                            tris.add(Integer.parseInt(f[4]) - 1);
+                        } else if (f.length == 4) {
+                            tris.add(Integer.parseInt(f[1]) - 1);
+                            tris.add(Integer.parseInt(f[2]) - 1);
+                            tris.add(Integer.parseInt(f[3]) - 1);
+                        }
+                    }
+                    if (lineNumber % 100000 == 0) {
+                        UI.printInfo(Module.GEOM, "OBJ -   * Parsed %7d lines ...", lineNumber);
+                    }
+                    lineNumber++;
+                }
+                file.close();
+                UI.printInfo(Module.GEOM, "OBJ -   * Creating mesh ...");
+                return generate(tris.trim(), verts.trim(), smoothNormals);
+            } catch (FileNotFoundException e) {
+                Logger.getLogger(FileMesh.class.getName()).log(Level.SEVERE, null, e);
+                UI.printError(Module.GEOM, "Unable to read mesh file \"%s\" - file not found", filename);
+            } catch (NumberFormatException e) {
+                Logger.getLogger(FileMesh.class.getName()).log(Level.SEVERE, null, e);
+                UI.printError(Module.GEOM, "Unable to read mesh file \"%s\" - syntax error at line %d", lineNumber);
+            } catch (IOException e) {
+                Logger.getLogger(FileMesh.class.getName()).log(Level.SEVERE, null, e);
+                UI.printError(Module.GEOM, "Unable to read mesh file \"%s\" - I/O error occured", filename);
+            }
+        } else if (filename.endsWith(".stl")) {
+            try {
+                UI.printInfo(Module.GEOM, "STL - Reading geometry: \"%s\" ...", filename);
+                FileInputStream file = new FileInputStream(filename);
+                DataInputStream stream = new DataInputStream(new BufferedInputStream(file));
+                file.skip(80);
+                int numTris = getLittleEndianInt(stream.readInt());
+                UI.printInfo(Module.GEOM, "STL -   * Reading %d triangles ...", numTris);
+                long filesize = new File(filename).length();
+                if (filesize != (84 + 50 * numTris)) {
+                    UI.printWarning(Module.GEOM, "STL - Size of file mismatch (expecting %s, found %s)", Memory.bytesToString(84 + 14 * numTris), Memory.bytesToString(filesize));
+                    return null;
+                }
+                int[] tris = new int[3 * numTris];
+                float[] verts = new float[9 * numTris];
+                for (int i = 0, i3 = 0, index = 0; i < numTris; i++, i3 += 3) {
+                    // skip normal
+                    stream.readInt();
+                    stream.readInt();
+                    stream.readInt();
+                    for (int j = 0; j < 3; j++, index += 3) {
+                        tris[i3 + j] = i3 + j;
+                        // get xyz
+                        verts[index + 0] = getLittleEndianFloat(stream.readInt());
+                        verts[index + 1] = getLittleEndianFloat(stream.readInt());
+                        verts[index + 2] = getLittleEndianFloat(stream.readInt());
+                    }
+                    stream.readShort();
+                    if ((i + 1) % 100000 == 0) {
+                        UI.printInfo(Module.GEOM, "STL -   * Parsed %7d triangles ...", i + 1);
+                    }
+                }
+                file.close();
+                // create geometry
+                UI.printInfo(Module.GEOM, "STL -   * Creating mesh ...");
+                if (smoothNormals) {
+                    UI.printWarning(Module.GEOM, "STL - format does not support shared vertices - normal smoothing disabled");
+                }
+                return generate(tris, verts, false);
+            } catch (FileNotFoundException e) {
+                Logger.getLogger(FileMesh.class.getName()).log(Level.SEVERE, null, e);
+                UI.printError(Module.GEOM, "Unable to read mesh file \"%s\" - file not found", filename);
+            } catch (IOException e) {
+                Logger.getLogger(FileMesh.class.getName()).log(Level.SEVERE, null, e);
+                UI.printError(Module.GEOM, "Unable to read mesh file \"%s\" - I/O error occured", filename);
+            }
+        } else {
+            UI.printWarning(Module.GEOM, "Unable to read mesh file \"%s\" - unrecognized format", filename);
+        }
+        return null;
+    }
+
+    private TriangleMesh generate(int[] tris, float[] verts, boolean smoothNormals) {
+        ParameterList pl = new ParameterList();
+        pl.addIntegerArray("triangles", tris);
+        pl.addPoints("points", InterpolationType.VERTEX, verts);
+        if (smoothNormals) {
+            float[] normals = new float[verts.length]; // filled with 0's
+            Point3 p0 = new Point3();
+            Point3 p1 = new Point3();
+            Point3 p2 = new Point3();
+            Vector3 n = new Vector3();
+            for (int i3 = 0; i3 < tris.length; i3 += 3) {
+                int v0 = tris[i3 + 0];
+                int v1 = tris[i3 + 1];
+                int v2 = tris[i3 + 2];
+                p0.set(verts[3 * v0 + 0], verts[3 * v0 + 1], verts[3 * v0 + 2]);
+                p1.set(verts[3 * v1 + 0], verts[3 * v1 + 1], verts[3 * v1 + 2]);
+                p2.set(verts[3 * v2 + 0], verts[3 * v2 + 1], verts[3 * v2 + 2]);
+                Point3.normal(p0, p1, p2, n); // compute normal
+                // add face normal to each vertex
+                // note that these are not normalized so this in fact weights
+                // each normal by the area of the triangle
+                normals[3 * v0 + 0] += n.x;
+                normals[3 * v0 + 1] += n.y;
+                normals[3 * v0 + 2] += n.z;
+                normals[3 * v1 + 0] += n.x;
+                normals[3 * v1 + 1] += n.y;
+                normals[3 * v1 + 2] += n.z;
+                normals[3 * v2 + 0] += n.x;
+                normals[3 * v2 + 1] += n.y;
+                normals[3 * v2 + 2] += n.z;
+            }
+            // normalize all the vectors
+            for (int i3 = 0; i3 < normals.length; i3 += 3) {
+                n.set(normals[i3 + 0], normals[i3 + 1], normals[i3 + 2]);
+                n.normalize();
+                normals[i3 + 0] = n.x;
+                normals[i3 + 1] = n.y;
+                normals[i3 + 2] = n.z;
+            }
+            pl.addVectors("normals", InterpolationType.VERTEX, normals);
+        }
+        TriangleMesh m = new TriangleMesh();
+        if (m.update(pl, null)) {
+            return m;
+        }
+        // something failed in creating the mesh, the error message will be
+        // printed by the mesh itself - no need to repeat it here
+        return null;
+    }
+
+    public boolean update(ParameterList pl, SunflowAPI api) {
+        String file = pl.getString("filename", null);
+        if (file != null) {
+            filename = api.resolveIncludeFilename(file);
+        }
+        smoothNormals = pl.getBoolean("smooth_normals", smoothNormals);
+        return filename != null;
+    }
+
+    private int getLittleEndianInt(int i) {
+        // input integer has its bytes in big endian byte order
+        // swap them around
+        return (i >>> 24) | ((i >>> 8) & 0xFF00) | ((i << 8) & 0xFF0000) | (i << 24);
+    }
+
+    private float getLittleEndianFloat(int i) {
+        // input integer has its bytes in big endian byte order
+        // swap them around and interpret data as floating point
+        return Float.intBitsToFloat(getLittleEndianInt(i));
+    }
+}