Пример #1
0
        static RawTargetContainer[] ContainRawTargets(MemoryStream diffsbuffer, MemoryStream mappingbuffer, UInt32[] NumVertexDiffsInEachChunk, UInt32[] NumVertexDiffsMappingInEachChunk, UInt32 TargetStartsInVertexDiffs, UInt32 TargetStartsInVertexDiffsMapping, Vec4 TargetPositionDiffOffset, Vec4 TargetPositionDiffScale, int SubMeshC)
        {
            RawTargetContainer[] rawtarget = new RawTargetContainer[SubMeshC];

            BinaryReader diffsbr   = new BinaryReader(diffsbuffer);
            BinaryReader mappingbr = new BinaryReader(mappingbuffer);

            for (int i = 0; i < SubMeshC; i++)
            {
                UInt32 diffsCount   = NumVertexDiffsInEachChunk[i];
                Vec3[] vertexDelta  = new Vec3[diffsCount];
                Vec3[] normalDelta  = new Vec3[diffsCount];
                Vec3[] tangentDelta = new Vec3[diffsCount];

                if (i == 0)
                {
                    diffsbuffer.Position = TargetStartsInVertexDiffs * 12;
                }
                else
                {
                    diffsbuffer.Position = TargetStartsInVertexDiffs * 12;

                    for (int eye = 0; eye < i; eye++)
                    {
                        diffsbuffer.Position += NumVertexDiffsInEachChunk[eye] * 12;
                    }
                }


                for (int e = 0; e < diffsCount; e++)
                {
                    Vec4 v = Converters.TenBitUnsigned(diffsbr.ReadUInt32());
                    vertexDelta[e] = new Vec3((v.X * TargetPositionDiffScale.X + TargetPositionDiffOffset.X), (v.Z * TargetPositionDiffScale.Z + TargetPositionDiffOffset.Z), -(v.Y * TargetPositionDiffScale.Y + TargetPositionDiffOffset.Y));
                    Vec4 n = Converters.TenBitShifted(diffsbr.ReadUInt32());
                    normalDelta[e] = new Vec3(n.X, n.Z, -n.Y);
                    Vec4 t = Converters.TenBitShifted(diffsbr.ReadUInt32());
                    tangentDelta[e] = new Vec3(t.X, t.Z, -t.Y);
                }

                UInt16[] vertexMapping = new UInt16[diffsCount];

                if (i == 0)
                {
                    mappingbuffer.Position = TargetStartsInVertexDiffsMapping * 4;
                }
                else
                {
                    mappingbuffer.Position = TargetStartsInVertexDiffsMapping * 4;

                    for (int eye = 0; eye < i; eye++)
                    {
                        mappingbuffer.Position += NumVertexDiffsMappingInEachChunk[eye] * 4;
                    }
                }

                for (int e = 0; e < diffsCount; e++)
                {
                    vertexMapping[e] = mappingbr.ReadUInt16();
                }

                rawtarget[i] = new RawTargetContainer()
                {
                    vertexDelta   = vertexDelta,
                    normalDelta   = normalDelta,
                    tangentDelta  = tangentDelta,
                    vertexMapping = vertexMapping,
                    diffsCount    = diffsCount
                };
            }

            return(rawtarget);
        }