joonsrenderer 1.1-java

data/src/main/java/org/sunflow/core/parser/Keyword.java

@@ -0,0 +1,39 @@
+package org.sunflow.core.parser;
+/**
+ * Public enums should live in their own file, we could do more here I am sure
+ * including things like enumset getting String value etc.
+ * @author Martin Prout
+ */
+public enum Keyword {
+    RESET, 
+    PARAMETER, 
+    GEOMETRY, 
+    INSTANCE, 
+    SHADER, 
+    MODIFIER, 
+    LIGHT, 
+    CAMERA, 
+    OPTIONS, 
+    INCLUDE, 
+    REMOVE, 
+    FRAME,
+    PLUGIN, 
+    SEARCHPATH, 
+    STRING, 
+    BOOL, 
+    INT, 
+    FLOAT, 
+    COLOR, 
+    POINT, 
+    VECTOR, 
+    TEXCOORD, 
+    MATRIX, 
+    STRING_ARRAY, 
+    INT_ARRAY, 
+    FLOAT_ARRAY, 
+    POINT_ARRAY, 
+    VECTOR_ARRAY, 
+    TEXCOORD_ARRAY, 
+    MATRIX_ARRAY, 
+    END_OF_FILE,
+}

data/src/main/java/org/sunflow/core/parser/RA2Parser.java

@@ -0,0 +1,107 @@
+package org.sunflow.core.parser;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+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.SunflowAPIInterface;
+import org.sunflow.core.SceneParser;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.Parser;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class RA2Parser implements SceneParser {
+
+    @Override
+    public boolean parse(String filename, SunflowAPIInterface api) {
+        try {
+            UI.printInfo(Module.USER, "RA2 - Reading geometry: \"%s\" ...", filename);
+            File file = new File(filename);
+            float[] data;
+            try (FileInputStream stream = new FileInputStream(filename)) {
+                MappedByteBuffer map = stream.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.length());
+                map.order(ByteOrder.LITTLE_ENDIAN);
+                FloatBuffer buffer = map.asFloatBuffer();
+                data = new float[buffer.capacity()];
+                for (int i = 0; i < data.length; i++) {
+                    data[i] = buffer.get(i);
+                }
+            }
+            api.parameter("points", "point", "vertex", data);
+            int[] triangles = new int[3 * (data.length / 9)];
+            for (int i = 0; i < triangles.length; i++) {
+                triangles[i] = i;
+            }
+            // create geo
+            api.parameter("triangles", triangles);
+            api.geometry(filename, "triangle_mesh");
+            // create shader
+            api.shader(filename + ".shader", "simple");
+            // create instance
+            api.parameter("shaders", filename + ".shader");
+            api.instance(filename + ".instance", filename);
+        } catch (FileNotFoundException e) {
+            Logger.getLogger(RA2Parser.class.getName()).log(Level.SEVERE, null, e);
+            return false;
+        } catch (IOException e) {
+            Logger.getLogger(RA2Parser.class.getName()).log(Level.SEVERE, null, e);
+            return false;
+        }
+        try {
+            filename = filename.replace(".ra2", ".txt");
+            UI.printInfo(Module.USER, "RA2 - Reading camera  : \"%s\" ...", filename);
+            Parser p = new Parser(filename);
+            Point3 eye = new Point3();
+            eye.x = p.getNextFloat();
+            eye.y = p.getNextFloat();
+            eye.z = p.getNextFloat();
+            Point3 to = new Point3();
+            to.x = p.getNextFloat();
+            to.y = p.getNextFloat();
+            to.z = p.getNextFloat();
+            Vector3 up = new Vector3();
+            switch (p.getNextInt()) {
+                case 0:
+                    up.set(1, 0, 0);
+                    break;
+                case 1:
+                    up.set(0, 1, 0);
+                    break;
+                case 2:
+                    up.set(0, 0, 1);
+                    break;
+                default:
+                    UI.printWarning(Module.USER, "RA2 - Invalid up vector specification - using Z axis");
+                    up.set(0, 0, 1);
+                    break;
+            }
+            api.parameter("eye", eye);
+            api.parameter("target", to);
+            api.parameter("up", up);
+            String cameraName = filename + ".camera";
+            api.parameter(FOV, 80f);
+            api.camera(cameraName, "pinhole");
+            api.parameter("camera", cameraName);
+            api.parameter("resolutionX", 1024);
+            api.parameter("resolutionY", 1024);
+            api.options(SunflowAPI.DEFAULT_OPTIONS);
+            p.close();
+        } catch (FileNotFoundException e) {
+            UI.printWarning(Module.USER, "RA2 - Camera file not found");
+        } catch (IOException e) {
+            Logger.getLogger(RA2Parser.class.getName()).log(Level.SEVERE, null, e);
+            return false;
+        }
+        return true;
+    }
+}

data/src/main/java/org/sunflow/core/parser/RA3Parser.java

