예제 #1
0
        private static RawTargetContainer[] ContainRawTargets(MemoryStream diffsbuffer, MemoryStream mappingbuffer, uint[] numVertexDiffsInEachChunk, uint[] numVertexDiffsMappingInEachChunk, uint targetStartsInVertexDiffs, uint targetStartsInVertexDiffsMapping, Vec4 targetPositionDiffOffset, Vec4 targetPositionDiffScale, int subMeshC)
        {
            var rawtarget = new RawTargetContainer[subMeshC];

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

            for (var i = 0; i < subMeshC; i++)
            {
                var diffsCount   = numVertexDiffsInEachChunk[i];
                var vertexDelta  = new TargetVec3[diffsCount];
                var normalDelta  = new Vec3[diffsCount];
                var tangentDelta = new Vec3[diffsCount];

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

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

                for (var e = 0; e < diffsCount; e++)
                {
                    if (diffsbr.BaseStream.Position < (diffsbr.BaseStream.Length - 3))
                    {
                        var v = Converters.TenBitUnsigned(diffsbr.ReadUInt32());

                        var x = (v.X * targetPositionDiffScale.X) + targetPositionDiffOffset.X;
                        var y = (v.Y * targetPositionDiffScale.Y) + targetPositionDiffOffset.Y;
                        var z = (v.Z * targetPositionDiffScale.Z) + targetPositionDiffOffset.Z;

                        vertexDelta[e] = new TargetVec3(x, z, -y);
                        var n = Converters.TenBitShifted(diffsbr.ReadUInt32());
                        normalDelta[e] = new Vec3(n.X, n.Z, -n.Y);
                        var t = Converters.TenBitShifted(diffsbr.ReadUInt32());
                        tangentDelta[e] = new Vec3(t.X, t.Z, -t.Y);
                    }
                }

                var vertexMapping = new ushort[diffsCount];

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

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

                for (var e = 0; e < diffsCount; e++)
                {
                    if (mappingbr.BaseStream.Position < (mappingbr.BaseStream.Length - 1))
                    {
                        vertexMapping[e] = mappingbr.ReadUInt16();
                    }
                }

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

            return(rawtarget);
        }
예제 #2
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];
                TargetVec3[] vertexDelta  = new TargetVec3[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++)
                {
                    if (diffsbr.BaseStream.Position < (diffsbr.BaseStream.Length - 3))
                    {
                        TargetVec4 v = Converters.TenBitUnsigned(diffsbr.ReadUInt32());

                        var x = v.X * TargetPositionDiffScale.X + TargetPositionDiffOffset.X;
                        var y = v.Y * TargetPositionDiffScale.Y + TargetPositionDiffOffset.Y;
                        var z = v.Z * TargetPositionDiffScale.Z + TargetPositionDiffOffset.Z;

                        vertexDelta[e] = new TargetVec3(x, z, -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++)
                {
                    if (mappingbr.BaseStream.Position < (mappingbr.BaseStream.Length - 1))
                    {
                        vertexMapping[e] = mappingbr.ReadUInt16();
                    }
                }

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

            return(rawtarget);
        }