Exemplo n.º 1
0
        private float[] readVertices(CtmInputStream input, Grid grid, int vcount, float precision)
        {
            checkTag(input.readLittleInt(), VERT);
            int[] intVertices = input.readPackedInts(vcount, Mesh.CTM_POSITION_ELEMENT_COUNT, false);

            checkTag(input.readLittleInt(), GIDX);
            int[] gridIndices = input.readPackedInts(vcount, 1, false);
            for (int i = 1; i < vcount; i++)
            {
                gridIndices[i] += gridIndices[i - 1];
            }

            return(CommonAlgorithm.restoreVertices(intVertices, gridIndices, grid, precision));
        }
Exemplo n.º 2
0
        public override void encode(Mesh m, CtmOutputStream output)
        {
            Grid grid = setupGrid(m.vertices);

            SortableVertex[] sorted  = sortVertices(grid, m.vertices);
            int[]            vdeltas = makeVertexDeltas(m.vertices, sorted, grid);

            int[] gridIndicies = new int[m.getVertexCount()];
            gridIndicies [0] = sorted [0].gridIndex;
            for (int i = 1; i < m.getVertexCount(); ++i)
            {
                gridIndicies [i] = sorted [i].gridIndex - sorted [i - 1].gridIndex;
            }

            output.writeLittleInt(MG2Decoder.MG2_HEADER_TAG);

            output.writeLittleFloat(vertexPrecision);
            output.writeLittleFloat(normalPrecision);

            grid.writeToStream(output);

            output.writeLittleInt(MeshDecoder.VERT);
            output.writePackedInts(vdeltas, m.getVertexCount(), Mesh.CTM_POSITION_ELEMENT_COUNT, false);

            output.writeLittleInt(MG2Decoder.GIDX);
            output.writePackedInts(gridIndicies, m.getVertexCount(), 1, false);

            output.writeLittleInt(MeshDecoder.INDX);
            int[] indices = reIndexIndices(sorted, m.indices);
            rearrangeTriangles(indices);

            //write indicies
            {
                int[] deltas = new int[indices.Length];
                Array.Copy(indices, deltas, indices.Length);
                makeIndexDeltas(deltas);
                output.writePackedInts(deltas, m.getTriangleCount(), 3, false);
            }

            if (m.hasNormals())
            {
                for (int i = 1; i < m.getVertexCount(); i++)
                {
                    gridIndicies [i] += gridIndicies [i - 1];
                }
                float[] restoredv = CommonAlgorithm.restoreVertices(vdeltas, gridIndicies, grid, vertexPrecision);

                output.writeLittleInt(MeshDecoder.NORM);
                int[] intNormals = makeNormalDeltas(restoredv, m.normals, indices, sorted);
                output.writePackedInts(intNormals, m.getVertexCount(), Mesh.CTM_NORMAL_ELEMENT_COUNT, false);
            }

            foreach (AttributeData ad in m.texcoordinates)
            {
                output.writeLittleInt(MeshDecoder.TEXC);
                output.writeString(ad.name);
                output.writeString(ad.materialName);
                output.writeLittleFloat(ad.precision);
                int[] deltas = makeUVCoordDeltas(ad, sorted);
                output.writePackedInts(deltas, m.getVertexCount(), Mesh.CTM_UV_ELEMENT_COUNT, true);
            }

            foreach (AttributeData ad in m.attributs)
            {
                output.writeLittleInt(MeshDecoder.ATTR);
                output.writeString(ad.name);
                output.writeLittleFloat(ad.precision);
                int[] deltas = makeAttribDeltas(ad, sorted);
                output.writePackedInts(deltas, m.getVertexCount(), Mesh.CTM_ATTR_ELEMENT_COUNT, true);
            }
        }