GoGo-Robot » xna

XNA Skinned Model Animations

Rew — Mon, 30 May 2011 15:36:33 +0000

The Skinned Model sample from the App Hub education catalogue is great for getting animated characters into your game, but there’s a bit of a flaw with the export process. The problem is, when you export your character from 3DS Max (and possibly other modelling programs), all you get is one animation, named ‘Take 001′. Wouldn’t it be nice if we could define different animations for different parts of the animation timeline? Well, we’re going to do just that . As an added bonus, we’ll also be adding in events, so you can be notified when certain parts of your animation are hit.

This tutorial is based on the Skinned Model sample, so grab it from the App Hub if you want to follow along, or skip to the end if you want the final version (which is released under the same license as the original).

What we’ll be doing is creating an XML file to go with our exported model, which will define our animation clips and events. The animations defined in this file will replace animations defined in the source model file. So, first thing is to define the class that will be represented by the XML file. Create a class in the SkinnedModelPipeline project named AnimationDefinition, like so:

using System;
using System.Collections.Generic;
using System.Text;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Content.Pipeline;
using Microsoft.Xna.Framework.Content.Pipeline.Serialization;
using Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate;
 
namespace SkinnedModelPipeline
{
    /// 
    /// A class for storing our animation definitions
    /// 
    public class AnimationDefinition
    {
        /// 
        /// The original clip name that was exported by the modelling package
        /// Usually this will be Take 001
        /// 
        public string OriginalClipName
        {
            get;
            set;
        }
 
        /// 
        /// The number of frames in the original animation
        /// 
        public int OriginalFrameCount
        {
            get;
            set;
        }
 
        /// 
        /// A class for storing information about individual clips that we want to create
        /// 
        public class ClipPart
        {
            /// 
            /// The name we have given the clip
            /// 
            public string ClipName
            {
                get;
                set;
            }
 
            /// 
            /// The starting frame of the clip
            /// 
            public int StartFrame
            {
                get;
                set;
            }
 
            /// 
            /// The ending frame of the clip
            /// 
            public int EndFrame
            {
                get;
                set;
            }
 
            /// 
            /// A class for defining events in an animation
            /// 
            public class Event
            {
                /// 
                /// The name of the event
                /// 
                public string Name
                {
                    get;
                    set;
                }
 
                /// 
                /// The frame that the event fires on
                /// 
                public int Keyframe
                {
                    get;
                    set;
                }
            };
 
            /// 
            /// Our list of events in this animation clip
            /// Animation clips do not require events, so this is marked as optional
            /// 
            [Microsoft.Xna.Framework.Content.ContentSerializer(Optional = true)]
            public List<Event> Events
            {
                get;
                set;
            }
        };
 
        /// 
        /// The list of clip parts that we are breaking the original clip into
        /// 
        public List<ClipPart> ClipParts
        {
            get;
            set;
        }
    }
}

Next, we’ll need to modify the runtime project to add information about our events to the animations. Create a class in the SkinnedModelWindows project named AnimationEvent, with this in it:

#region Using Statements
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
#endregion
 
namespace SkinnedModel
{
    /// 
    /// Information about an event in our animation
    /// 
    public class AnimationEvent
    {
        /// 
        /// The name of the event
        /// 
        public String EventName
        {
            get;
            set;
        }
 
        /// 
        /// The time of the event
        /// 
        public TimeSpan EventTime
        {
            get;
            set;
        }
    }
}

Now, we need to add our events store to the animation clip, as well as the clip name. So open up AnimationClip.cs, and add this to the end of the class:

	/// 
        /// Callback events for the animation clips
        /// 
        [ContentSerializer]
        public List<AnimationEvent> Events { get; private set; }
 
	/// 
        /// The name of the clip
        /// 
        [ContentSerializer]
        public string Name { get; private set; }

We also need to modify the constructor so that we can pass in the list of animation events when we create the clip. Our new constructor looks like this:

	/// 
        /// Constructs a new animation clip object.
        /// 
        public AnimationClip(TimeSpan duration, List<Keyframe> keyframes, List<AnimationEvent> events, string name)
        {
            Duration = duration;
            Keyframes = keyframes;
            Events = events;
            Name = name;
        }

