コード例 #1
0
ファイル: InstanceList.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox();
     foreach (Instance i in instances)
         bounds.include(i.getBounds());
     return bounds;
 }
コード例 #2
0
ファイル: BanchoffSurface.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox(1.5f);
     if (o2w != null)
         bounds = o2w.transform(bounds);
     return bounds;
 }
コード例 #3
0
ファイル: BezierMesh.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox();
     if (o2w == null)
     {
         for (int i = 0; i < patches.Length; i++)
         {
             float[] patch = patches[i];
             for (int j = 0; j < patch.Length; j += 3)
                 bounds.include(patch[j], patch[j + 1], patch[j + 2]);
         }
     }
     else
     {
         // transform vertices first
         for (int i = 0; i < patches.Length; i++)
         {
             float[] patch = patches[i];
             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;
 }
コード例 #4
0
ファイル: Box.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox(minX, minY, minZ);
     bounds.include(maxX, maxY, maxZ);
     if (o2w == null)
         return bounds;
     return o2w.transform(bounds);
 }
コード例 #5
0
ファイル: Torus.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox(-ro - ri, -ro - ri, -ri);
     bounds.include(ro + ri, ro + ri, ri);
     if (o2w != null)
         bounds = o2w.transform(bounds);
     return bounds;
 }
コード例 #6
0
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox();
     for (int i = 0, i3 = 0; i < n; i++, i3 += 3)
         bounds.include(particles[i3], particles[i3 + 1], particles[i3 + 2]);
     bounds.include(bounds.getMinimum().x - r, bounds.getMinimum().y - r, bounds.getMinimum().z - r);
     bounds.include(bounds.getMaximum().x + r, bounds.getMaximum().y + r, bounds.getMaximum().z + r);
     return o2w == null ? bounds : o2w.transform(bounds);
 }
コード例 #7
0
 public static Instance createTemporary(PrimitiveList primitives, Matrix4 transform, IShader shader)
 {
     Instance i = new Instance();
     i.o2w = new MovingMatrix4(transform);
     i.w2o = i.o2w.inverse();
     if (i.w2o == null) {
         UI.printError(UI.Module.GEOM, "Unable to compute transform inverse");
         return null;
     }
     i.geometry = new Geometry(primitives);
     i.shaders = new IShader[] { shader };
     i.updateBounds();
     return i;
 }
コード例 #8
0
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox();
     if (o2w == null)
     {
         for (int i = 0; i < points.Length; i += 3)
             bounds.include(points[i], points[i + 1], points[i + 2]);
     }
     else
     {
         // transform vertices first
         for (int i = 0; i < points.Length; i += 3)
         {
             float x = points[i];
             float y = points[i + 1];
             float z = points[i + 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;
 }
コード例 #9
0
ファイル: Matrix4.cs プロジェクト: rzel/sunflowsharp
 /**
  * Creates a rotation matrix about the Z axis.
  *
  * @param theta angle to rotate about the Z axis in radians
  * @return a new Matrix4 object representing the rotation
  */
 public static Matrix4 rotateZ(float theta)
 {
     Matrix4 m = new Matrix4();
     float s = (float)Math.Sin(theta);
     float c = (float)Math.Cos(theta);
     m.m22 = m.m33 = 1;
     m.m00 = m.m11 = c;
     m.m01 = -s;
     m.m10 = +s;
     return m;
 }
コード例 #10
0
 /**
  * Create a new ray by transforming the supplied one by the given matrix. If
  * the matrix is <code>null</code>, the original ray is returned.
  *
  * @param m matrix to transform the ray by
  */
 public Ray transform(Matrix4 m)
 {
     if (m == null)
         return this;
     Ray r = new Ray();
     r.ox = m.transformPX(ox, oy, oz);
     r.oy = m.transformPY(ox, oy, oz);
     r.oz = m.transformPZ(ox, oy, oz);
     r.dx = m.transformVX(dx, dy, dz);
     r.dy = m.transformVY(dx, dy, dz);
     r.dz = m.transformVZ(dx, dy, dz);
     r.tMin = tMin;
     r.tMax = tMax;
     return r;
 }
コード例 #11
0
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox(getPrimitiveBound(0, 1));
     if (o2w != null)
         bounds = o2w.transform(bounds);
     return bounds;
 }
コード例 #12
0
ファイル: Matrix4.cs プロジェクト: rzel/sunflowsharp
 /**
  * Create a translation matrix for the specified vector.
  *
  * @param x x component of translation
  * @param y y component of translation
  * @param z z component of translation
  * @return a new Matrix4 object representing the translation
  */
 public static Matrix4 translation(float x, float y, float z)
 {
     Matrix4 m = new Matrix4();
     m.m00 = m.m11 = m.m22 = m.m33 = 1;
     m.m03 = x;
     m.m13 = y;
     m.m23 = z;
     return m;
 }
コード例 #13
0
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     if (o2w == null)
         return bounds;
     return o2w.transform(bounds);
 }
