public static void Read(ResFileSwitchLoader loader, LightAnim lightAnim)
        {
            if (loader.ResFile.VersionMajor2 == 9)
            {
                lightAnim.Flags = loader.ReadEnum <LightAnimFlags>(true);
                loader.Seek(2);
            }
            else
            {
                loader.LoadHeaderBlock();
            }
            lightAnim.Name = loader.LoadString();
            long CurveArrayOffset = loader.ReadInt64();

            lightAnim.BaseData             = loader.LoadCustom(() => new LightAnimData(loader, lightAnim.AnimatedFields));
            lightAnim.UserData             = loader.LoadDictValues <UserData>();
            lightAnim.LightTypeName        = loader.LoadString();
            lightAnim.DistanceAttnFuncName = loader.LoadString();
            lightAnim.AngleAttnFuncName    = loader.LoadString();

            ushort numUserData = 0;
            byte   numCurve    = 0;

            if (loader.ResFile.VersionMajor2 == 9)
            {
                lightAnim.FrameCount            = loader.ReadInt32();
                numCurve                        = loader.ReadByte();
                lightAnim.LightTypeIndex        = loader.ReadSByte();
                lightAnim.DistanceAttnFuncIndex = loader.ReadSByte();
                lightAnim.AngleAttnFuncIndex    = loader.ReadSByte();
                lightAnim.BakedSize             = loader.ReadUInt32();
                numUserData                     = loader.ReadUInt16();
                loader.Seek(2);
            }
            else
            {
                lightAnim.Flags                 = loader.ReadEnum <LightAnimFlags>(true);
                numUserData                     = loader.ReadUInt16();
                lightAnim.FrameCount            = loader.ReadInt32();
                numCurve                        = loader.ReadByte();
                lightAnim.LightTypeIndex        = loader.ReadSByte();
                lightAnim.DistanceAttnFuncIndex = loader.ReadSByte();
                lightAnim.AngleAttnFuncIndex    = loader.ReadSByte();
                lightAnim.BakedSize             = loader.ReadUInt32();
            }
            lightAnim.Curves = loader.LoadList <AnimCurve>(numCurve);
        }
Exemple #2
0
        public static void Read(ResFileSwitchLoader loader, CameraAnim cameraAnim)
        {
            if (loader.ResFile.VersionMajor2 == 9)
            {
                cameraAnim.Flags = loader.ReadEnum <CameraAnimFlags>(true);
                loader.Seek(2);
            }
            else
            {
                loader.LoadHeaderBlock();
            }
            cameraAnim.Name = loader.LoadString();
            long CurveArrayOffset = loader.ReadInt64();

            cameraAnim.BaseData = loader.LoadCustom(() => new CameraAnimData(loader));
            cameraAnim.UserData = loader.LoadDictValues <UserData>();

            byte numCurve = 0;

            if (loader.ResFile.VersionMajor2 == 9)
            {
                cameraAnim.FrameCount = loader.ReadInt32();
                cameraAnim.BakedSize  = loader.ReadUInt32();
                ushort numUserData = loader.ReadUInt16();
                numCurve = loader.ReadByte();
                loader.Seek(1);
                loader.Seek(4);
            }
            else
            {
                cameraAnim.Flags = loader.ReadEnum <CameraAnimFlags>(true);
                loader.Seek(2);
                cameraAnim.FrameCount = loader.ReadInt32();
                numCurve = loader.ReadByte();
                loader.Seek(1);
                ushort numUserData = loader.ReadUInt16();
                cameraAnim.BakedSize = loader.ReadUInt32();
            }

            cameraAnim.Curves = loader.LoadList <AnimCurve>(numCurve, (uint)CurveArrayOffset);
        }
