示例#1
0
        public override Mesh decode(MeshInfo minfo, CtmInputStream input)
        {
            int vc = minfo.getVertexCount();

            checkTag(input.readLittleInt(), MG2_HEADER_TAG);
            float vertexPrecision = input.readLittleFloat();
            float normalPrecision = input.readLittleFloat();

            Grid grid = Grid.fromStream(input);
            if(!grid.checkIntegrity()) {
                throw new InvalidDataException("The vertex size grid is corrupt!");
            }

            float[] vertices = readVertices(input, grid, vc, vertexPrecision);

            int[] indices = readIndices(input, minfo.getTriangleCount(), vc);

            float[] normals = null;
            if (minfo.hasNormals()) {
                normals = readNormals(input, vertices, indices, normalPrecision, vc);
            }

            AttributeData[] uvData = new AttributeData[minfo.getUvMapCount()];
            for (int i = 0; i < uvData.Length; i++) {
                uvData[i] = readUvData(input, vc);
            }

            AttributeData[] attributs = new AttributeData[minfo.getAttrCount()];
            for (int i = 0; i < attributs.Length; i++) {
                attributs[i] = readAttribute(input, vc);
            }

            return new Mesh(vertices, normals, indices, uvData, attributs);
        }
示例#2
0
        public override Mesh decode(MeshInfo minfo, CtmInputStream input)
        {
            int vc = minfo.getVertexCount();

            AttributeData[] tex = new AttributeData[minfo.getUvMapCount()];
            AttributeData[] att = new AttributeData[minfo.getAttrCount()];

            checkTag(input.readLittleInt(), INDX);
            int[] indices = readIntArray(input, minfo.getTriangleCount(), 3, false);

            checkTag(input.readLittleInt(), VERT);
            float[] vertices = readFloatArray(input, vc * Mesh.CTM_POSITION_ELEMENT_COUNT, 1);

            float[] normals = null;
            if (minfo.hasNormals()) {
                checkTag(input.readLittleInt(), NORM);
                normals = readFloatArray(input, vc, Mesh.CTM_NORMAL_ELEMENT_COUNT);
            }

            for (int i = 0; i < tex.Length; ++i) {
                checkTag(input.readLittleInt(), TEXC);
                tex[i] = readUVData(vc, input);
            }

            for (int i = 0; i < att.Length; ++i) {
                checkTag(input.readLittleInt(), ATTR);
                att[i] = readAttrData(vc, input);
            }

            return new Mesh(vertices, normals, indices, tex, att);
        }
示例#3
0
        /**
         * Calculate various forms of derivatives in order to reduce data entropy.
         */
        private int[] makeUVCoordDeltas(AttributeData map, SortableVertex[] sortVertices)
        {
            // UV coordinate scaling factor
            float scale = 1.0f / map.precision;
            int vc = sortVertices.Length;
            int prevU = 0, prevV = 0;
            int[] intUVCoords = new int[vc * Mesh.CTM_UV_ELEMENT_COUNT];
            for (int i = 0; i < vc; ++i) {
                // Get old UV coordinate index (before vertex sorting)
                int oldIdx = sortVertices [i].originalIndex;

                // Convert to fixed point
                int u = (int)Math.Floor (scale * map.values [oldIdx * 2] + 0.5f);
                int v = (int)Math.Floor (scale * map.values [oldIdx * 2 + 1] + 0.5f);

                // Calculate delta and store it in the converted array. NOTE: Here we rely
                // on the fact that vertices are sorted, and usually close to each other,
                // which means that UV coordinates should also be close to each other...
                intUVCoords [i * 2] = u - prevU;
                intUVCoords [i * 2 + 1] = v - prevV;

                prevU = u;
                prevV = v;
            }
            return intUVCoords;
        }
示例#4
0
        /**
         * Calculate various forms of derivatives in order to reduce data entropy.
         */
        private int[] makeAttribDeltas(AttributeData map, SortableVertex[] sortVertices)
        {
            // Attribute scaling factor
            float scale = 1.0f / map.precision;

            int[] prev = new int[4];

            int vc = sortVertices.Length;
            int[] intAttribs = new int[vc * Mesh.CTM_ATTR_ELEMENT_COUNT];

            for (int i = 0; i < vc; ++i) {
                // Get old attribute index (before vertex sorting)
                int oldIdx = sortVertices [i].originalIndex;

                // Convert to fixed point, and calculate delta and store it in the converted
                // array. NOTE: Here we rely on the fact that vertices are sorted, and
                // usually close to each other, which means that attributes should also
                // be close to each other (and we assume that they somehow vary slowly with
                // the geometry)...

                for (int j = 0; j < 4; ++j) {
                    int value = (int)Math.Floor (scale * map.values [oldIdx * 4 + j] + 0.5f);
                    intAttribs [i * 4 + j] = value - prev [j];
                    prev [j] = value;
                }
            }
            return intAttribs;
        }
示例#5
0
        private void testAttributeArrays(AttributeData[] a, AttributeData[] b, int[] indexLUT)
        {
            if ((a == null || a.Length == 0) && (b == null || b.Length == 0))
                return;

            Assert.AreEqual (a.Length, b.Length);

            for (int i=0; i < a.Length; i++) {
                Assert.AreEqual (a [i].materialName, b [i].materialName);
                Assert.AreEqual (a [i].name, b [i].name);
                Assert.AreEqual (a [i].precision, b [i].precision);

                float[] orig = a [i].values;
                float[] read = b [i].values;

                Assert.AreEqual (orig.Length, read.Length);

                int count = orig.Length / indexLUT.Length;

                Assert.AreEqual (count * indexLUT.Length, orig.Length);

                for (int vi=0; vi < indexLUT.Length; vi++) {
                    int newIndex = indexLUT [vi];

                    for (int e = 0; e < count; e++) {
                        Assert.IsTrue (compare (orig [vi * count + e], read [newIndex * count + e], a [i].precision * 2),
                                       "Attributs not in precision");
                    }
                }

            }
        }