コード例 #14
0
 /**
  * Constructs a simple static matrix.
  *
  * @param m matrix value at all times
  		 */
 public MovingMatrix4(Matrix4 m)
 {
     transforms = new Matrix4[] { m };
     t0 = t1 = 0;
     inv = 1;
 }
コード例 #15
0
 /**
  * Declare a parameter with the specified name and value. This parameter
  * will be added to the currently active parameter list.
  *
  * @param name parameter name
  * @param value parameter value
  */
 public void parameter(string name, Matrix4 value)
 {
     parameterList.addMatrices(name, ParameterList.InterpolationType.NONE, value.asRowMajor());
 }
コード例 #16
0
        private void parseObjectBlock(SunflowAPI api)
        {
            p.checkNextToken("{");
            bool noInstance = false;
            Matrix4[] transform = null;
              float transformTime0 = 0, transformTime1 = 0;
            string name = null;
            string[] shaders = null;
            string[] modifiers = null;
            if (p.peekNextToken("noinstance"))
            {
                // this indicates that the geometry is to be created, but not
                // instanced into the scene
                noInstance = true;
            }
            else
            {
                // these are the parameters to be passed to the instance
                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() };
                }
                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 (p.peekNextToken("transform")) {
              if (p.peekNextToken("steps")) {
            transform = new Matrix4[p.getNextInt()];
            p.checkNextToken("times");
            transformTime0 = p.getNextFloat();
            transformTime1 = p.getNextFloat();
            for (int i = 0; i < transform.Length; i++)
              transform[i] = parseMatrix();
              } else
            transform = new Matrix4[] { parseMatrix() };
            }
            }
            if (p.peekNextToken("accel"))
                api.parameter("accel", p.getNextToken());
            p.checkNextToken("type");
            string type = p.getNextToken();
            if (p.peekNextToken("name"))
                name = p.getNextToken();
            else
            name = generateUniqueName(type);
            if (type == "mesh")
            {
                UI.printWarning(UI.Module.API, "Deprecated object type: mesh");
                UI.printInfo(UI.Module.API, "Reading mesh: {0} ...", name);
                int numVertices = p.getNextInt();
                int numTriangles = p.getNextInt();
                float[] points = new float[numVertices * 3];
                float[] normals = new float[numVertices * 3];
                float[] uvs = new float[numVertices * 2];
                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();
                    normals[3 * i + 0] = p.getNextFloat();
                    normals[3 * i + 1] = p.getNextFloat();
                    normals[3 * i + 2] = p.getNextFloat();
                    uvs[2 * i + 0] = p.getNextFloat();
                    uvs[2 * i + 1] = p.getNextFloat();
                }
                int[] triangles = new int[numTriangles * 3];
                for (int i = 0; i < numTriangles; i++)
                {
                    p.checkNextToken("t");
                    triangles[i * 3 + 0] = p.getNextInt();
                    triangles[i * 3 + 1] = p.getNextInt();
                    triangles[i * 3 + 2] = p.getNextInt();
                }
                // create geometry
                api.parameter("triangles", triangles);
                api.parameter("points", "point", "vertex", points);
                api.parameter("normals", "vector", "vertex", normals);
                api.parameter("uvs", "texcoord", "vertex", uvs);
                api.geometry(name, "triangle_mesh");
            }
            else if (type == "flat-mesh")
            {
                UI.printWarning(UI.Module.API, "Deprecated object type: flat-mesh");
                UI.printInfo(UI.Module.API, "Reading flat mesh: {0} ...", name);
                int numVertices = p.getNextInt();
                int numTriangles = p.getNextInt();
                float[] points = new float[numVertices * 3];
                float[] uvs = new float[numVertices * 2];
                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();
                    p.getNextFloat();
                    p.getNextFloat();
                    p.getNextFloat();
                    uvs[2 * i + 0] = p.getNextFloat();
                    uvs[2 * i + 1] = p.getNextFloat();
                }
                int[] triangles = new int[numTriangles * 3];
                for (int i = 0; i < numTriangles; i++)
                {
                    p.checkNextToken("t");
                    triangles[i * 3 + 0] = p.getNextInt();
                    triangles[i * 3 + 1] = p.getNextInt();
                    triangles[i * 3 + 2] = p.getNextInt();
                }
                // create geometry
                api.parameter("triangles", triangles);
                api.parameter("points", "point", "vertex", points);
                api.parameter("uvs", "texcoord", "vertex", uvs);
            api.geometry(name, "triangle_mesh");
            }
            else if (type == "sphere")
            {
                UI.printInfo(UI.Module.API, "Reading sphere ...");
            api.geometry(name, "sphere");
                if (transform == null && !noInstance)
                {
                    // legacy method of specifying transformation for spheres
                    p.checkNextToken("c");
                    float x = p.getNextFloat();
                    float y = p.getNextFloat();
                    float z = p.getNextFloat();
                    p.checkNextToken("r");
                    float radius = p.getNextFloat();
                    api.parameter("transform", Matrix4.translation(x, y, z).multiply(Matrix4.scale(radius)));
                    api.parameter("shaders", shaders);
                    if (modifiers != null)
                        api.parameter("modifiers", modifiers);
                    api.instance(name + ".instance", name);
              // disable future auto-instancing - instance has already been created
                    noInstance = true;
                }
            }
              else if (type.Equals("cylinder"))
              {
            UI.printInfo(UI.Module.API, "Reading cylinder ...");
            api.geometry(name, "cylinder");
              }
            else if (type == "banchoff")
            {
                UI.printInfo(UI.Module.API, "Reading banchoff ...");
                api.geometry(name, "banchoff");
            }
            else if (type == "torus")
            {
                UI.printInfo(UI.Module.API, "Reading torus ...");
                p.checkNextToken("r");
                api.parameter("radiusInner", p.getNextFloat());
                api.parameter("radiusOuter", p.getNextFloat());
                api.geometry(name, "torus");
            }
              else if (type.Equals("sphereflake")) {
            UI.printInfo(UI.Module.API, "Reading sphereflake ...");
            if (p.peekNextToken("level"))
              api.parameter("level", p.getNextInt());
            if (p.peekNextToken("axis"))
              api.parameter("axis", parseVector());
            if (p.peekNextToken("radius"))
              api.parameter("radius", p.getNextFloat());
            api.geometry(name, "sphereflake");
              }
            else if (type == "plane")
            {
                UI.printInfo(UI.Module.API, "Reading plane ...");
                p.checkNextToken("p");
                api.parameter("center", parsePoint());
                if (p.peekNextToken("n"))
                {
                    api.parameter("normal", parseVector());
                }
                else
                {
                    p.checkNextToken("p");
                    api.parameter("point1", parsePoint());
                    p.checkNextToken("p");
                    api.parameter("point2", parsePoint());
                }
                api.geometry(name, "plane");
            }
            else if (type == "generic-mesh")
            {
                UI.printInfo(UI.Module.API, "Reading generic mesh: {0} ... ", name);
                // 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));
                // parse normals
                p.checkNextToken("normals");
                if (p.peekNextToken("vertex"))
                    api.parameter("normals", "vector", "vertex", parseFloatArray(np * 3));
                else if (p.peekNextToken("facevarying"))
                    api.parameter("normals", "vector", "facevarying", parseFloatArray(nt * 9));
                else
                    p.checkNextToken("none");
                // parse texture coordinates
                p.checkNextToken("uvs");
                if (p.peekNextToken("vertex"))
                    api.parameter("uvs", "texcoord", "vertex", parseFloatArray(np * 2));
                else if (p.peekNextToken("facevarying"))
                    api.parameter("uvs", "texcoord", "facevarying", parseFloatArray(nt * 6));
                else
                    p.checkNextToken("none");
                if (p.peekNextToken("face_shaders"))
                    api.parameter("faceshaders", parseIntArray(nt));
                api.geometry(name, "triangle_mesh");
            }
            else if (type == "hair")
            {
                UI.printInfo(UI.Module.API, "Reading hair curves: {0} ... ", name);
                p.checkNextToken("segments");
                api.parameter("segments", p.getNextInt());
                p.checkNextToken("width");
                api.parameter("widths", p.getNextFloat());
                p.checkNextToken("points");
                api.parameter("points", "point", "vertex", parseFloatArray(p.getNextInt()));
                api.geometry(name, "hair");
            }
            else if (type == "csharp-tesselatable")
            {
                UI.printInfo(UI.Module.API, "Reading procedural primitive: {0} ... ", name);
            string code = p.getNextCodeBlock();
                try
                {
              String typename = p.peekNextToken("typename") ? p.getNextToken() : PluginRegistry.tesselatablePlugins.generateUniqueName(name);
              if (!PluginRegistry.tesselatablePlugins.registerPlugin(typename, code))
            return;
              api.geometry(name, typename);

                }
                catch (Exception e)
                {
                    UI.printDetailed(UI.Module.API, "Compiling: {0}", code);
                    UI.printError(UI.Module.API, "{0}", e);
                    noInstance = true;
                }
            }
            else if (type == "teapot")
            {
                UI.printInfo(UI.Module.API, "Reading teapot: {0} ... ", name);
                if (p.peekNextToken("subdivs"))
                {
              api.parameter("subdivs", p.getNextInt());
                }
                if (p.peekNextToken("smooth"))
                {
                    api.parameter("smooth", p.getNextbool());
                }

            api.geometry(name, "teapot");
            }
            else if (type == "gumbo")
            {
                UI.printInfo(UI.Module.API, "Reading gumbo:{0} ... ", name);
                if (p.peekNextToken("subdivs"))
                {
                    api.parameter("subdivs", p.getNextInt());
                }
                if (p.peekNextToken("smooth"))
                {
                    api.parameter("smooth", p.getNextbool());
                }
                api.geometry(name, "gumbo");
            }
            else if (type == "julia")
            {
                UI.printInfo(UI.Module.API, "Reading julia fractal: {0} ... ", name);
                if (p.peekNextToken("q"))
                {
                    api.parameter("cw", p.getNextFloat());
                    api.parameter("cx", p.getNextFloat());
                    api.parameter("cy", p.getNextFloat());
                    api.parameter("cz", p.getNextFloat());
                }
                if (p.peekNextToken("iterations"))
                    api.parameter("iterations", p.getNextInt());
                if (p.peekNextToken("epsilon"))
                    api.parameter("epsilon", p.getNextFloat());
                api.geometry(name, "julia");
            }
            else if (type == "particles" || type == "dlasurface")
            {
                if (type == "dlasurface")
                    UI.printWarning(UI.Module.API, "Deprecated object type: \"dlasurface\" - please use \"particles\" instead");

            float[] data;

            if (p.peekNextToken("filename")) {

                  string filename = p.getNextToken();
                  bool littleEndian = false;
                  if (p.peekNextToken("little_endian"))
                      littleEndian = true;
                  UI.printInfo(UI.Module.USER, "Loading particle file: {0}", filename);
                  //File file = new File(filename);
                  //FileInputStream stream = new FileInputStream(filename);
                  //MappedByteBuffer map = stream.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.Length());
                  //if (littleEndian)
                  //    map.order(ByteOrder.LITTLE_ENDIAN);
                  //FloatBuffer buffer = map.asFloatBuffer();
                  BinaryReader reader = new BinaryReader(File.OpenRead(filename));
                  data = new float[reader.BaseStream.Length / 4];
              if (!littleEndian) {
            for (int i = 0; i < data.Length; i++) {
              byte[] newBytes = reader.ReadBytes(4);
              Array.Reverse(newBytes);
              data[i] = BitConverter.ToSingle(newBytes, 0);//buffer.get(i);
              //            UI.printInfo(UI.Module.USER, " particle {0}: {1}", i, data[i]);
            }
              } else {
                    for (int i = 0; i < data.Length; i++) {
                        data[i] = BitConverter.ToSingle(reader.ReadBytes(4), 0);//buffer.get(i);
              //              UI.printInfo(UI.Module.USER, " particle {0}: {1}", i, data[i]);
            }

              }

              reader.Close();

            } else {
              p.checkNextToken("points");
              int n = p.getNextInt();
              data = parseFloatArray(n * 3); // read 3n points
            }
                api.parameter("particles", "point", "vertex", data);
                if (p.peekNextToken("num"))
                    api.parameter("num", p.getNextInt());
                else
                    api.parameter("num", data.Length / 3);
                p.checkNextToken("radius");
                api.parameter("radius", p.getNextFloat());
                api.geometry(name, "particles");
            }
            else if (type == "file-mesh")
            {
                UI.printInfo(UI.Module.API, "Reading file mesh: {0} ... ", name);
                p.checkNextToken("filename");
                api.parameter("filename", p.getNextToken());
                if (p.peekNextToken("smooth_normals"))
                    api.parameter("smooth_normals", p.getNextbool());
                api.geometry(name, "file_mesh");
            }
            else if (type == "bezier-mesh")
            {
                UI.printInfo(UI.Module.API, "Reading bezier mesh: {0} ... ", name);
                p.checkNextToken("n");
                int nu, nv;
                api.parameter("nu", nu = p.getNextInt());
                api.parameter("nv", nv = p.getNextInt());
                if (p.peekNextToken("wrap"))
                {
                    api.parameter("uwrap", p.getNextbool());
                    api.parameter("vwrap", p.getNextbool());
                }
                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.getNextbool());
                api.geometry(name, "bezier_mesh");
            }
            else
            {
                UI.printWarning(UI.Module.API, "Unrecognized object type: {0}", p.getNextToken());
                noInstance = true;
            }
            if (!noInstance)
            {
                // create instance
                api.parameter("shaders", shaders);
                if (modifiers != null)
                    api.parameter("modifiers", modifiers);
            if (transform != null && transform.Length > 0) {
              if (transform.Length == 1)
             api.parameter("transform", transform[0]);
              else {
            api.parameter("transform.steps", transform.Length);
            api.parameter("transform.times", "float", "none", new float[] {
              transformTime0, transformTime1 });
            for (int i = 0; i < transform.Length; i++)
              api.parameter(string.Format("transform[{0}]", i), transform[i]);
              }
            }
                api.instance(name + ".instance", name);
            }
            p.checkNextToken("}");
        }
