There are still outstanding issues, but the previous release is already getting a beard and I'm getting reports for issues already solved

Amit Ginni Patpatia of FatCow Games AS fame reminds the community to vote for a character for an upcoming game.

Last but not least Barnaby Smith pokes me about an XNA 3.1 Morph Target implementation he put online: “This example uses multiple vertex streams and blends between them using a vertex shader. This approach is a differing method to CPU or VTF based implementations and does not require the calculation of vertex textures, making it quite simple and straightforward.”

Source code and more details can be found at his post.

"This is the third-and-a-half release of the KiloWatt Animation library. It is intended as a companion to the kW X-port 3ds Max X file exporter, to be used with Microsoft XNA Game Studio. This release is for version 3.0/3.1 for Windows and Xbox 360. Sorry, no Zune support "

He goes on to explain how this is different to the XNA Skinning sample on the creators website

The KiloWatt Animation Library is different from the XNA Skinning sample code in several ways, including:

• KiloWatt Animation stores animation keyframes as position, rotation and scale (for a total of 10 floats), instead of the full matrix used by the Animation Components.
• KiloWatt Animation removes unnecessary keyframes (down to a tolerance that you can specify), for a usually quite significant savings in file size.
• KiloWatt Animation does interpolation between animation keyframes using quaternions, which means that slow-motion and varispeed playback will still look smooth.
• KiloWatt Animation supports composition (blending) of animations to generate the final output pose for a given Model.
• KiloWatt Animation replaces the Effect used for your Model only when you tell it to.
• KiloWatt Animation does not make any specific demands of your geometry; you can (and should) use it to animate rigid objects such as windmills, catapults etc. in addition to skinned meshes.

sgMotion is an animation library (based on XNAnimation by Bruno Evangelista) and provides full integration with both the Sunburn Engine and the Sunburn Framework.

More at the source.

This article describes how to animate a 2D sprite sheet with XNA.

I have decided to break this article into seperate pages, starting with the basics, and then progressing towards making a simple animated sprite class.

This first part is a basic tutorial on how to make a simple animated sprite using a set of images. There are better ways to animate sprites, but this will get you the basics on how it is accomplished, so the code is simple, and not optimized.

First start off with creating a new XNA 3.1 project.

With this newly created project, we want to add the images that we want to animate.
Click here for the images to use. Add those to the project's content folder.

Next we want to add a few private variables to the Game1.cs file.

public class Game1 : Microsoft.Xna.Framework.Game
	{
		GraphicsDeviceManager graphics;
		SpriteBatch spriteBatch;

		private List scribbles;  // a list of the textures we are going to animate
		private Vector2 scribbleOrigin;  // the center of the sprite
		private Vector2 scribblePos; // where to draw the sprite
		private int frameCount;  // how many frames are there to animate
		private float timePerFrame; // how long to display each frame
		private float totalElapsed;  // how long has it elapsed.
		private int currentFrame;  // what frame are we on
		private int framesPerSec; // how many frames of animation do we want to show per second.
...

This will get all the variables to animate the textures to make a nice animated sprite. Next you want to load up the textures, and set the variables with their default values. You want to do that in LoadContent in Game1.cs.

		protected override void LoadContent()
		{
			// Create a new SpriteBatch, which can be used to draw textures.
			spriteBatch = new SpriteBatch(GraphicsDevice);

			// init the list
			scribbles = new List();
			// loop thru all the textures, and add them to the list
			for (int i = 1; i <= 10; i++)
			{
				if(i < 10)
					scribbles.Add(Content.Load("scribble0" + i));
				else
					scribbles.Add(Content.Load("scribble" + i));
			}
			// set the number of frames to the size of the List
			frameCount = scribbles.Count;
			// how many frames do we want to show a sec?  15 looked like a good number
			framesPerSec = 15;
			// compute how long it we should show each frame
			timePerFrame = (float) 1/framesPerSec;
			// we want to start from the first frame
			currentFrame = 0;
			// just started, so elapse is 0
			totalElapsed = 0;
			// get the middle of the first texture (each texture is teh same size, so we can use the first one only)
			scribbleOrigin = new Vector2(scribbles[0].Width / 2, scribbles[0].Height / 2);
			// get the center of the current display
			scribblePos = new Vector2(graphics.PreferredBackBufferWidth/2, graphics.PreferredBackBufferHeight/2);
		}

With all the variables setup and the textures loaded, lets get the logic in to start animating the sprite. To do this, we want to add the following code to the Update function in Game1.cs so it looks like the following:

		protected override void Update(GameTime gameTime)
		{
			// Allows the game to exit
			if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
				this.Exit();

			float elapsed = (float)gameTime.ElapsedGameTime.TotalSeconds;
			totalElapsed += elapsed;

			if (totalElapsed > timePerFrame)
			{
				currentFrame++;
				// we want to keep the current frame betwee 0 and frameCount -1
				currentFrame = currentFrame % frameCount;
				// reset the total elapsed time.
				totalElapsed -= timePerFrame;
			}

			base.Update(gameTime);
		}

We are almost done here. Only thing that is left is to draw the sprite. To do this, we want to add the following code to the Draw function in Game1.cs.

protected override void Draw(GameTime gameTime)
		{
			GraphicsDevice.Clear(Color.CornflowerBlue);

			spriteBatch.Begin(SpriteBlendMode.AlphaBlend, SpriteSortMode.Deferred,
							  SaveStateMode.SaveState);

			spriteBatch.Draw(scribbles[currentFrame], scribblePos, null, Color.White, 0,
				scribbleOrigin, 1.0f, SpriteEffects.None, 0.6f);

			spriteBatch.End();

			base.Draw(gameTime);
		}

Once you add that, compile the project and run it. You should see a big scribble animating on the center of your screen.

To download the full project for this part of the article with images and source code, click here.

Up on the next page, we will merge the images into a sprite sheet, and do the animation with just 1 texture!