Пример #1
0
        private static float[] ConvertToFloatArray(Constants.PicaDataType format, byte[] data, uint offset, float scale)
        {
            float[] dataOut = new float[2];

            switch (format)
            {
            case Constants.PicaDataType.Byte:
            case Constants.PicaDataType.UnsignedByte:
            {
                byte[] temp = new byte[(data.Length - offset) / sizeof(byte)];
                Buffer.BlockCopy(data, (int)offset, temp, 0, temp.Length * sizeof(byte));
                dataOut = new float[temp.Length];
                for (int i = 0; i < temp.Length; i++)
                {
                    dataOut[i] = Convert.ToSingle(temp[i]) * scale;
                }
            }
            break;

            case Constants.PicaDataType.Short:
            case Constants.PicaDataType.UnsignedShort:
            {
                short[] temp = new short[(data.Length - offset) / sizeof(short)];
                Buffer.BlockCopy(data, (int)offset, temp, 0, temp.Length * sizeof(short));
                dataOut = new float[temp.Length];
                for (int i = 0; i < temp.Length; i++)
                {
                    dataOut[i] = Convert.ToSingle(temp[i]) * scale;
                }
            }
            break;

            case Constants.PicaDataType.Float:
            {
                int texCoordDataLength = (int)(data.Length - offset);
                dataOut = new float[texCoordDataLength / sizeof(float)];
                Buffer.BlockCopy(data, (int)offset, dataOut, 0, texCoordDataLength);
                for (int i = 0; i < dataOut.Length; i++)
                {
                    dataOut[i] *= scale;
                }
            }
            break;
            }

            return(dataOut);
        }