コード例 #17
0
ファイル: ParameterList.cs プロジェクト: rzel/sunflowsharp
 /**
  * Get the specified matrix parameter from this list.
  *
  * @param name name of the parameter
  * @param defaultValue value to return if not found
  * @return the value of the parameter specified or default value if not
  *         found
  */
 public Matrix4 getMatrix(string name, Matrix4 defaultValue)
 {
     Parameter p;
     if (list.TryGetValue(name, out p))
         if (isValidParameter(name, ParameterType.MATRIX, InterpolationType.NONE, 1, p))
             return p.getMatrix();
     return defaultValue;
 }
コード例 #18
0
ファイル: Matrix4.cs プロジェクト: rzel/sunflowsharp
        /**
         * Computes this*m and return the result as a new Matrix4
         *
         * @param m right hand side of the multiplication
         * @return a new Matrix4 object equal to <code>this*m</code>
         */
        public Matrix4 multiply(Matrix4 m)
        {
            // matrix multiplication is m[r][c] = (row[r]).(col[c])
            float rm00 = m00 * m.m00 + m01 * m.m10 + m02 * m.m20 + m03 * m.m30;
            float rm01 = m00 * m.m01 + m01 * m.m11 + m02 * m.m21 + m03 * m.m31;
            float rm02 = m00 * m.m02 + m01 * m.m12 + m02 * m.m22 + m03 * m.m32;
            float rm03 = m00 * m.m03 + m01 * m.m13 + m02 * m.m23 + m03 * m.m33;

            float rm10 = m10 * m.m00 + m11 * m.m10 + m12 * m.m20 + m13 * m.m30;
            float rm11 = m10 * m.m01 + m11 * m.m11 + m12 * m.m21 + m13 * m.m31;
            float rm12 = m10 * m.m02 + m11 * m.m12 + m12 * m.m22 + m13 * m.m32;
            float rm13 = m10 * m.m03 + m11 * m.m13 + m12 * m.m23 + m13 * m.m33;

            float rm20 = m20 * m.m00 + m21 * m.m10 + m22 * m.m20 + m23 * m.m30;
            float rm21 = m20 * m.m01 + m21 * m.m11 + m22 * m.m21 + m23 * m.m31;
            float rm22 = m20 * m.m02 + m21 * m.m12 + m22 * m.m22 + m23 * m.m32;
            float rm23 = m20 * m.m03 + m21 * m.m13 + m22 * m.m23 + m23 * m.m33;

            float rm30 = m30 * m.m00 + m31 * m.m10 + m32 * m.m20 + m33 * m.m30;
            float rm31 = m30 * m.m01 + m31 * m.m11 + m32 * m.m21 + m33 * m.m31;
            float rm32 = m30 * m.m02 + m31 * m.m12 + m32 * m.m22 + m33 * m.m32;
            float rm33 = m30 * m.m03 + m31 * m.m13 + m32 * m.m23 + m33 * m.m33;

            return new Matrix4(rm00, rm01, rm02, rm03, rm10, rm11, rm12, rm13, rm20, rm21, rm22, rm23, rm30, rm31, rm32, rm33);
        }
