Esempio n. 1
0
        // ---- METHODS ------------------------------------------------------------------------------------------------

        void IResData.Load(ResFileLoader loader)
        {
            ShaderArchiveName = loader.LoadString();
            ShadingModelName  = loader.LoadString();

            if (loader.IsSwitch)
            {
                AttribAssigns  = loader.LoadDictValues <ResString>();
                SamplerAssigns = loader.LoadDictValues <ResString>();
                ShaderOptions  = loader.LoadDictValues <ResString>();
                Revision       = loader.ReadUInt32();
                byte   numAttribAssign  = loader.ReadByte();
                byte   numSamplerAssign = loader.ReadByte();
                ushort numShaderOption  = loader.ReadUInt16();
            }
            else
            {
                Revision = loader.ReadUInt32();
                byte   numAttribAssign  = loader.ReadByte();
                byte   numSamplerAssign = loader.ReadByte();
                ushort numShaderOption  = loader.ReadUInt16();
                AttribAssigns  = loader.LoadDict <ResString>();
                SamplerAssigns = loader.LoadDict <ResString>();
                ShaderOptions  = loader.LoadDict <ResString>();
            }
        }
Esempio n. 2
0
        // ---- METHODS ------------------------------------------------------------------------------------------------

        void IResData.Load(ResFileLoader loader)
        {
            loader.CheckSignature(_signature);
            if (loader.IsSwitch)
            {
                if (loader.ResFile.VersionMajor2 == 9)
                {
                    _flags = loader.ReadUInt32();
                }
                else
                {
                    ((Switch.Core.ResFileSwitchLoader)loader).LoadHeaderBlock();
                }

                long BoneDictOffset  = loader.ReadOffset();
                long BoneArrayOffset = loader.ReadOffset();
                Bones = loader.LoadDictValues <Bone>(BoneDictOffset, BoneArrayOffset);

                uint MatrixToBoneListOffset     = loader.ReadOffset();
                uint InverseModelMatricesOffset = loader.ReadOffset();

                if (loader.ResFile.VersionMajor2 == 8)
                {
                    loader.Seek(16);
                }
                if (loader.ResFile.VersionMajor2 == 9)
                {
                    loader.Seek(8);
                }

                long userPointer = loader.ReadInt64();
                if (loader.ResFile.VersionMajor2 != 9)
                {
                    _flags = loader.ReadUInt32();
                }
                ushort numBone         = loader.ReadUInt16();
                ushort numSmoothMatrix = loader.ReadUInt16();
                ushort numRigidMatrix  = loader.ReadUInt16();
                loader.Seek(6);

                MatrixToBoneList     = loader.LoadCustom(() => loader.ReadUInt16s((numSmoothMatrix + numRigidMatrix)), MatrixToBoneListOffset);
                InverseModelMatrices = loader.LoadCustom(() => loader.ReadMatrix3x4s(numSmoothMatrix), InverseModelMatricesOffset)?.ToList();
            }
            else
            {
                _flags = loader.ReadUInt32();
                ushort numBone         = loader.ReadUInt16();
                ushort numSmoothMatrix = loader.ReadUInt16();
                ushort numRigidMatrix  = loader.ReadUInt16();
                loader.Seek(2);
                Bones = loader.LoadDict <Bone>();
                uint ofsBoneList = loader.ReadOffset(); // Only load dict.
                MatrixToBoneList = loader.LoadCustom(() => loader.ReadUInt16s((numSmoothMatrix + numRigidMatrix)));
                if (loader.ResFile.Version >= 0x03040000)
                {
                    InverseModelMatrices = loader.LoadCustom(() => loader.ReadMatrix3x4s(numSmoothMatrix))?.ToList();
                }
                uint userPointer = loader.ReadUInt32();
            }
        }
