scparser.java

Sunflow是一个照片级的渲染系统

            }
            p.checkNextToken("points");
            float[] points = new float[3 * nu * nv];
            for (int i = 0; i < points.length; i++)
                points[i] = p.getNextFloat();
            api.parameter("points", "point", "vertex", points);
            if (p.peekNextToken("subdivs"))
                api.parameter("subdivs", p.getNextInt());
            if (p.peekNextToken("smooth"))
                api.parameter("smooth", p.getNextBoolean());
            api.geometry(name, (Tesselatable) new BezierMesh());
        } else {
            UI.printWarning(Module.API, "Unrecognized object type: %s", p.getNextToken());
            noInstance = true;
        }
        if (!noInstance) {
            // create instance
            api.parameter("shaders", shaders);
            if (modifiers != null)
                api.parameter("modifiers", modifiers);
            if (transform != null)
                api.parameter("transform", transform);
            api.instance(name + ".instance", name);
        }
        p.checkNextToken("}");
    }

    private void parseInstanceBlock(SunflowAPI api) throws ParserException, IOException {
        p.checkNextToken("{");
        p.checkNextToken("name");
        String name = p.getNextToken();
        UI.printInfo(Module.API, "Reading instance: %s ...", name);
        p.checkNextToken("geometry");
        String geoname = p.getNextToken();
        p.checkNextToken("transform");
        api.parameter("transform", parseMatrix());
        String[] shaders;
        if (p.peekNextToken("shaders")) {
            int n = p.getNextInt();
            shaders = new String[n];
            for (int i = 0; i < n; i++)
                shaders[i] = p.getNextToken();
        } else {
            p.checkNextToken("shader");
            shaders = new String[] { p.getNextToken() };
        }
        api.parameter("shaders", shaders);
        String[] modifiers = null;
        if (p.peekNextToken("modifiers")) {
            int n = p.getNextInt();
            modifiers = new String[n];
            for (int i = 0; i < n; i++)
                modifiers[i] = p.getNextToken();
        } else if (p.peekNextToken("modifier"))
            modifiers = new String[] { p.getNextToken() };
        if (modifiers != null)
            api.parameter("modifiers", modifiers);
        api.instance(name, geoname);
        p.checkNextToken("}");
    }

    private void parseLightBlock(SunflowAPI api) throws ParserException, IOException {
        p.checkNextToken("{");
        p.checkNextToken("type");
        if (p.peekNextToken("mesh")) {
            UI.printWarning(Module.API, "Deprecated light type: mesh");
            p.checkNextToken("name");
            String name = p.getNextToken();
            UI.printInfo(Module.API, "Reading light mesh: %s ...", name);
            p.checkNextToken("emit");
            api.parameter("radiance", parseColor());
            int samples = numLightSamples;
            if (p.peekNextToken("samples"))
                samples = p.getNextInt();
            else
                UI.printWarning(Module.API, "Samples keyword not found - defaulting to %d", samples);
            api.parameter("samples", samples);
            int numVertices = p.getNextInt();
            int numTriangles = p.getNextInt();
            float[] points = new float[3 * numVertices];
            int[] triangles = new int[3 * numTriangles];
            for (int i = 0; i < numVertices; i++) {
                p.checkNextToken("v");
                points[3 * i + 0] = p.getNextFloat();
                points[3 * i + 1] = p.getNextFloat();
                points[3 * i + 2] = p.getNextFloat();
                // ignored
                p.getNextFloat();
                p.getNextFloat();
                p.getNextFloat();
                p.getNextFloat();
                p.getNextFloat();
            }
            for (int i = 0; i < numTriangles; i++) {
                p.checkNextToken("t");
                triangles[3 * i + 0] = p.getNextInt();
                triangles[3 * i + 1] = p.getNextInt();
                triangles[3 * i + 2] = p.getNextInt();
            }
            api.parameter("points", "point", "vertex", points);
            api.parameter("triangles", triangles);
            TriangleMeshLight mesh = new TriangleMeshLight();
            mesh.init(name, api);
        } else if (p.peekNextToken("point")) {
            UI.printInfo(Module.API, "Reading point light ...");
            Color pow;
            if (p.peekNextToken("color")) {
                pow = parseColor();
                p.checkNextToken("power");
                float po = p.getNextFloat();
                pow.mul(po);
            } else {
                UI.printWarning(Module.API, "Deprecated color specification - please use color and power instead");
                p.checkNextToken("power");
                pow = parseColor();
            }
            p.checkNextToken("p");
            api.parameter("center", parsePoint());
            api.parameter("power", pow);
            api.light(api.getUniqueName("pointlight"), new PointLight());
        } else if (p.peekNextToken("spherical")) {
            UI.printInfo(Module.API, "Reading spherical light ...");
            p.checkNextToken("color");
            Color pow = parseColor();
            p.checkNextToken("radiance");
            pow.mul(p.getNextFloat());
            api.parameter("radiance", pow);
            p.checkNextToken("center");
            api.parameter("center", parsePoint());
            p.checkNextToken("radius");
            api.parameter("radius", p.getNextFloat());
            p.checkNextToken("samples");
            api.parameter("samples", p.getNextInt());
            SphereLight light = new SphereLight();
            light.init(api.getUniqueName("spherelight"), api);
        } else if (p.peekNextToken("directional")) {
            UI.printInfo(Module.API, "Reading directional light ...");
            p.checkNextToken("source");
            Point3 s = parsePoint();
            api.parameter("source", s);
            p.checkNextToken("target");
            Point3 t = parsePoint();
            api.parameter("dir", Point3.sub(t, s, new Vector3()));
            p.checkNextToken("radius");
            api.parameter("radius", p.getNextFloat());
            p.checkNextToken("emit");
            Color e = parseColor();
            if (p.peekNextToken("intensity")) {
                float i = p.getNextFloat();
                e.mul(i);
            } else
                UI.printWarning(Module.API, "Deprecated color specification - please use emit and intensity instead");
            api.parameter("radiance", e);
            api.light(api.getUniqueName("dirlight"), new DirectionalSpotlight());
        } else if (p.peekNextToken("ibl")) {
            UI.printInfo(Module.API, "Reading image based light ...");
            p.checkNextToken("image");
            api.parameter("texture", p.getNextToken());
            p.checkNextToken("center");
            api.parameter("center", parseVector());
            p.checkNextToken("up");
            api.parameter("up", parseVector());
            p.checkNextToken("lock");
            api.parameter("fixed", p.getNextBoolean());
            int samples = numLightSamples;
            if (p.peekNextToken("samples"))
                samples = p.getNextInt();
            else
                UI.printWarning(Module.API, "Samples keyword not found - defaulting to %d", samples);
            api.parameter("samples", samples);
            ImageBasedLight ibl = new ImageBasedLight();
            ibl.init(api.getUniqueName("ibl"), api);
        } else if (p.peekNextToken("meshlight")) {
            p.checkNextToken("name");
            String name = p.getNextToken();
            UI.printInfo(Module.API, "Reading meshlight: %s ...", name);
            p.checkNextToken("emit");
            Color e = parseColor();
            if (p.peekNextToken("radiance")) {
                float r = p.getNextFloat();
                e.mul(r);
            } else
                UI.printWarning(Module.API, "Deprecated color specification - please use emit and radiance instead");
            api.parameter("radiance", e);
            int samples = numLightSamples;
            if (p.peekNextToken("samples"))
                samples = p.getNextInt();
            else
                UI.printWarning(Module.API, "Samples keyword not found - defaulting to %d", samples);
            api.parameter("samples", samples);
            // parse vertices
            p.checkNextToken("points");
            int np = p.getNextInt();
            api.parameter("points", "point", "vertex", parseFloatArray(np * 3));
            // parse triangle indices
            p.checkNextToken("triangles");
            int nt = p.getNextInt();
            api.parameter("triangles", parseIntArray(nt * 3));
            TriangleMeshLight mesh = new TriangleMeshLight();
            mesh.init(name, api);
        } else if (p.peekNextToken("sunsky")) {
            p.checkNextToken("up");
            api.parameter("up", parseVector());
            p.checkNextToken("east");
            api.parameter("east", parseVector());
            p.checkNextToken("sundir");
            api.parameter("sundir", parseVector());
            p.checkNextToken("turbidity");
            api.parameter("turbidity", p.getNextFloat());
            if (p.peekNextToken("samples"))
                api.parameter("samples", p.getNextInt());
            SunSkyLight sunsky = new SunSkyLight();
            sunsky.init(api.getUniqueName("sunsky"), api);
        } else
            UI.printWarning(Module.API, "Unrecognized object type: %s", p.getNextToken());
        p.checkNextToken("}");
    }

    private Color parseColor() throws IOException, ParserException {
        if (p.peekNextToken("{")) {
            String space = p.getNextToken();
            Color c = null;
            if (space.equals("sRGB nonlinear")) {
                float r = p.getNextFloat();
                float g = p.getNextFloat();
                float b = p.getNextFloat();
                c = new Color(r, g, b);
                c.toLinear();
            } else if (space.equals("sRGB linear")) {
                float r = p.getNextFloat();
                float g = p.getNextFloat();
                float b = p.getNextFloat();
                c = new Color(r, g, b);
            } else
                UI.printWarning(Module.API, "Unrecognized color space: %s", space);
            p.checkNextToken("}");
            return c;
        } else {
            float r = p.getNextFloat();
            float g = p.getNextFloat();
            float b = p.getNextFloat();
            return new Color(r, g, b);
        }
    }

    private Point3 parsePoint() throws IOException {
        float x = p.getNextFloat();
        float y = p.getNextFloat();
        float z = p.getNextFloat();
        return new Point3(x, y, z);
    }

    private Vector3 parseVector() throws IOException {
        float x = p.getNextFloat();
        float y = p.getNextFloat();
        float z = p.getNextFloat();
        return new Vector3(x, y, z);
    }

    private int[] parseIntArray(int size) throws IOException {
        int[] data = new int[size];
        for (int i = 0; i < size; i++)
            data[i] = p.getNextInt();
        return data;
    }

    private float[] parseFloatArray(int size) throws IOException {
        float[] data = new float[size];
        for (int i = 0; i < size; i++)
            data[i] = p.getNextFloat();
        return data;
    }

    private Matrix4 parseMatrix() throws IOException, ParserException {
        if (p.peekNextToken("row")) {
            return new Matrix4(parseFloatArray(16), true);
        } else if (p.peekNextToken("col")) {
            return new Matrix4(parseFloatArray(16), false);
        } else {
            Matrix4 m = Matrix4.IDENTITY;
            p.checkNextToken("{");
            while (!p.peekNextToken("}")) {
                Matrix4 t = null;
                if (p.peekNextToken("translate")) {
                    float x = p.getNextFloat();
                    float y = p.getNextFloat();
                    float z = p.getNextFloat();
                    t = Matrix4.translation(x, y, z);
                } else if (p.peekNextToken("scaleu")) {
                    float s = p.getNextFloat();
                    t = Matrix4.scale(s);
                } else if (p.peekNextToken("scale")) {
                    float x = p.getNextFloat();
                    float y = p.getNextFloat();
                    float z = p.getNextFloat();
                    t = Matrix4.scale(x, y, z);
                } else if (p.peekNextToken("rotatex")) {
                    float angle = p.getNextFloat();
                    t = Matrix4.rotateX((float) Math.toRadians(angle));
                } else if (p.peekNextToken("rotatey")) {
                    float angle = p.getNextFloat();
                    t = Matrix4.rotateY((float) Math.toRadians(angle));
                } else if (p.peekNextToken("rotatez")) {
                    float angle = p.getNextFloat();
                    t = Matrix4.rotateZ((float) Math.toRadians(angle));
                } else if (p.peekNextToken("rotate")) {
                    float x = p.getNextFloat();
                    float y = p.getNextFloat();
                    float z = p.getNextFloat();
                    float angle = p.getNextFloat();
                    t = Matrix4.rotate(x, y, z, (float) Math.toRadians(angle));
                } else
                    UI.printWarning(Module.API, "Unrecognized transformation type: %s", p.getNextToken());
                if (t != null)
                    m = t.multiply(m);
            }
            return m;
        }
    }
}