コード例 #19
0
ファイル: Matrix4.cs プロジェクト: rzel/sunflowsharp
        /**
         * Compute the inverse of this matrix and return it as a new object. If the
         * matrix is not invertible, <code>null</code> is returned.
         *
         * @return the inverse of this matrix, or <code>null</code> if not
         *         invertible
         */
        public Matrix4 inverse()
        {
            float A0 = m00 * m11 - m01 * m10;
            float A1 = m00 * m12 - m02 * m10;
            float A2 = m00 * m13 - m03 * m10;
            float A3 = m01 * m12 - m02 * m11;
            float A4 = m01 * m13 - m03 * m11;
            float A5 = m02 * m13 - m03 * m12;

            float B0 = m20 * m31 - m21 * m30;
            float B1 = m20 * m32 - m22 * m30;
            float B2 = m20 * m33 - m23 * m30;
            float B3 = m21 * m32 - m22 * m31;
            float B4 = m21 * m33 - m23 * m31;
            float B5 = m22 * m33 - m23 * m32;

            float det = A0 * B5 - A1 * B4 + A2 * B3 + A3 * B2 - A4 * B1 + A5 * B0;
            if (Math.Abs(det) < 1e-12f)
                return null; // matrix is not invertible
            float invDet = 1 / det;
            Matrix4 inv = new Matrix4();
            inv.m00 = (+m11 * B5 - m12 * B4 + m13 * B3) * invDet;
            inv.m10 = (-m10 * B5 + m12 * B2 - m13 * B1) * invDet;
            inv.m20 = (+m10 * B4 - m11 * B2 + m13 * B0) * invDet;
            inv.m30 = (-m10 * B3 + m11 * B1 - m12 * B0) * invDet;
            inv.m01 = (-m01 * B5 + m02 * B4 - m03 * B3) * invDet;
            inv.m11 = (+m00 * B5 - m02 * B2 + m03 * B1) * invDet;
            inv.m21 = (-m00 * B4 + m01 * B2 - m03 * B0) * invDet;
            inv.m31 = (+m00 * B3 - m01 * B1 + m02 * B0) * invDet;
            inv.m02 = (+m31 * A5 - m32 * A4 + m33 * A3) * invDet;
            inv.m12 = (-m30 * A5 + m32 * A2 - m33 * A1) * invDet;
            inv.m22 = (+m30 * A4 - m31 * A2 + m33 * A0) * invDet;
            inv.m32 = (-m30 * A3 + m31 * A1 - m32 * A0) * invDet;
            inv.m03 = (-m21 * A5 + m22 * A4 - m23 * A3) * invDet;
            inv.m13 = (+m20 * A5 - m22 * A2 + m23 * A1) * invDet;
            inv.m23 = (-m20 * A4 + m21 * A2 - m23 * A0) * invDet;
            inv.m33 = (+m20 * A3 - m21 * A1 + m22 * A0) * invDet;
            return inv;
        }