Пример #2
0
        public SepdChunk(byte[] data, int offset, BaseCTRChunk parent)
            : base(data, offset, parent)
        {
            PrmsCount      = BitConverter.ToUInt16(ChunkData, 0x08);
            Unknown0A      = BitConverter.ToUInt16(ChunkData, 0x0A);
            UnknownFloat0C = BitConverter.ToSingle(ChunkData, 0x0C);
            UnknownFloat10 = BitConverter.ToSingle(ChunkData, 0x10);
            UnknownFloat14 = BitConverter.ToSingle(ChunkData, 0x14);
            Unknown18      = BitConverter.ToUInt32(ChunkData, 0x18);
            Unknown1C      = BitConverter.ToUInt32(ChunkData, 0x1C);
            Unknown20      = BitConverter.ToUInt32(ChunkData, 0x20);

            int arrayCount = (BaseCTRChunk.IsMajora3D ? 9 : 8);

            ArrayOffsets   = new uint[arrayCount];
            ArrayScales    = new float[arrayCount];
            ArrayDataTypes = new Constants.PicaDataType[arrayCount];
            ArrayUnknown1  = new ushort[arrayCount];
            ArrayUnknown2  = new uint[arrayCount];
            ArrayUnknown3  = new uint[arrayCount];
            ArrayUnknown4  = new uint[arrayCount];
            ArrayUnknown5  = new uint[arrayCount];

            for (int i = 0; i < arrayCount; i++)
            {
                ArrayOffsets[i]   = BitConverter.ToUInt32(ChunkData, 0x24 + (i * 0x1C));
                ArrayScales[i]    = BitConverter.ToSingle(ChunkData, 0x28 + (i * 0x1C));
                ArrayDataTypes[i] = (Constants.PicaDataType)BitConverter.ToUInt16(ChunkData, 0x2C + (i * 0x1C));
                ArrayUnknown1[i]  = BitConverter.ToUInt16(ChunkData, 0x2E + (i * 0x1C));
                ArrayUnknown2[i]  = BitConverter.ToUInt32(ChunkData, 0x30 + (i * 0x1C));
                ArrayUnknown3[i]  = BitConverter.ToUInt32(ChunkData, 0x34 + (i * 0x1C));
                ArrayUnknown4[i]  = BitConverter.ToUInt32(ChunkData, 0x38 + (i * 0x1C));
                ArrayUnknown5[i]  = BitConverter.ToUInt32(ChunkData, 0x3C + (i * 0x1C));
            }

            Unknown_104OoT_120MM = BitConverter.ToUInt32(ChunkData, !BaseCTRChunk.IsMajora3D ? 0x104 : 0x120);

            int prmsDataOffset = (!BaseCTRChunk.IsMajora3D ? 0x108 : 0x124);

            PrmsChunks = new PrmsChunk[PrmsCount];
            for (int i = 0; i < PrmsChunks.Length; i++)
            {
                PrmsChunks[i] = new PrmsChunk(ChunkData, (int)BitConverter.ToUInt16(ChunkData, prmsDataOffset + (i * 2)), this);
            }

            switch (NormalArrayDataType)
            {
            case Constants.PicaDataType.Byte:
            case Constants.PicaDataType.UnsignedByte:
                NormalPointerType = NormalPointerType.Byte;
                NormalSize        = (sizeof(byte) * 3);
                break;

            case Constants.PicaDataType.Short:
            case Constants.PicaDataType.UnsignedShort:
                NormalPointerType = NormalPointerType.Short;
                NormalSize        = (sizeof(ushort) * 3);
                break;

            case Constants.PicaDataType.Int:
            case Constants.PicaDataType.UnsignedInt:
                NormalPointerType = NormalPointerType.Int;
                NormalSize        = (sizeof(uint) * 3);
                break;

            case Constants.PicaDataType.Float:
                NormalPointerType = NormalPointerType.Float;
                NormalSize        = (sizeof(float) * 3);
                break;
            }

            switch (ColorArrayDataType)
            {
            case Constants.PicaDataType.Byte:
                ColorPointerType = ColorPointerType.Byte;
                ColorSize        = (sizeof(sbyte) * 4);
                break;

            case Constants.PicaDataType.UnsignedByte:
                ColorPointerType = ColorPointerType.UnsignedByte;
                ColorSize        = (sizeof(byte) * 4);
                break;

            case Constants.PicaDataType.Short:
                ColorPointerType = ColorPointerType.Short;
                ColorSize        = (sizeof(short) * 4);
                break;

            case Constants.PicaDataType.UnsignedShort:
                ColorPointerType = ColorPointerType.UnsignedShort;
                ColorSize        = (sizeof(ushort) * 4);
                break;

            case Constants.PicaDataType.Int:
                ColorPointerType = ColorPointerType.Int;
                ColorSize        = (sizeof(int) * 4);
                break;

            case Constants.PicaDataType.UnsignedInt:
                ColorPointerType = ColorPointerType.UnsignedInt;
                ColorSize        = (sizeof(uint) * 4);
                break;

            case Constants.PicaDataType.Float:
                ColorPointerType = ColorPointerType.Float;
                ColorSize        = (sizeof(float) * 4);
                break;
            }

            switch (TextureCoordArrayDataType)
            {
            case Constants.PicaDataType.Byte:
            case Constants.PicaDataType.UnsignedByte:
                /* Needs conversion to short during rendering! */
                TexCoordPointerType = TexCoordPointerType.Short;
                TexCoordSize        = (sizeof(byte) * 2);
                break;

            case Constants.PicaDataType.Short:
            case Constants.PicaDataType.UnsignedShort:
                TexCoordPointerType = TexCoordPointerType.Short;
                TexCoordSize        = (sizeof(ushort) * 2);
                break;

            case Constants.PicaDataType.Int:
            case Constants.PicaDataType.UnsignedInt:
                TexCoordPointerType = TexCoordPointerType.Int;
                TexCoordSize        = (sizeof(uint) * 2);
                break;

            case Constants.PicaDataType.Float:
                TexCoordPointerType = TexCoordPointerType.Float;
                TexCoordSize        = (sizeof(float) * 2);
                break;
            }

            switch (VertexArrayDataType)
            {
            case Constants.PicaDataType.Byte:
            case Constants.PicaDataType.UnsignedByte:
                /* Needs conversion to short during rendering! */
                VertexPointerType = VertexPointerType.Short;
                VertexSize        = (sizeof(byte) * 3);
                break;

            case Constants.PicaDataType.Short:
            case Constants.PicaDataType.UnsignedShort:
                VertexPointerType = VertexPointerType.Short;
                VertexSize        = (sizeof(ushort) * 3);
                break;

            case Constants.PicaDataType.Int:
            case Constants.PicaDataType.UnsignedInt:
                VertexPointerType = VertexPointerType.Int;
                VertexSize        = (sizeof(uint) * 3);
                break;

            case Constants.PicaDataType.Float:
                VertexPointerType = VertexPointerType.Float;
                VertexSize        = (sizeof(float) * 3);
                break;
            }

            switch (BoneIndexLookupArrayDataType)
            {
            case Constants.PicaDataType.Byte:
            case Constants.PicaDataType.UnsignedByte:
                BoneIndexLookupSize = sizeof(byte);
                break;

            case Constants.PicaDataType.Short:
            case Constants.PicaDataType.UnsignedShort:
                BoneIndexLookupSize = sizeof(ushort);
                break;

            case Constants.PicaDataType.Int:
            case Constants.PicaDataType.UnsignedInt:
                BoneIndexLookupSize = sizeof(uint);
                break;

            case Constants.PicaDataType.Float:
                BoneIndexLookupSize = sizeof(float);
                break;
            }

            /* For information purposes */
            TotalPrimitives = 0;
            foreach (PrmsChunk prms in PrmsChunks)
            {
                TotalPrimitives += (prms.PrmChunk.NumberOfIndices / 3);
            }
        }