Ejemplo n.º 1
0
        /**
         * Commands are packed into CmdType + Params, but these are just
         * translated straight back into normal TRAnimCommands.
         */
        private void UnpackAnimCommands(PackedAnimation packedAnimation)
        {
            if (packedAnimation.Commands.Count == 0)
            {
                return;
            }

            List <TRAnimCommand> levelAnimCommands = Level.AnimCommands.ToList();

            packedAnimation.Animation.AnimCommand = (ushort)levelAnimCommands.Count;
            foreach (PackedAnimationCommand cmd in packedAnimation.Commands.Values)
            {
                levelAnimCommands.Add(new TRAnimCommand {
                    Value = (short)cmd.Command
                });
                foreach (short param in cmd.Params)
                {
                    levelAnimCommands.Add(new TRAnimCommand {
                        Value = param
                    });
                }
            }

            // Save back to the level
            Level.AnimCommands    = levelAnimCommands.ToArray();
            Level.NumAnimCommands = (uint)levelAnimCommands.Count;
        }
Ejemplo n.º 2
0
        private void PackAnimSounds(PackedAnimation packedAnimation)
        {
            foreach (PackedAnimationCommand cmd in packedAnimation.Commands.Values)
            {
                if (cmd.Command == TR2AnimCommand.PlaySound)
                {
                    int   soundMapIndex     = cmd.Params[1] & 0x3fff;
                    short soundDetailsIndex = Level.SoundMap[soundMapIndex];
                    packedAnimation.Sound.SoundMapIndices[soundMapIndex] = soundDetailsIndex;
                    if (soundDetailsIndex != -1)
                    {
                        TRSoundDetails soundDetails = Level.SoundDetails[soundDetailsIndex];
                        packedAnimation.Sound.SoundDetails[soundDetailsIndex] = soundDetails;

                        uint[] sampleIndices = new uint[soundDetails.NumSounds];
                        for (int i = 0; i < soundDetails.NumSounds; i++)
                        {
                            sampleIndices[i] = Level.SampleIndices[(ushort)(soundDetails.Sample + i)];
                        }

                        packedAnimation.Sound.SampleIndices[soundDetails.Sample] = sampleIndices;
                    }
                }
            }
        }
Ejemplo n.º 3
0
        private int UnpackAnimation(PackedAnimation animation)
        {
            List <TRAnimation> levelAnimations = Level.Animations.ToList();

            levelAnimations.Add(animation.Animation);
            Level.Animations = levelAnimations.ToArray();
            Level.NumAnimations++;

            return(levelAnimations.Count - 1);
        }
Ejemplo n.º 4
0
        public override void Import()
        {
            Dictionary <int, PackedAnimation> animations = Definition.Animations;
            bool firstAnimationConfigured  = false;
            Dictionary <int, int> indexMap = new Dictionary <int, int>();

            foreach (int oldAnimationIndex in animations.Keys)
            {
                PackedAnimation packedAnimation = animations[oldAnimationIndex];
                UnpackStateChanges(packedAnimation);
                UnpackAnimSounds(packedAnimation);
                UnpackAnimCommands(packedAnimation);

                int newAnimationIndex = UnpackAnimation(packedAnimation);
                indexMap[oldAnimationIndex] = newAnimationIndex;

                if (!firstAnimationConfigured)
                {
                    Definition.Model.Animation = (ushort)newAnimationIndex;
                    firstAnimationConfigured   = true;
                }
            }

            // Re-map the NextAnimations of each of the animation and dispatches
            // now we know the indices of each of the newly inserted animations.
            //List<short> missingAnimations = new List<short>();
            foreach (PackedAnimation packedAnimation in animations.Values)
            {
                packedAnimation.Animation.NextAnimation = (ushort)indexMap[packedAnimation.Animation.NextAnimation];
                foreach (TRAnimDispatch dispatch in packedAnimation.AnimationDispatches.Values)
                {
                    if (indexMap.ContainsKey(dispatch.NextAnimation))
                    {
                        dispatch.NextAnimation = (short)indexMap[dispatch.NextAnimation];
                    }
                    else
                    {
                        // I think this happens for such things as returning to a default stance e.g.
                        // after dismounting the Snowmobile, so it will be different in every level (e.g.
                        // Lara default animations).
                    }
                }
            }

            // Inserting SampleIndices will break the game unless they are sorted numerically
            // so handle this outwith the main animation insertion loop for ease.
            ResortSoundIndices();

            ImportAnimationFrames();
        }
Ejemplo n.º 5
0
        private void PackStateChanges(PackedAnimation packedAnimation, TRAnimation animation)
        {
            for (int stateChangeIndex = 0; stateChangeIndex < animation.NumStateChanges; stateChangeIndex++)
            {
                TRStateChange stateChange = Level.StateChanges[animation.StateChangeOffset + stateChangeIndex];
                packedAnimation.StateChanges.Add(stateChange);

                int dispatchOffset = stateChange.AnimDispatch;
                for (int i = 0; i < stateChange.NumAnimDispatches; i++, dispatchOffset++)
                {
                    if (!packedAnimation.AnimationDispatches.ContainsKey(dispatchOffset))
                    {
                        TRAnimDispatch dispatch = Level.AnimDispatches[dispatchOffset];
                        packedAnimation.AnimationDispatches[dispatchOffset] = dispatch;
                    }
                }
            }
        }
