예제 #1
0
        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);
        }
예제 #2
0
        public static void Write(ResFileSwitchSaver saver, LightAnim lightAnim)
        {
            if (saver.ResFile.VersionMajor2 == 9)
            {
                saver.Write(lightAnim.Flags, true);
                saver.Seek(2);
            }
            else
            {
                saver.Seek(12);
            }

            saver.SaveRelocateEntryToSection(saver.Position, 8, 1, 0, ResFileSwitchSaver.Section1, "Light Animation");
            saver.SaveString(lightAnim.Name);
            lightAnim.PosCurveArrayOffset   = saver.SaveOffset();
            lightAnim.PosBaseDataOffset     = saver.SaveOffset();
            lightAnim.PosUserDataOffset     = saver.SaveOffset();
            lightAnim.PosUserDataDictOffset = saver.SaveOffset();
            saver.SaveString(lightAnim.LightTypeName);
            saver.SaveString(lightAnim.DistanceAttnFuncName);
            saver.SaveString(lightAnim.AngleAttnFuncName);
            if (saver.ResFile.VersionMajor2 == 9)
            {
                saver.Write(lightAnim.FrameCount);
                saver.Write((byte)lightAnim.Curves.Count);
                saver.Write(lightAnim.LightTypeIndex);
                saver.Write(lightAnim.DistanceAttnFuncIndex);
                saver.Write(lightAnim.AngleAttnFuncIndex);
                saver.Write(lightAnim.BakedSize);
                saver.Write((ushort)lightAnim.UserData.Count);
                saver.Seek(2);
            }
            else
            {
                saver.Write(lightAnim.Flags, true);
                saver.Write((ushort)lightAnim.UserData.Count);
                saver.Write(lightAnim.FrameCount);
                saver.Write((byte)lightAnim.Curves.Count);
                saver.Write(lightAnim.LightTypeIndex);
                saver.Write(lightAnim.DistanceAttnFuncIndex);
                saver.Write(lightAnim.AngleAttnFuncIndex);
                saver.Write(lightAnim.BakedSize);
            }
        }
예제 #3
0
 public void LoadAnim(LightAnim anim)
 {
     Initialize();
     Text = anim.Name;
 }
예제 #4
0
        public static void FromJson(SceneAnim anim, string json)
        {
            JsonConvert.DefaultSettings = () =>
            {
                var settings = new JsonSerializerSettings();
                return(settings);
            };

            var animJson = JsonConvert.DeserializeObject <SceneAnimStuct>(json);

            anim.Name        = animJson.Name;
            anim.CameraAnims = new ResDict <CameraAnim>();
            anim.LightAnims  = new ResDict <LightAnim>();
            anim.FogAnims    = new ResDict <FogAnim>();
            anim.UserData    = UserDataConvert.Convert(animJson.UserData);

            foreach (var camAnimJson in animJson.CameraAnims)
            {
                CameraAnim camAnim = new CameraAnim();
                camAnim.Flags = 0;

                anim.CameraAnims.Add(camAnimJson.Name, camAnim);

                if (camAnimJson.Loop)
                {
                    camAnim.Flags |= CameraAnimFlags.Looping;
                }
                if (camAnimJson.Baked)
                {
                    camAnim.Flags |= CameraAnimFlags.BakedCurve;
                }
                if (camAnimJson.Perspective)
                {
                    camAnim.Flags |= CameraAnimFlags.Perspective;
                }
                if (camAnimJson.EulerRotation)
                {
                    camAnim.Flags |= CameraAnimFlags.EulerZXY;
                }

                camAnim.Name       = camAnimJson.Name;
                camAnim.FrameCount = camAnimJson.FrameCount;
                camAnim.BaseData   = camAnimJson.BaseData;
                foreach (var curveJson in camAnimJson.Curves)
                {
                    var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);

                    var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
                    camAnim.Curves.Add(curve);
                }
            }
            foreach (var lightAnimJson in animJson.LightAnims)
            {
                LightAnim lightAnim = new LightAnim();
                lightAnim.Flags = 0;

                anim.LightAnims.Add(lightAnimJson.Name, lightAnim);

                if (lightAnimJson.Loop)
                {
                    lightAnim.Flags |= LightAnimFlags.Looping;
                }
                if (lightAnimJson.Baked)
                {
                    lightAnim.Flags |= LightAnimFlags.BakedCurve;
                }
                if (lightAnimJson.BaseAngleAttn)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseAngleAttn;
                }
                if (lightAnimJson.BaseColor0)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseColor0;
                }
                if (lightAnimJson.BaseColor1)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseColor1;
                }
                if (lightAnimJson.BaseDir)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseDir;
                }
                if (lightAnimJson.BaseDistAttn)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseDistAttn;
                }
                if (lightAnimJson.BasePos)
                {
                    lightAnim.Flags |= LightAnimFlags.BasePos;
                }

                lightAnim.Name       = lightAnimJson.Name;
                lightAnim.FrameCount = lightAnimJson.FrameCount;
                lightAnim.BaseData   = lightAnimJson.BaseData;

                if (lightAnim.BaseData.Enable == 1)
                {
                    lightAnim.Flags |= LightAnimFlags.BaseEnable;
                }

                foreach (var curveJson in lightAnimJson.Curves)
                {
                    var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);

                    var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
                    lightAnim.Curves.Add(curve);
                }
            }
            foreach (var fogAnimJson in animJson.FogAnims)
            {
                FogAnim fogAnim = new FogAnim();
                fogAnim.Flags = 0;

                anim.CameraAnims.Add(fogAnimJson.Name, fogAnim);

                if (fogAnimJson.Loop)
                {
                    fogAnim.Flags |= FogAnimFlags.Looping;
                }
                if (fogAnimJson.Baked)
                {
                    fogAnim.Flags |= FogAnimFlags.BakedCurve;
                }

                fogAnim.Name                  = fogAnimJson.Name;
                fogAnim.FrameCount            = fogAnimJson.FrameCount;
                fogAnim.DistanceAttnFuncIndex = fogAnimJson.DistanceAttnFuncIndex;
                fogAnim.DistanceAttnFuncName  = fogAnimJson.DistanceAttnFuncName;
                fogAnim.BaseData              = fogAnimJson.BaseData;

                foreach (var curveJson in fogAnimJson.Curves)
                {
                    var target = (CameraAnimDataOffset)Enum.Parse(typeof(CameraAnimDataOffset), curveJson.Target);

                    var curve = CurveAnimHelper.GenerateCurve(curveJson, (uint)target, false);
                    fogAnim.Curves.Add(curve);
                }
            }
        }