Esempio n. 3
0
        // ---- METHODS ------------------------------------------------------------------------------------------------

        void IResData.Load(ResFileLoader loader)
        {
            if (loader.IsSwitch)
            {
                Name     = loader.LoadString();
                UserData = loader.LoadDictValues <UserData>();
                if (loader.ResFile.VersionMajor2 == 8 || loader.ResFile.VersionMajor2 == 9)
                {
                    loader.Seek(16);
                }

                ushort idx = loader.ReadUInt16();
                ParentIndex       = loader.ReadInt16();
                SmoothMatrixIndex = loader.ReadInt16();
                RigidMatrixIndex  = loader.ReadInt16();
                BillboardIndex    = loader.ReadInt16();
                ushort numUserData = loader.ReadUInt16();
                _flags   = loader.ReadUInt32();
                Scale    = loader.ReadVector3F();
                Rotation = loader.ReadVector4F();
                Position = loader.ReadVector3F();
            }
            else
            {
                Name = loader.LoadString();
                ushort idx = loader.ReadUInt16();
                ParentIndex       = loader.ReadInt16();
                SmoothMatrixIndex = loader.ReadInt16();
                RigidMatrixIndex  = loader.ReadInt16();
                BillboardIndex    = loader.ReadInt16();
                ushort numUserData = loader.ReadUInt16();
                _flags   = loader.ReadUInt32();
                Scale    = loader.ReadVector3F();
                Rotation = loader.ReadVector4F();
                Position = loader.ReadVector3F();
                UserData = loader.LoadDict <UserData>();

                if (loader.ResFile.Version < 0x03040000)
                {
                    InverseMatrix = loader.ReadMatrix3x4();
                }
            }
        }