@@ -0,0 +1,68 @@
+package org.sunflow.core.parser;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+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.SunflowAPIInterface;
+import org.sunflow.core.SceneParser;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public class RA3Parser implements SceneParser {
+
+    @Override
+    public boolean parse(String filename, SunflowAPIInterface api) {
+        try {
+            UI.printInfo(Module.USER, "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.USER, "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.USER, "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.USER, "RA3 -   * Creating mesh ...");
+
+            // create geometry
+            api.parameter("triangles", tris);
+            api.parameter("points", "point", "vertex", verts);
+            api.geometry(filename, "triangle_mesh");
+
+            // create default shader (this will simply error out if the shader
+            // already exists)
+            api.shader("ra3shader", "simple");
+            // create instance
+            api.parameter("shaders", "ra3shader");
+            api.instance(filename + ".instance", filename);
+        } catch (FileNotFoundException e) {
+            Logger.getLogger(RA3Parser.class.getName()).log(Level.SEVERE, null, e);
+            return false;
+        } catch (IOException e) {
+            Logger.getLogger(RA3Parser.class.getName()).log(Level.SEVERE, null, e);
+            return false;
+        }
+        return true;
+    }
+}

data/src/main/java/org/sunflow/core/parser/SCAbstractParser.java

@@ -0,0 +1,299 @@
+package org.sunflow.core.parser;
+
+import java.io.EOFException;
+import java.io.IOException;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.sunflow.SunflowAPIInterface;
+import org.sunflow.core.SceneParser;
+import org.sunflow.core.ParameterList.InterpolationType;
+import org.sunflow.image.ColorFactory;
+import org.sunflow.math.Matrix4;
+import org.sunflow.math.Point2;
+import org.sunflow.math.Point3;
+import org.sunflow.math.Vector3;
+import org.sunflow.system.Timer;
+import org.sunflow.system.UI;
+import org.sunflow.system.UI.Module;
+
+public abstract class SCAbstractParser implements SceneParser {
+
+  
+
+    @Override
+    public boolean parse(String filename, SunflowAPIInterface api) {
+        Timer timer = new Timer();
+        timer.start();
+        UI.printInfo(Module.API, "Parsing \"%s\" ...", filename);
+        try {
+            openParser(filename);
+            parseloop:
+            while (true) {
+                Keyword k = parseKeyword();
+                switch (k) {
+                    case RESET:
+                        api.reset();
+                        break;
+                    case PARAMETER:
+                        parseParameter(api);
+                        break;
+                    case GEOMETRY: {
+                        String name = parseString();
+                        String type = parseString();
+                        api.geometry(name, type);
+                        break;
+                    }
+                    case INSTANCE: {
+                        String name = parseString();
+                        String geoname = parseString();
+                        api.instance(name, geoname);
+                        break;
+                    }
+                    case SHADER: {
+                        String name = parseString();
+                        String type = parseString();
+                        api.shader(name, type);
+                        break;
+                    }
+                    case MODIFIER: {
+                        String name = parseString();
+                        String type = parseString();
+                        api.modifier(name, type);
+                        break;
+                    }
+                    case LIGHT: {
+                        String name = parseString();
+                        String type = parseString();
+                        api.light(name, type);
+                        break;
+                    }
+                    case CAMERA: {
+                        String name = parseString();
+                        String type = parseString();
+                        api.camera(name, type);
+                        break;
+                    }
+                    case OPTIONS: {
+                        api.options(parseString());
+                        break;
+                    }
+                    case INCLUDE: {
+                        String file = parseString();
+                        UI.printInfo(Module.API, "Including: \"%s\" ...", file);
+                        api.include(file);
+                        break;
+                    }
+                    case REMOVE: {
+                        api.remove(parseString());
+                        break;
+                    }
+                    case FRAME: {
+                        api.currentFrame(parseInt());
+                        break;
+                    }
+                    case PLUGIN: {
+                        String type = parseString();
+                        String name = parseString();
+                        String code = parseVerbatimString();
+                        api.plugin(type, name, code);
+                        break;
+                    }
+                    case SEARCHPATH: {
+                        String type = parseString();
+                        api.searchpath(type, parseString());
+                        break;
+                    }
+                    case END_OF_FILE: {
+                        // clean exit
+                        break parseloop;
+                    }
+                    default: {
+                        UI.printWarning(Module.API, "Unexpected token %s", k);
+                        break;
+                    }
+                }
+            }
+            closeParser();
+        } catch (IOException e) {
+            // catch all exceptions
+            Logger.getLogger(SCAbstractParser.class.getName()).log(Level.SEVERE, null, e);
+            UI.printError(Module.API, "%s", e.getMessage());
+            return false;
+        }
+        timer.end();
+        UI.printInfo(Module.API, "Done parsing (took %s)", timer.toString());
+        return true;
+    }
+
+    private void parseParameter(SunflowAPIInterface api) throws IOException {
+        String name = parseString();
+        Keyword k = parseKeyword();
+        switch (k) {
+            case STRING: {
+                api.parameter(name, parseString());
+                break;
+            }
+            case BOOL: {
+                api.parameter(name, parseBoolean());
+                break;
+            }
+            case INT: {
+                api.parameter(name, parseInt());
+                break;
+            }
+            case FLOAT: {
+                api.parameter(name, parseFloat());
+                break;
+            }
+            case COLOR: {
+                String colorspace = parseString();
+                int req = ColorFactory.getRequiredDataValues(colorspace);
+                if (req == -2) {
+                    api.parameter(name, colorspace); // call just to generate
+                } // an error
+                else {
+                    api.parameter(name, colorspace, parseFloatArray(req == -1 ? parseInt() : req));
+                }
+                break;
+            }
+            case POINT: {
+                api.parameter(name, parsePoint());
+                break;
+            }
+            case VECTOR: {
+                api.parameter(name, parseVector());
+                break;
+            }
+            case TEXCOORD: {
+                api.parameter(name, parseTexcoord());
+                break;
+            }
+            case MATRIX: {
+                api.parameter(name, parseMatrix());
+                break;
+            }
+            case STRING_ARRAY: {
+                int n = parseInt();
+                api.parameter(name, parseStringArray(n));
+                break;
+            }
+            case INT_ARRAY: {
+                int n = parseInt();
+                api.parameter(name, parseIntArray(n));
+                break;
+            }
+            case FLOAT_ARRAY: {
+                String interp = parseInterpolationType().toString();
+                int n = parseInt();
+                api.parameter(name, "float", interp, parseFloatArray(n));
+                break;
+            }
+            case POINT_ARRAY: {
+                String interp = parseInterpolationType().toString();
+                int n = parseInt();
+                api.parameter(name, "point", interp, parseFloatArray(3 * n));
+                break;
+            }
+            case VECTOR_ARRAY: {
+                String interp = parseInterpolationType().toString();
+                int n = parseInt();
+                api.parameter(name, "vector", interp, parseFloatArray(3 * n));
+                break;
+            }
+            case TEXCOORD_ARRAY: {
+                String interp = parseInterpolationType().toString();
+                int n = parseInt();
+                api.parameter(name, "texcoord", interp, parseFloatArray(2 * n));
+                break;
+            }
+            case MATRIX_ARRAY: {
+                String interp = parseInterpolationType().toString();
+                int n = parseInt();
+                api.parameter(name, "matrix", interp, parseMatrixArray(n));
+                break;
+            }
+            case END_OF_FILE:
+                throw new EOFException();
+            default: {
+                UI.printWarning(Module.API, "Unexpected keyword: %s", k);
+                break;
+            }
+        }
+    }
+
+    private String[] parseStringArray(int size) throws IOException {
+        String[] data = new String[size];
+        for (int i = 0; i < size; i++) {
+            data[i] = parseString();
+        }
+        return data;
+    }
+
+    private int[] parseIntArray(int size) throws IOException {
+        int[] data = new int[size];
+        for (int i = 0; i < size; i++) {
+            data[i] = parseInt();
+        }
+        return data;
+    }
+
+    protected float[] parseFloatArray(int size) throws IOException {
+        float[] data = new float[size];
+        for (int i = 0; i < size; i++) {
+            data[i] = parseFloat();
+        }
+        return data;
+    }
+
+    private float[] parseMatrixArray(int size) throws IOException {
+        float[] data = new float[16 * size];
+        for (int i = 0, offset = 0; i < size; i++, offset += 16) {
+            // copy the next matrix into a linear array - in row major order
+            float[] rowdata = parseMatrix().asRowMajor();
+            System.arraycopy(rowdata, 0, data, offset, 16);
+        }
+        return data;
+    }
+
+    private Point3 parsePoint() throws IOException {
+        float x = parseFloat();
+        float y = parseFloat();
+        float z = parseFloat();
+        return new Point3(x, y, z);
+    }
+
+    private Vector3 parseVector() throws IOException {
+        float x = parseFloat();
+        float y = parseFloat();
+        float z = parseFloat();
+        return new Vector3(x, y, z);
+    }
+
+    private Point2 parseTexcoord() throws IOException {
+        float x = parseFloat();
+        float y = parseFloat();
+        return new Point2(x, y);
+    }
+
+    protected abstract InterpolationType parseInterpolationType() throws IOException;
+
+    // abstract methods - to be implemented by subclasses
+    protected abstract void openParser(String filename) throws IOException;
+
+    protected abstract void closeParser() throws IOException;
+
+    protected abstract Keyword parseKeyword() throws IOException;
+
+    protected abstract boolean parseBoolean() throws IOException;
+
+    protected abstract int parseInt() throws IOException;
+
+    protected abstract float parseFloat() throws IOException;
+
+    protected abstract String parseString() throws IOException;
+
+    protected abstract String parseVerbatimString() throws IOException;
+
+    protected abstract Matrix4 parseMatrix() throws IOException;
+}