Almost there. We need to modify the SkinnedModelProcessor class so that it reads in our XML files describing our animations and stores them in the model file that it generates, replacing the original animation (the Take 001). So, in SkinnedModelProcessor.cs, in the ProcessAnimations function, we need to first check if an animation definition file exists that we will use to override the ones in the model. By having this check, it means that we don’t need to create an animation definition for every skinned model, just the ones that we want custom animations on. You’ll also need to modify the ProcessAnimations function to take two extra parameters, which are the ContentProcessorContext and ContentIdentity. We use these to get information about the current file we are processing, so we can look for an animation definition with the same name. The below code is the updated ProcessAnimations function:

        /// 
        /// Converts an intermediate format content pipeline AnimationContentDictionary
        /// object to our runtime AnimationClip format.
        /// 
        static Dictionary<string, AnimationClip> ProcessAnimations(
            AnimationContentDictionary animations, IList<BoneContent> bones,
            ContentProcessorContext context, ContentIdentity sourceIdentity)
        {
            // Build up a table mapping bone names to indices.
            Dictionary<string, int> boneMap = new Dictionary<string, int>();
 
            for (int i = 0; i < bones.Count; i++)
            {
                string boneName = bones[i].Name;
 
                if (!string.IsNullOrEmpty(boneName))
                    boneMap.Add(boneName, i);
            }
 
            // Convert each animation in turn.
            Dictionary<string, AnimationClip> animationClips;
            animationClips = new Dictionary<string, AnimationClip>();
 
            // We process the original animation first, so we can use their keyframes
            foreach (KeyValuePair<string, AnimationContent> animation in animations)
            {
                AnimationClip processed = ProcessAnimation(animation.Value, boneMap, animation.Key);
 
                animationClips.Add(animation.Key, processed);
            }
 
            // Check to see if there's an animation clip definition
            // Here, we're checking for a file with the _Anims suffix.
            // So, if your model is named dude.fbx, we'd add dude_Anims.xml in the same folder
            // and the pipeline will see the file and use it to override the animations in the
            // original model file.
            string SourceModelFile = sourceIdentity.SourceFilename;
            string SourcePath = Path.GetDirectoryName(SourceModelFile);
            string AnimFilename = Path.GetFileNameWithoutExtension(SourceModelFile);
            AnimFilename += "_Anims.xml";
            string AnimPath = Path.Combine(SourcePath, AnimFilename);
            if (File.Exists(AnimPath))
            {
                // Add the filename as a dependency, so if it changes, the model is rebuilt
                context.AddDependency(AnimPath);
 
                // Load the animation definition from the XML file
                AnimationDefinition AnimDef = context.BuildAndLoadAsset<XmlImporter, AnimationDefinition>(new ExternalReference<XmlImporter>(AnimPath), null);
 
                // Break up the original animation clips into our new clips
                // First, we check if the clips contains our clip to break up
                if (animationClips.ContainsKey(AnimDef.OriginalClipName))
                {
                    // Grab the main clip that we are using
                    AnimationClip MainClip = animationClips[AnimDef.OriginalClipName];
 
                    // Now remove the original clip from our animations
                    animationClips.Remove(AnimDef.OriginalClipName);
 
                    // Process each of our new animation clip parts
                    foreach (AnimationDefinition.ClipPart Part in AnimDef.ClipParts)
                    {
                        // Calculate the frame times
                        TimeSpan StartTime = GetTimeSpanForFrame(Part.StartFrame, AnimDef.OriginalFrameCount, MainClip.Duration.Ticks);
                        TimeSpan EndTime = GetTimeSpanForFrame(Part.EndFrame, AnimDef.OriginalFrameCount, MainClip.Duration.Ticks);
 
                        // Get all the keyframes for the animation clip
                        // that fall within the start and end time
                        List<Keyframe> Keyframes = new List<Keyframe>();
                        foreach (Keyframe AnimFrame in MainClip.Keyframes)
                        {
                            if ((AnimFrame.Time >= StartTime) && (AnimFrame.Time <= EndTime))
                            {
                                Keyframe NewFrame = new Keyframe(AnimFrame.Bone, AnimFrame.Time - StartTime, AnimFrame.Transform);
                                Keyframes.Add(NewFrame);
                            }
                        }
 
                        // Process the events
                        List<AnimationEvent> Events = new List<AnimationEvent>();
                        if (Part.Events != null)
                        {
                            // Process each event
                            foreach (AnimationDefinition.ClipPart.Event Event in Part.Events)
                            {
                                // Get the event time within the animation
                                TimeSpan EventTime = GetTimeSpanForFrame(Event.Keyframe, AnimDef.OriginalFrameCount, MainClip.Duration.Ticks);
 
                                // Offset the event time so it is relative to the start of the animation
                                EventTime -= StartTime;
 
                                // Create the event
                                AnimationEvent NewEvent = new AnimationEvent();
                                NewEvent.EventTime = EventTime;
                                NewEvent.EventName = Event.Name;
                                Events.Add(NewEvent);
                            }
                        }
 
                        // Create the clip
                        AnimationClip NewClip = new AnimationClip(EndTime - StartTime, Keyframes, Events, Part.ClipName);
                        animationClips[Part.ClipName] = NewClip;
                    }
                }
            }
 
            if (animationClips.Count == 0)
            {
                throw new InvalidContentException(
                            "Input file does not contain any animations.");
            }
 
            return animationClips;
        }
 
        /// 
        /// Gets a TimeSpan value for a frame index in an animation
        /// 
        private static TimeSpan GetTimeSpanForFrame(int FrameIndex, int TotalFrameCount, long TotalTicks)
        {
            float MaxFrameIndex = (float)TotalFrameCount - 1;
            float AmountOfAnimation = (float)FrameIndex / MaxFrameIndex;
            float NumTicks = AmountOfAnimation * (float)TotalTicks;
            return new TimeSpan((long)NumTicks);
        }