コード例 #20
0
 public BoundingBox GetWorldBounds(Matrix4 o2w)
 {
     if (o2w == null)
         return bb;
     return o2w.transform(bb);
 }
コード例 #21
0
ファイル: Instance.cs プロジェクト: rzel/sunflowsharp
 public bool update(ParameterList pl, SunflowAPI api)
 {
     string geometryName = pl.getstring("geometry", null);
     if (geometry == null || geometryName != null)
     {
         if (geometryName == null)
         {
             UI.printError(UI.Module.GEOM, "geometry parameter missing - unable to create instance");
             return false;
         }
         geometry = api.lookupGeometry(geometryName);
         if (geometry == null)
         {
             UI.printError(UI.Module.GEOM, "Geometry \"{0}\" was not declared yet - instance is invalid", geometryName);
             return false;
         }
     }
     string[] shaderNames = pl.getstringArray("shaders", null);
     if (shaderNames != null)
     {
         // new shader names have been provided
         shaders = new IShader[shaderNames.Length];
         for (int i = 0; i < shaders.Length; i++)
         {
             shaders[i] = api.lookupShader(shaderNames[i]);
             if (shaders[i] == null)
                 UI.printWarning(UI.Module.GEOM, "Shader \"{0}\" was not declared yet - ignoring", shaderNames[i]);
         }
     }
     else
     {
         // re-use existing shader array
     }
     string[] modifierNames = pl.getstringArray("modifiers", null);
     if (modifierNames != null)
     {
         // new modifier names have been provided
         modifiers = new Modifier[modifierNames.Length];
         for (int i = 0; i < modifiers.Length; i++)
         {
             modifiers[i] = api.lookupModifier(modifierNames[i]);
             if (modifiers[i] == null)
                 UI.printWarning(UI.Module.GEOM, "Modifier \"{0}\" was not declared yet - ignoring", modifierNames[i]);
         }
     }
     Matrix4 transform = pl.getMatrix("transform", o2w);
     if (transform != o2w)
     {
         o2w = transform;
         if (o2w != null)
         {
             w2o = o2w.inverse();
             if (w2o == null)
             {
                 UI.printError(UI.Module.GEOM, "Unable to compute transform inverse - determinant is: {0}", o2w.determinant());
                 return false;
             }
         }
         else
             o2w = w2o = null;
     }
     return true;
 }