Exemple #3
0
        public static void Read(ResFileSwitchLoader loader, Shape shape)
        {
            if (loader.ResFile.VersionMajor2 == 9)
            {
                shape.Flags = loader.ReadEnum <ShapeFlags>(true);
            }
            else
            {
                loader.LoadHeaderBlock();
            }

            shape.Name         = loader.LoadString();
            shape.VertexBuffer = loader.Load <VertexBuffer>();
            long MeshArrayOffset         = loader.ReadOffset();
            long SkinBoneIndexListOffset = loader.ReadOffset();

            shape.KeyShapes = loader.LoadDictValues <KeyShape>();
            long BoundingBoxArrayOffset = loader.ReadOffset();
            long RadiusOffset           = 0;

            if (loader.ResFile.VersionMajor2 > 2 || loader.ResFile.VersionMajor > 0)
            {
                RadiusOffset = loader.ReadOffset();
                long UserPointer = loader.ReadInt64();
            }
            else
            {
                long UserPointer = loader.ReadInt64();
                shape.RadiusArray.Add(loader.ReadSingle());
            }
            if (loader.ResFile.VersionMajor2 != 9)
            {
                shape.Flags = loader.ReadEnum <ShapeFlags>(true);
            }
            ushort idx = loader.ReadUInt16();

            shape.MaterialIndex     = loader.ReadUInt16();
            shape.BoneIndex         = loader.ReadUInt16();
            shape.VertexBufferIndex = loader.ReadUInt16();
            ushort numSkinBoneIndex = loader.ReadUInt16();

            shape.VertexSkinCount = loader.ReadByte();
            byte numMesh       = loader.ReadByte();
            byte numKeys       = loader.ReadByte();
            byte numTargetAttr = loader.ReadByte();

            if (loader.ResFile.VersionMajor2 <= 2 && loader.ResFile.VersionMajor == 0)
            {
                loader.Seek(2); //padding
            }
            else if (loader.ResFile.VersionMajor2 == 9)
            {
                loader.Seek(2); //padding
            }
            else
            {
                loader.Seek(6); //padding
            }
            shape.Meshes          = numMesh == 0 ? new List <Mesh>() : loader.LoadList <Mesh>(numMesh, (uint)MeshArrayOffset).ToList();
            shape.SkinBoneIndices = numSkinBoneIndex == 0 ? new List <ushort>() : loader.LoadCustom(() => loader.ReadUInt16s(numSkinBoneIndex), (uint)SkinBoneIndexListOffset)?.ToList();

            if (RadiusOffset != 0)
            {
                shape.RadiusArray = numMesh == 0 ? new List <float>() : loader.LoadCustom(() => loader.ReadSingles(numMesh), (uint)RadiusOffset).ToList();
            }

            int boundingboxCount = shape.Meshes.Sum(x => x.SubMeshes.Count + 1);

            shape.SubMeshBoundings = boundingboxCount == 0 ? new List <Bounding>() : loader.LoadCustom(() =>
                                                                                                       loader.ReadBoundings(boundingboxCount), (uint)BoundingBoxArrayOffset)?.ToList();

            shape.SubMeshBoundingNodes = new List <BoundingNode>();
        }
Exemple #4
0
        public static void Load(ResFileSwitchLoader loader, Material mat)
        {
            if (loader.ResFile.VersionMajor2 == 9)
            {
                mat.Flags = loader.ReadEnum <MaterialFlags>(true);
            }
            else
            {
                loader.LoadHeaderBlock();
            }

            mat.Name         = loader.LoadString();
            mat.RenderInfos  = loader.LoadDictValues <RenderInfo>();
            mat.ShaderAssign = loader.Load <ShaderAssign>();
            long TextureArrayOffset = loader.ReadInt64();
            long TextureNameArray   = loader.ReadInt64();
            long SamplerArrayOffset = loader.ReadInt64();

            mat.Samplers     = loader.LoadDictValues <Sampler>();
            mat.ShaderParams = loader.LoadDictValues <ShaderParam>();
            long SourceParamOffset = loader.ReadInt64();

            mat.UserData = loader.LoadDictValues <UserData>();
            long VolatileFlagsOffset    = loader.ReadInt64();
            long userPointer            = loader.ReadInt64();
            long SamplerSlotArrayOffset = loader.ReadInt64();
            long TexSlotArrayOffset     = loader.ReadInt64();

            if (loader.ResFile.VersionMajor2 != 9)
            {
                mat.Flags = loader.ReadEnum <MaterialFlags>(true);
            }
            ushort idx                    = loader.ReadUInt16();
            ushort numRenderInfo          = loader.ReadUInt16();
            byte   numTextureRef          = loader.ReadByte();
            byte   numSampler             = loader.ReadByte();
            ushort numShaderParam         = loader.ReadUInt16();
            ushort numShaderParamVolatile = loader.ReadUInt16();
            ushort sizParamSource         = loader.ReadUInt16();
            ushort sizParamRaw            = loader.ReadUInt16();
            ushort numUserData            = loader.ReadUInt16();

            if (loader.ResFile.VersionMajor2 != 9)
            {
                loader.ReadUInt32(); //Padding
            }
            var textures = loader.LoadCustom(() => loader.LoadStrings(numTextureRef), (uint)TextureNameArray);

            mat.TextureRefs = new List <TextureRef>();
            if (textures != null)
            {
                foreach (var tex in textures)
                {
                    mat.TextureRefs.Add(new TextureRef()
                    {
                        Name = tex
                    });
                }
            }

            //Add names to the value as switch does not store any
            foreach (var sampler in mat.Samplers)
            {
                sampler.Value.Name = sampler.Key;
            }

            mat.ShaderParamData = loader.LoadCustom(() => loader.ReadBytes(sizParamSource), (uint)SourceParamOffset);

            mat.VolatileFlags    = loader.LoadCustom(() => loader.ReadBytes((int)Math.Ceiling(numShaderParam / 8f)), (uint)VolatileFlagsOffset);
            mat.TextureSlotArray = loader.LoadCustom(() => loader.ReadInt64s(numTextureRef), (uint)SamplerSlotArrayOffset);
            mat.SamplerSlotArray = loader.LoadCustom(() => loader.ReadInt64s(numSampler), (uint)TexSlotArrayOffset);
        }