Beispiel #1
0
        public void GenerateVerticesRecursive(NodeContent input)
        {
            MeshContent mesh = input as MeshContent;

            if (mesh != null)
            {
                GeometryContentCollection gc = mesh.Geometry;
                foreach (GeometryContent g in gc)
                {
                    VertexContent vc = g.Vertices;
                    IndirectPositionCollection ipc = vc.Positions;
                    IndexCollection            ic  = g.Indices;

                    float[] vertexData = new float[ipc.Count * 3];
                    for (int i = 0; i < ipc.Count; i++)
                    {
                        Vector3 v0 = ipc[i];
                        vertexData[(i * 3) + 0] = v0.X;
                        vertexData[(i * 3) + 1] = v0.Y;
                        vertexData[(i * 3) + 2] = v0.Z;
                    }

                    int[] indexData = new int[ic.Count];
                    for (int j = 0; j < ic.Count; j++)
                    {
                        indexData[j] = ic[j] + indexOffset;
                    }

                    tag.appendVertexData(vertexData);
                    tag.appendIndexData(indexData);
                    indexOffset += ipc.Count;
                }
            }

            foreach (NodeContent child in input.Children)
            {
                GenerateVerticesRecursive(child);
            }
        }
Beispiel #2
0
 /// <summary>
 /// Constructs a VertexContent instance.
 /// </summary>
 internal VertexContent(GeometryContent geom)
 {
     positionIndices = new VertexChannel<int>("PositionIndices");
     positions = new IndirectPositionCollection(geom, positionIndices);
     channels = new VertexChannelCollection(this);
 }
        /// <summary>
        /// Breaks the input mesh into separate un-indexed triangles.
        /// </summary>
        /// <param name="input">Input MeshContent node.</param>
        /// <returns>Broken MeshContent</returns>
        private MeshContent ProcessMesh(NodeContent input)
        {
            MeshBuilder builder = MeshBuilder.StartMesh("model");

            MeshContent    mesh         = input as MeshContent;
            List <Vector3> normalList   = new List <Vector3>();
            List <Vector2> texCoordList = new List <Vector2>();

            if (mesh != null)
            {
                int normalChannel = builder.CreateVertexChannel <Vector3>(
                    VertexChannelNames.Normal());
                int texChannel = builder.CreateVertexChannel <Vector2>(
                    VertexChannelNames.TextureCoordinate(0));

                foreach (GeometryContent geometry in mesh.Geometry)
                {
                    IndirectPositionCollection positions = geometry.Vertices.Positions;

                    VertexChannel <Vector3> normals =
                        geometry.Vertices.Channels.Get <Vector3>(
                            VertexChannelNames.Normal());

                    VertexChannel <Vector2> texCoords =
                        geometry.Vertices.Channels.Get <Vector2>(
                            VertexChannelNames.TextureCoordinate(0));

                    // Copy the positions over
                    // To do that, we traverse the indices and grab the indexed
                    // position  and add it to the new mesh. This in effect will
                    // duplicate positions in the mesh reversing the compacting
                    // effect of using index buffers.
                    foreach (int i in geometry.Indices)
                    {
                        builder.CreatePosition(positions[i]);

                        // Save the normals and the texture coordinates for additon to
                        // the mesh later.
                        normalList.Add(normals[i]);
                        texCoordList.Add(texCoords[i]);
                    }
                }

                int index = 0;

                foreach (GeometryContent geometry in mesh.Geometry)
                {
                    // Save the material to the new mesh.
                    builder.SetMaterial(geometry.Material);

                    // Now we create the Triangles.
                    // To do that, we simply generate an index list that is sequential
                    // from 0 to geometry.Indices.Count
                    // This will create an index buffer that looks like: 0,1,2,3,4,5,...
                    for (int i = 0; i < geometry.Indices.Count; i++)
                    {
                        // Set the normal for the current vertex
                        builder.SetVertexChannelData(normalChannel, normalList[index]);
                        // Set the texture coordinates for the current vertex
                        builder.SetVertexChannelData(texChannel, texCoordList[index]);
                        builder.AddTriangleVertex(index);
                        index++;
                    }
                }
            }

            MeshContent finalMesh = builder.FinishMesh();

            // Copy the transform over from the source mesh to retain parent/child
            // relative transforms.
            finalMesh.Transform = input.Transform;

            // Now we take the new MeshContent and calculate the centers of all the
            // triangles. The centers are needed so that we can rotate the triangles
            // around them as we shatter the model.
            foreach (GeometryContent geometry in finalMesh.Geometry)
            {
                Vector3[] triangleCenters = new Vector3[geometry.Indices.Count / 3];
                Vector3[] trianglePoints  = new Vector3[2];

                IndirectPositionCollection positions = geometry.Vertices.Positions;

                for (int i = 0; i < positions.Count; i++)
                {
                    Vector3 position = positions[i];

                    if (i % 3 == 2)
                    {
                        // Calculate the center of the triangle.
                        triangleCenters[i / 3] = (trianglePoints[0] + trianglePoints[1]
                                                  + position) / 3;
                    }
                    else
                    {
                        trianglePoints[i % 3] = position;
                    }
                }

                // Add two new channels to the MeshContent:
                // triangleCenterChannel: This is the channel that will store the center
                // of the triangle that this vertex belongs to.
                // rotationalVelocityChannel: This channel has randomly generated values
                // for x,y and z rotational angles. This information will be used to
                // randomly rotate the triangles as they shatter from the model.
                geometry.Vertices.Channels.Add <Vector3>(
                    triangleCenterChannel,
                    new ReplicateTriangleDataToEachVertex <Vector3>(triangleCenters));
                geometry.Vertices.Channels.Add <Vector3>(
                    rotationalVelocityChannel,
                    new ReplicateTriangleDataToEachVertex <Vector3>(
                        new RandomVectorEnumerable(triangleCenters.Length)));
            }

            foreach (NodeContent child in input.Children)
            {
                finalMesh.Children.Add(ProcessMesh(child));
            }

            return(finalMesh);
        }
Beispiel #4
0
 /// <summary>
 /// Constructs a VertexContent instance.
 /// </summary>
 internal VertexContent()
 {
     channels = new VertexChannelCollection(this);
     positionIndices = new VertexChannel<int>("PositionIndices");
     positions = new IndirectPositionCollection();
 }