Ejemplo n.º 6
0
        private void UnpackStateChanges(PackedAnimation packedAnimation)
        {
            if (packedAnimation.Animation.NumStateChanges == 0)
            {
                if (packedAnimation.AnimationDispatches.Count != 0)
                {
                    throw new Exception();
                }
                return;
            }

            // Import the AnimDispatches first, noting their new indices
            List <TRAnimDispatch> animDispatches = Level.AnimDispatches.ToList();
            Dictionary <int, int> indexMap       = new Dictionary <int, int>();

            foreach (int oldDispatchIndex in packedAnimation.AnimationDispatches.Keys)
            {
                TRAnimDispatch dispatch = packedAnimation.AnimationDispatches[oldDispatchIndex];
                indexMap[oldDispatchIndex] = animDispatches.Count;
                animDispatches.Add(dispatch);
                // The dispatch's NextAnimation will need to be remapped, but this is handled in Import above
                // once all animations are in place.
            }

            // The animation's StateChangeOffset will be the current length of level StateChanges
            List <TRStateChange> stateChanges = Level.StateChanges.ToList();

            packedAnimation.Animation.StateChangeOffset = (ushort)stateChanges.Count;

            // Import Each state change, re-mapping AnimDispatch to new index
            foreach (TRStateChange stateChange in packedAnimation.StateChanges)
            {
                stateChange.AnimDispatch = (ushort)indexMap[stateChange.AnimDispatch];
                stateChanges.Add(stateChange);
            }

            // Save back to the level
            Level.AnimDispatches    = animDispatches.ToArray();
            Level.NumAnimDispatches = (uint)animDispatches.Count;

            Level.StateChanges    = stateChanges.ToArray();
            Level.NumStateChanges = (uint)stateChanges.Count;
        }
Ejemplo n.º 7
0
        /**
         * SampleIndices has to remain in numerical order, but rather than dealing with it after inserting
         * each new sample, ImportAnimations will handle reorganising the list and remapping SoundDetails
         * as necessary.
         */
        private void UnpackAnimSounds(PackedAnimation packedAnimation)
        {
            _soundUnpacker.Unpack(packedAnimation.Sound, Level, false);
            IReadOnlyDictionary <int, int> soundIndexMap = _soundUnpacker.SoundIndexMap;

            // Change the Params[1] value of each PlaySound AnimCommand to point to the
            // new index in SoundMap.
            foreach (PackedAnimationCommand cmd in packedAnimation.Commands.Values)
            {
                if (cmd.Command == TR2AnimCommand.PlaySound)
                {
                    int oldSoundMapIndex = cmd.Params[1] & 0x3fff;
                    int newSoundMapIndex = soundIndexMap[oldSoundMapIndex];

                    int param = cmd.Params[1] & ~oldSoundMapIndex;
                    param        |= newSoundMapIndex;
                    cmd.Params[1] = (short)param;
                }
            }
        }
Ejemplo n.º 8
0
        private void PackAnimCommands(PackedAnimation packedAnimation, TRAnimation animation)
        {
            int cmdOffset = animation.AnimCommand;

            for (int i = 0; i < animation.NumAnimCommands; i++)
            {
                int           cmdIndex = cmdOffset++;
                TRAnimCommand cmd      = Level.AnimCommands[cmdIndex];

                int paramCount;
                switch ((TR2AnimCommand)cmd.Value)
                {
                case TR2AnimCommand.SetPosition:
                    paramCount = 3;
                    break;

                case TR2AnimCommand.JumpDistance:
                case TR2AnimCommand.PlaySound:
                case TR2AnimCommand.FlipEffect:
                    paramCount = 2;
                    break;

                default:
                    paramCount = 0;
                    break;
                }

                short[] paramArr = new short[paramCount];
                for (int j = 0; j < paramCount; j++)
                {
                    paramArr[j] = Level.AnimCommands[cmdOffset++].Value;
                }

                packedAnimation.Commands[cmdIndex] = new PackedAnimationCommand
                {
                    Command = (TR2AnimCommand)cmd.Value,
                    Params  = paramArr
                };
            }
        }
Ejemplo n.º 9
0
        public override void Export()
        {
            Definition.Animations = new Dictionary <int, PackedAnimation>();

            int endAnimation = GetModelAnimationCount(Level, Definition.Model) + Definition.Model.Animation;

            for (int animationIndex = Definition.Model.Animation; animationIndex < endAnimation; animationIndex++)
            {
                TRAnimation     animation       = Level.Animations[animationIndex];
                PackedAnimation packedAnimation = new PackedAnimation
                {
                    Animation = animation,
                };
                Definition.Animations[animationIndex] = packedAnimation;

                PackStateChanges(packedAnimation, animation);
                PackAnimCommands(packedAnimation, animation);
                PackAnimSounds(packedAnimation);
            }

            ExportAnimationFrames();
        }