What we do is process the original animations, so that all the keyframe data is there, then we check for an animation definition file and, if it exists, use it to replace the animation clips from the original model. We also need to modify ProcessAnimation to handle the new AnimationClip constructor:

        /// 
        /// Converts an intermediate format content pipeline AnimationContent
        /// object to our runtime AnimationClip format.
        /// 
        static AnimationClip ProcessAnimation(AnimationContent animation,
                                              Dictionary<string, int> boneMap,
                                              string clipName)
        {
            List<Keyframe> keyframes = new List<Keyframe>();
 
            // For each input animation channel.
            foreach (KeyValuePair<string, AnimationChannel> channel in
                animation.Channels)
            {
                // Look up what bone this channel is controlling.
                int boneIndex;
 
                if (!boneMap.TryGetValue(channel.Key, out boneIndex))
                {
                    throw new InvalidContentException(string.Format(
                        "Found animation for bone '{0}', " +
                        "which is not part of the skeleton.", channel.Key));
                }
 
                // Convert the keyframe data.
                foreach (AnimationKeyframe keyframe in channel.Value)
                {
                    keyframes.Add(new Keyframe(boneIndex, keyframe.Time,
                                               keyframe.Transform));
                }
            }
 
            // Sort the merged keyframes by time.
            keyframes.Sort(CompareKeyframeTimes);
 
            if (keyframes.Count == 0)
                throw new InvalidContentException("Animation has no keyframes.");
 
            if (animation.Duration <= TimeSpan.Zero)
                throw new InvalidContentException("Animation has a zero duration.");
 
            return new AnimationClip(animation.Duration, keyframes, new List<AnimationEvent>(), clipName);
        }

OK, so now we can override animations in the models using our XML file. Before I show you an example file, there’s one last thing to do, which is to add in the event callback system into the runtime. So, we need to add in a place to register our event callbacks into the AnimationPlayer class. At the end of the ‘Fields’ region, we need to add:

	// The delegate template for the event callbacks
        public delegate void EventCallback(string Event);
 
        // The reigstered events
        Dictionary<string, Dictionary<string, EventCallback>> registeredEvents = new Dictionary<string, Dictionary<string, EventCallback>>();
        public Dictionary<string, Dictionary<string, EventCallback>> RegisteredEvents
        {
            get { return registeredEvents; }
        }

And initialise the registeredEvents dictionary in the constructor:

	// Construct the event dictionaries for each clip
        foreach (string clipName in skinningData.AnimationClips.Keys)
        {
            registeredEvents[clipName] = new Dictionary<string, EventCallback>();
        }