Esempio n. 4
0
        // ---- METHODS ------------------------------------------------------------------------------------------------

        void IResData.Load(ResFileLoader loader)
        {
            signature = loader.ReadString(4, Encoding.ASCII);
            uint   materialAnimOffset = 0;
            ushort materialCount      = 0;

            if (signature == "FMAA")
            {
                if (loader.ResFile.VersionMajor2 == 9)
                {
                    Flags = loader.ReadEnum <MaterialAnimFlags>(true);
                    loader.ReadUInt16();
                }
                else
                {
                    ((Switch.Core.ResFileSwitchLoader)loader).LoadHeaderBlock();
                }

                Name      = loader.LoadString();
                Path      = loader.LoadString();
                BindModel = loader.Load <Model>(true);
                uint BindIndicesOffset = loader.ReadOffset();
                materialAnimOffset = loader.ReadOffset();
                uint unk = loader.ReadOffset(); //Empty section. Maybe set at runtime
                uint TextureNameArrayOffset = loader.ReadOffset();
                UserData = loader.LoadDictValues <UserData>();
                uint TextureBindArrayOffset = loader.ReadOffset();

                if (loader.ResFile.VersionMajor2 != 9)
                {
                    Flags = loader.ReadEnum <MaterialAnimFlags>(true);
                }

                ushort numUserData = 0;
                ushort CurveCount  = 0;

                if (loader.ResFile.VersionMajor2 == 9)
                {
                    FrameCount    = loader.ReadInt32();
                    BakedSize     = loader.ReadUInt32();
                    numUserData   = loader.ReadUInt16();
                    materialCount = loader.ReadUInt16();
                    CurveCount    = loader.ReadUInt16();
                }
                else
                {
                    numUserData   = loader.ReadUInt16();
                    materialCount = loader.ReadUInt16();
                    CurveCount    = loader.ReadUInt16();
                    FrameCount    = loader.ReadInt32();
                    BakedSize     = loader.ReadUInt32();
                }

                ushort ShaderParamAnimCount    = loader.ReadUInt16();
                ushort TexturePatternAnimCount = loader.ReadUInt16();
                ushort VisabiltyAnimCount      = loader.ReadUInt16();
                ushort TextureCount            = loader.ReadUInt16();

                if (loader.ResFile.VersionMajor2 == 9)
                {
                    loader.ReadUInt16(); //padding
                }
                BindIndices = loader.LoadCustom(() => loader.ReadUInt16s(materialCount), BindIndicesOffset);
                var textureList = loader.LoadCustom(() => loader.LoadStrings(TextureCount), TextureNameArrayOffset);
                TextureBindArray = loader.LoadCustom(() => loader.ReadInt64s(TextureCount), TextureBindArrayOffset);

                if (textureList == null)
                {
                    textureList = new List <string>();
                }

                foreach (var tex in textureList)
                {
                    TextureNames.Add(tex, new TextureRef()
                    {
                        Name = tex
                    });
                }
            }
            else if (signature == "FSHU")
            {
                if (loader.ResFile.Version >= 0x02040000)
                {
                    Name  = loader.LoadString();
                    Path  = loader.LoadString();
                    Flags = (MaterialAnimFlags)loader.ReadUInt32();

                    if (loader.ResFile.Version >= 0x03040000)
                    {
                        FrameCount    = loader.ReadInt32();
                        materialCount = loader.ReadUInt16();
                        ushort numUserData  = loader.ReadUInt16();
                        int    numParamAnim = loader.ReadInt32();
                        int    numCurve     = loader.ReadInt32();
                        BakedSize = loader.ReadUInt32();
                    }
                    else
                    {
                        FrameCount    = loader.ReadUInt16();
                        materialCount = loader.ReadUInt16();
                        UnknownValue  = loader.ReadUInt32();
                        int numCurve = loader.ReadInt32();
                        BakedSize = loader.ReadUInt32();
                        int padding2 = loader.ReadInt32();
                    }
                    BindModel          = loader.Load <Model>();
                    BindIndices        = loader.LoadCustom(() => loader.ReadUInt16s(materialCount));
                    materialAnimOffset = loader.ReadOffset();
                    UserData           = loader.LoadDict <UserData>();
                }
                else
                {
                    Flags         = (MaterialAnimFlags)loader.ReadUInt32();
                    FrameCount    = loader.ReadInt16();
                    materialCount = loader.ReadUInt16();
                    ushort numUserData = loader.ReadUInt16();
                    ushort unk         = loader.ReadUInt16();
                    BakedSize          = loader.ReadUInt32();
                    Name               = loader.LoadString();
                    Path               = loader.LoadString();
                    BindModel          = loader.Load <Model>();
                    BindIndices        = loader.LoadCustom(() => loader.ReadUInt16s(materialCount));
                    materialAnimOffset = loader.ReadOffset();
                }
            }
            else if (signature == "FTXP")
            {
                Name  = loader.LoadString();
                Path  = loader.LoadString();
                Flags = loader.ReadEnum <MaterialAnimFlags>(true);
                ushort numTextureRef = 0;
                if (loader.ResFile.Version >= 0x03040000)
                {
                    ushort numUserData = loader.ReadUInt16();
                    FrameCount    = loader.ReadInt32();
                    numTextureRef = loader.ReadUInt16();
                    materialCount = loader.ReadUInt16();
                    int numPatAnim = loader.ReadInt32();
                    int numCurve   = loader.ReadInt32();
                    BakedSize = loader.ReadUInt32();
                }
                else
                {
                    FrameCount    = loader.ReadUInt16();
                    numTextureRef = loader.ReadUInt16();
                    materialCount = loader.ReadUInt16();
                    ushort numUserData = loader.ReadUInt16();
                    int    numPatAnim  = loader.ReadInt16();
                    int    numCurve    = loader.ReadInt32();
                    BakedSize = loader.ReadUInt32();
                    loader.Seek(4); //padding
                }


                BindModel          = loader.Load <Model>();
                BindIndices        = loader.LoadCustom(() => loader.ReadUInt16s(materialCount));
                materialAnimOffset = loader.ReadOffset();
                if (loader.ResFile.Version >= 0x03040000)
                {
                    TextureNames = loader.LoadDict <TextureRef>();
                }
                else
                {
                    int TextureCount = 0;
                    foreach (var patternAnim in MaterialAnimDataList)
                    {
                        foreach (var curve in patternAnim.Curves)
                        {
                            List <uint> frames = new List <uint>();
                            foreach (float key in curve.Keys)
                            {
                                frames.Add((uint)key);
                            }
                            TextureCount = (short)frames.Max();
                        }
                    }
                    var TextureRefNames = loader.LoadList <TextureRef>(numTextureRef);
                    foreach (var texRef in TextureRefNames)
                    {
                        TextureNames.Add(texRef.Name, texRef);
                    }
                }
                UserData = loader.LoadDict <UserData>();
            }

            //Load materials and parse based on the signature of the section
            MaterialAnimDataList = loader.LoadCustom(() =>
            {
                List <MaterialAnimData> materialAnims = new List <MaterialAnimData>();
                for (int i = 0; i < materialCount; i++)
                {
                    materialAnims.Add(new MaterialAnimData(loader, signature));
                }
                return(materialAnims);
            }, materialAnimOffset);
        }