コード例 #22
0
ファイル: ImageBasedLight.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     return null;
 }
コード例 #23
0
 /**
  * Updates the matrix for the given time step.
  *
  * @param i time step to update
  * @param m new value for the matrix at this time step
  */
 public void updateData(int i, Matrix4 m)
 {
     transforms[i] = m;
 }
コード例 #24
0
ファイル: Matrix4.cs プロジェクト: rzel/sunflowsharp
 /**
  * Creates a rotation matrix about the specified axis. The axis vector need
  * not be normalized.
  *
  * @param x x component of the axis vector
  * @param y y component of the axis vector
  * @param z z component of the axis vector
  * @param theta angle to rotate about the axis in radians
  * @return a new Matrix4 object representing the rotation
  */
 public static Matrix4 rotate(float x, float y, float z, float theta)
 {
     Matrix4 m = new Matrix4();
     float invLen = 1 / (float)Math.Sqrt(x * x + y * y + z * z);
     x *= invLen;
     y *= invLen;
     z *= invLen;
     float s = (float)Math.Sin(theta);
     float c = (float)Math.Cos(theta);
     float t = 1 - c;
     m.m00 = t * x * x + c;
     m.m11 = t * y * y + c;
     m.m22 = t * z * z + c;
     float txy = t * x * y;
     float sz = s * z;
     m.m01 = txy - sz;
     m.m10 = txy + sz;
     float txz = t * x * z;
     float sy = s * y;
     m.m02 = txz + sy;
     m.m20 = txz - sy;
     float tyz = t * y * z;
     float sx = s * x;
     m.m12 = tyz - sx;
     m.m21 = tyz + sx;
     m.m33 = 1;
     return m;
 }
