C# Polygon.Triangulate方法代码示例

        /// <summary>
        /// This takes the feedback data and turns it into triangles.
        /// </summary>
        /// <param name="gl"></param>
        /// <param name="values">The number of triangles.</param>
        protected override void ParseData(OpenGL gl, int values)
        {
            int count = values;

            //	Create the triangle.
            triangle = new Polygon();
            triangle.Name = "Triangulated Polygon";

            //	For every value in the buffer...
            while (count != 0)
            {
                //	Get the token.
                float token = feedbackBuffer[values - count];

                //	Decrement count (move to the next token).
                count--;

                //	Check the type of the token.
                switch ((int)token)
                {
                    case (int)OpenGL.GL_PASS_THROUGH_TOKEN:
                        count--;
                        break;
                    case (int)OpenGL.GL_POINT_TOKEN:
                        //	We use only polygons, skip this single vertex (11 floats).
                        count -= 11;
                        break;
                    case (int)OpenGL.GL_LINE_TOKEN:
                        //	We use only polygons, skip this vertex pair (22 floats).
                        count -= 22;
                        break;
                    case (int)OpenGL.GL_LINE_RESET_TOKEN:
                        //	We use only polygons, skip this vertex pair (22 floats).
                        count -= 22;
                        break;
                    case (int)OpenGL.GL_POLYGON_TOKEN:

                        //	Get the number of vertices.
                        int vertexCount = (int)feedbackBuffer[values - count--];

                        //	Create an array of vertices.
                        Vertex[] vertices = new Vertex[vertexCount];

                        //	Parse them.
                        for (int i = 0; i < vertexCount; i++)
                        {
                            vertices[i] = new Vertex();
                            double x = (double)feedbackBuffer[values - count--];
                            double y = (double)feedbackBuffer[values - count--];
                            double z = (double)feedbackBuffer[values - count--];
                            double[] coords = gl.UnProject(x, y, z);
                            vertices[i].X = (float)coords[0];
                            vertices[i].Y = (float)coords[1];
                            vertices[i].Z = (float)coords[2];

                            //	Ignore the four r,g,b,a values and four material coords.
                            count -= 8;
                        }

                        //	Add a new face to the current polygon.
                        triangle.AddFaceFromVertexData(vertices);

                        break;
                }
            }

            //	Triangulate it.
            triangle.Triangulate();
        }

        /// <summary>
        /// This function reads a polygon.
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        protected override object ReadData(BinaryReader reader)
        {
            //	Create a polygon.
            Polygon poly = new Polygon();

            //	Read a name chunk.
            CaligariName name = new CaligariName();
            name.Read(reader);
            poly.Name = name.name;

            //	Read the local axies.
            CaligariAxies axies = new CaligariAxies();
            axies.Read(reader);
            poly.Transformation.TranslateX = axies.centre.X;
            poly.Transformation.TranslateY = axies.centre.Y;
            poly.Transformation.TranslateZ = axies.centre.Z;
            //	poly.Rotate = axies.rotate;

            //	Read the position matrix.
            CaligariPosition pos = new CaligariPosition();
            pos.Read(reader);

            //	Read number of verticies.
            int verticesCount = reader.ReadInt32();

            //	Get them all
            for (int i = 0; i < verticesCount; i++)
            {
                //	Read a vertex.
                Vertex vertex = new Vertex(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());

                //	Multiply it by the position matrix.
                vertex = vertex * pos.matrix;

                //	Add it.
                poly.Vertices.Add(vertex);
            }

            //	Read UV count.
            int uvsCount = reader.ReadInt32();

            //	Read all of the UVs
            for (int i = 0; i < uvsCount; i++)
                poly.UVs.Add(new UV(reader.ReadInt32(), reader.ReadInt32()));

            //	Read faces count.
            int faces = reader.ReadInt32();

            //	Read each face.
            for (int f = 0; f < faces; f++)
            {
                Face face = new Face();
                poly.Faces.Add(face);

                //	Read face type flags.
                byte flags = reader.ReadByte();

                //	Read vertex count
                short verticesInFace = reader.ReadInt16();

                //	Do we read a material number?
                if ((flags & 0x08) == 0)	//	is it a 'hole' face?
                    reader.ReadInt16();

                //	Now read the indices, a vertex index and a uv index.
                for (short j = 0; j < verticesInFace; j++)
                    face.Indices.Add(new Index(reader.ReadInt32(), reader.ReadInt32()));
            }

            //	Any extra stuff?
            if (header.minorVersion > 4)
            {
                //	read flags.
                reader.ReadChars(4);

                if ((header.minorVersion > 5) && (header.minorVersion < 8))
                    reader.ReadChars(2);
            }

            //	Now that we've loaded the polygon, we triangulate it.
            poly.Triangulate();

            //	Finally, we update normals.
            poly.Validate(true);

            return poly;
        }