Now we can add events, so the last thing to do is to add the code that calls them, then we’ll be done. In the UpdateBoneTransforms function in AnimationPlayer, we need to modify it like so:

        /// 
        /// Helper used by the Update method to refresh the BoneTransforms data.
        /// 
        public void UpdateBoneTransforms(TimeSpan time, bool relativeToCurrentTime)
        {
            if (currentClipValue == null)
                throw new InvalidOperationException(
                            "AnimationPlayer.Update was called before StartClip");
 
            // Store the previous time
            TimeSpan lastTime = time;
 
            // Update the animation position.
            if (relativeToCurrentTime)
            {
                lastTime = currentTimeValue;
                time += currentTimeValue;
 
                // Check for events
                CheckEvents(ref time, ref lastTime);
 
                // If we reached the end, loop back to the start.
                bool hasLooped = false;
                while (time >= currentClipValue.Duration)
                {
                    hasLooped = true;
                    time -= currentClipValue.Duration;
                }
 
                // If we've looped, reprocess the events
                if (hasLooped)
                {
                    CheckEvents(ref time, ref lastTime);
                }
            }
 
            if ((time < TimeSpan.Zero) || (time >= currentClipValue.Duration))
                throw new ArgumentOutOfRangeException("time");
 
            // If the position moved backwards, reset the keyframe index.
            bool HasResetKeyframe = false;
            if (time < currentTimeValue)
            {
                HasResetKeyframe = true;
                currentKeyframe = 0;
                skinningDataValue.BindPose.CopyTo(boneTransforms, 0);
            }
 
            currentTimeValue = time;
 
            // Read keyframe matrices.
            IList<Keyframe> keyframes = currentClipValue.Keyframes;
 
            while (currentKeyframe < keyframes.Count)
            {
                Keyframe keyframe = keyframes[currentKeyframe];
 
                // Stop when we've read up to the current time position.
                if ((keyframe.Time > currentTimeValue) && (!HasResetKeyframe))
                    break;
 
                // Use this keyframe.
                boneTransforms[keyframe.Bone] = keyframe.Transform;
 
                currentKeyframe++;
 
                if(HasResetKeyframe)
                {
                    currentTimeValue = keyframe.Time;
                    HasResetKeyframe = false;
                }
            }
        }

And add the CheckEvents function:

        /// 
        /// Checks to see if any events have passed
        /// 
        private void CheckEvents(ref TimeSpan time, ref TimeSpan lastTime)
        {
            foreach (string eventName in registeredEvents[currentClipValue.Name].Keys)
            {
                // Find the event
                foreach (AnimationEvent animEvent in currentClipValue.Events)
                {
                    if (animEvent.EventName == eventName)
                    {
                        TimeSpan eventTime = animEvent.EventTime;
                        if ((lastTime < eventTime) && (time >= eventTime))
                        {
                            // Call the event
                            registeredEvents[currentClipValue.Name][eventName](eventName);
                        }
                    }
                }
            }
        }

So now we can define custom animations with events. Lets see it in action…

Add a new file to your content project, giving it the same name as the model, but with _Anims.xml. In our case, our model file is dude.fbx, so we want dude_Anims.xml. We don’t actually want the content pipeline to build this directly, so set the Build Action property to None, the Content Processor to No Processing Required, and Copy to Output Directory to Do not copy. Our XML looks like this:

 version="1.0" encoding="utf-8" ?>
>
 
   Type="SkinnedModelPipeline.AnimationDefinition">
 
    
    >Take 001>
 
    
    >100>
 
    
    >
 
      
      >
        >Idle>
        >0>
        >50>
      >
 
      >
        >Fire>
        >51>
        >99>
 
        
        >
          >
            >FireFrame>
            >70>
          >
        >
 
      >
 
    >
 
  >
 
>

Now we can play our new clips like normal. We can also add callbacks for events. For example, the FireFrame event, we add like this:

            // Create an animation player, and start decoding an animation clip.
            animationPlayer = new AnimationPlayer(skinningData);
 
            // Register an event
            animationPlayer.RegisteredEvents["Fire"].Add("FireFrame", new AnimationPlayer.EventCallback(OnFire));
 
            AnimationClip clip = skinningData.AnimationClips["Fire"];
 
            animationPlayer.StartClip(clip);

And our function just looks like this:

        private void OnFire(string EventName)
        {
            // Do something here like create a bullet
        }