Esempio n. 5
0
        // ---- METHODS ------------------------------------------------------------------------------------------------

        void IResData.Load(ResFileLoader loader)
        {
            loader.CheckSignature(_signature);
            if (loader.IsSwitch)
            {
                if (loader.ResFile.VersionMajor2 == 9)
                {
                    _flags = loader.ReadUInt32();
                }
                else
                {
                    ((Switch.Core.ResFileSwitchLoader)loader).LoadHeaderBlock();
                }

                Name         = loader.LoadString();
                Path         = loader.LoadString();
                BindSkeleton = loader.Load <Skeleton>();
                uint BindIndexArray      = loader.ReadOffset();
                uint BoneAnimArrayOffset = loader.ReadOffset();
                UserData = loader.LoadDictValues <UserData>();
                if (loader.ResFile.VersionMajor2 != 9)
                {
                    _flags = loader.ReadUInt32();
                }

                FrameCount = loader.ReadInt32();
                int numCurve = loader.ReadInt32();
                BakedSize = loader.ReadUInt32();
                ushort numBoneAnim = loader.ReadUInt16();
                ushort numUserData = loader.ReadUInt16();

                if (loader.ResFile.VersionMajor2 != 9)
                {
                    loader.ReadUInt32(); //Padding
                }
                BoneAnims   = loader.LoadList <BoneAnim>(numBoneAnim, BoneAnimArrayOffset).ToList();
                BindIndices = loader.LoadCustom(() => loader.ReadUInt16s(numBoneAnim), BindIndexArray);
            }
            else
            {
                ushort numBoneAnim = 0;
                if (loader.ResFile.Version >= 0x02040000)
                {
                    Name   = loader.LoadString();
                    Path   = loader.LoadString();
                    _flags = loader.ReadUInt32();

                    if (loader.ResFile.Version >= 0x03040000)
                    {
                        FrameCount  = loader.ReadInt32();
                        numBoneAnim = loader.ReadUInt16();
                        ushort numUserData = loader.ReadUInt16();
                        int    numCurve    = loader.ReadInt32();
                        BakedSize = loader.ReadUInt32();
                    }
                    else
                    {
                        FrameCount  = loader.ReadUInt16();
                        numBoneAnim = loader.ReadUInt16();
                        ushort numUserData = loader.ReadUInt16();
                        ushort numCurve    = loader.ReadUInt16();
                        BakedSize = loader.ReadUInt32();
                        loader.Seek(4); //padding
                    }

                    BoneAnims    = loader.LoadList <BoneAnim>(numBoneAnim).ToList();
                    BindSkeleton = loader.Load <Skeleton>();
                    BindIndices  = loader.LoadCustom(() => loader.ReadUInt16s(numBoneAnim));
                    UserData     = loader.LoadDict <UserData>();
                }
                else
                {
                    _flags      = loader.ReadUInt32();
                    FrameCount  = loader.ReadUInt16();
                    numBoneAnim = loader.ReadUInt16();
                    ushort numUserData = loader.ReadUInt16();
                    ushort numCurve    = loader.ReadUInt16();
                    Name         = loader.LoadString();
                    Path         = loader.LoadString();
                    BoneAnims    = loader.LoadList <BoneAnim>(numBoneAnim).ToList();
                    BindSkeleton = loader.Load <Skeleton>();
                    BindIndices  = loader.LoadCustom(() => loader.ReadUInt16s(numBoneAnim));
                }
            }
        }