コード例 #25
0
ファイル: Geometry.cs プロジェクト: rzel/sunflowsharp
        public BoundingBox getWorldBounds(Matrix4 o2w)
        {
            if (primitives == null)
            {

                BoundingBox b = tesselatable.getWorldBounds(o2w);
                if (b != null)
                    return b;
                if (builtTess == 0)
                    tesselate();
                if (primitives == null)
                    return null; // failed tesselation, return infinite bounding
                // box
            }
            return primitives.getWorldBounds(o2w);
        }
コード例 #26
0
ファイル: Matrix4.cs プロジェクト: rzel/sunflowsharp
 /**
  * Create a uniform scaling matrix.
  *
  * @param s scale factor for all three axes
  * @return a new Matrix4 object representing the uniform scale
  */
 public static Matrix4 scale(float s)
 {
     Matrix4 m = new Matrix4();
     m.m00 = m.m11 = m.m22 = s;
     m.m33 = 1;
     return m;
 }
コード例 #27
0
ファイル: Hair.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox();
     for (int i = 0, j = 0; i < points.Length; i += 3, j++)
     {
         float w = 0.5f * getWidth(j);
         bounds.include(points[i] - w, points[i + 1] - w, points[i + 2] - w);
         bounds.include(points[i] + w, points[i + 1] + w, points[i + 2] + w);
     }
     if (o2w != null)
         bounds = o2w.transform(bounds);
     return bounds;
 }