So there you have it. You can download the updated sample here. You can use the ’1′ and ’2′ keys to switch between animation clips. The second one has a callback registered to it. One thing to note is that you’ll have to make sure you do a Rebuild Solution if you’re adding an animation XML to an existing model, because the content pipeline doesn’t know that the model depends on the animation definition until after it has built it once with the animation file there. Enjoy!

Texture Atlas (Sprite Sheet) Generator

Rew — Sat, 20 Mar 2010 16:47:50 +0000

A texture atlas, or sprite sheet, is a single image containing a number of smaller textures or sprites. This is useful as it is more efficient for the graphics card to process (it doesn’t have to keep switching textures when drawing different textures, as it can just use the single texture and sample from different parts of it). It is also faster to load into RAM, as you are only loading in one image, as opposed to several smaller ones, so the loading can be done in one stage.

It is useful to be able to quickly and easily generate texture atlases from a number of source sprites to speed up development. A useful tool when developing using the XNA framework is the SpriteSheet Sample available on the XNA Creators Club website. One downside of this, however, is that you must still manually generate the XML file list by hand, which can be a pain if you have a lot of textures to place on the sprite sheet. Another is that it is XNA only

Because we also do development on the iPhone, it was useful to have a similar generator for that platform, as well as for the XNA framework, so we created a tool to easily generate the texture atlases for us. The packing code is based on the SpriteSheet Sample code, though the tool is written in plain .NET, so does not require the XNA framework to be installed (though it does require the .NET framework). The tool can produce a PNG file with the combined textures, as well as an accompanying binary file, called a TXA file, with the information on each of the packed textures. It also supports removing transparent borders from textures to produce a more compact output. It can also optionally produce a C style header with enums in, so you don’t have to look up the textures by their names.

The help files for the texture atlas generator tool contain information on the format of the TXA files, so you can write your own loaders if you wish.

As well as the PNG + TXA combination, the tool can produce an XNA XML file (and optionally a C# file with enums in) which can be imported into your Content project to build the sprite sheet during compile time. You do need to include the XNA projects in yours to access the Content Processor and runtime types. The runtime library also includes extensions to the SpriteBatch class, to make it easier to draw using the textures.

Finally, there is a runtime library to load the texture atlas on an iPhone. The iPhone code uses the PVRTexture class from Apple’s sample code, so you can convert the PNG to a PVR if you wish using Apple’s texturetool (though this can be problematic as the textures may ‘bleed’ into each other). The iPhone runtime library also requires zlib and libpng

Each zip contains a Readme.txt file containing license information and other tips. You’re pretty much free to do what you want with these things, use them however you see fit (commercial or non-commercial), but remember they are provided as-is, and we accept no responsibility for anything We’ve tried to tidy them up to make them usable by other people, but if you’ve got any problems or questions, post in the comments and we’ll try and help. There may be bugs in these, so let us know if you find any!

Texture Atlas Generator
XNA Runtime and Pipeline Libraries
iPhone Runtime – Requires zlib and libpng

Windows Phone 7 Flashlight (With SOS)

Rew — Fri, 19 Mar 2010 12:02:16 +0000

I tried posting this as a comment in reply to this post, but the code got mangled, so I’m posting it here

            graphics.GraphicsDevice.Clear(
                /* Check for touch panel being pressed */
            TouchPanel.GetState().Count == 0 ?
                /* Touch panel released, so reset the timer. This is stored in the target elapsed time, so we don't have to create any variables :) We also turn off IsFixedTimeStep, so that TargetElapsedTime isn't used. */
                ((((this.IsFixedTimeStep = false) == false) && ((this.TargetElapsedTime = TimeSpan.FromMilliseconds(Math.Max(1.0f, gameTime.TotalGameTime.TotalMilliseconds))) == TimeSpan.Zero)) ? Color.Gray : Color.Gray) :
                /* Touch panel pressed, so do SOS */
                (gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 1 ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 2) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 3)) ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 4) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 5)) ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 7) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 9)) ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 10) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 12)) ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 13) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 15)) ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 17) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 18)) ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 19) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 20)) ? Color.White :
                (((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds >= 21) && ((gameTime.TotalGameTime - this.TargetElapsedTime).Seconds < 22)) ? Color.White :
                Color.Black);