コード例 #28
0
ファイル: Matrix4.cs プロジェクト: rzel/sunflowsharp
 /**
  * Creates a non-uniform scaling matrix.
  *
  * @param sx scale factor in the x dimension
  * @param sy scale factor in the y dimension
  * @param sz scale factor in the z dimension
  * @return a new Matrix4 object representing the non-uniform scale
  */
 public static Matrix4 scale(float sx, float sy, float sz)
 {
     Matrix4 m = new Matrix4();
     m.m00 = sx;
     m.m11 = sy;
     m.m22 = sz;
     m.m33 = 1;
     return m;
 }
コード例 #29
0
ファイル: FileMesh.cs プロジェクト: rzel/sunflowsharp
 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;
 }
コード例 #30
0
ファイル: TriangleMesh.cs プロジェクト: rzel/sunflowsharp
 public BoundingBox getWorldBounds(Matrix4 o2w)
 {
     BoundingBox bounds = new BoundingBox();
     if (o2w == null)
     {
         for (int i = 0; i < triangleMesh.uvs.data.Length; i += 2)
             bounds.include(triangleMesh.uvs.data[i], triangleMesh.uvs.data[i + 1], 0);
     }
     else
     {
         // transform vertices first
         for (int i = 0; i < triangleMesh.uvs.data.Length; i += 2)
         {
             float x = triangleMesh.uvs.data[i];
             float y = triangleMesh.uvs.data[i + 1];
             float wx = o2w.transformPX(x, y, 0);
             float wy = o2w.transformPY(x, y, 0);
             float wz = o2w.transformPZ(x, y, 0);
             bounds.include(wx, wy, wz);
         }
     }
     return bounds;
 }