I present – lessons learned the hard way in game programming:

Do not write your own physics for games.

Use http://farseerphysics.codeplex.com/ for 2D and http://physxdotnet.codeplex.com/ for 3D physics. Do not write you’re own just because you need a simple physics engine in your game – even if you do have the neccessary knowledge. It’s too big to finish in a reasonable time and there are far better engines out there.

Learn to use some paint software and a 3d modelling package

You will need art for your game. Lots and lots of art if you’re making anything bigger than puzzle games. Learn how to use Photoshop, Gimp or whatever to create basic game 2D game art. Also learn a 3D modelling package like Maya or Blender because – if you can handle the math – you will want to do something in 3 dimensions. Also learn Mudbox or some other free sculpting package if you don’t want to totally devote to 3D with learning how to uv map / texture. Also to touch UV mapping: Do not UV map a model manually using plane, sphere, … projections. Use something called LSCM mapping. Blender has it by default and most packages have a plugin that handles that (Maya has RoadKill)

Learn about view and projection transforms and object, view, world coordinate systems

Not knowing how to handle transformations between different coordinate systems turns out to be quite a bummer when trying to do anything a bit more complex with graphics. You need to know the maths so you can do a whole lot of cool stuff like shadow mapping and camera effects… Start with Vector math, and go on with Matrix math and View, Projection, Transformation matrices. It’s really practical math, ready-to-use math, not something abstract with a lot of theory behind.

Well, that’s it for now. What did you learn the hard way in game programming?

I’m doing a spaceship shooter game, and I encountered a situation where the only solution was to write a custom xml file next to every one of my models. So I started a content pipeline extension project and began twiddling. I inherited the ModelProcessor to load info from my custom xml file, and I saw a OpaqueData dictionary in the NodeContents so I decided to google it.

With some help from http://blogs.msdn.com/b/etayrien/archive/2007/03/22/opaque-data-from-max-and-maya.aspx I got exactly what I wanted without the xml info file – getting extra information from Maya to XNA.

As the link says, soo

• 1. Add a custom attribute to a mesh in Maya
• 2. Read it in the OpaqueData
• 3. ???
• 4. Profit!

Simple as that! What you actually want to do in step 3 is pass on that extra information in a Model.Tag, or Mesh.Tag from the content pipeline to your game.

As you can see none of them still textured, and I probably won’t be spending much time texturing any of them as I feel so helpless doing that. I’m really not an artistic guy (I couldn’t draw a bicycle on a piece of paper), as I ventured into 3D for my own personal needs , and I feel that texturing non-organics is my limit.

So yeah, now I’m stuck with a couple of untextured spaceship models so I decided to do a little 3D top-down space arcade / roguelike kinda action RPG where the textures won’t stand out as totally bad. And I said I’d finish it by the end of summer. We’ll see…

In other news:

• XNA 4.0 Beta – If you got the CTP version installed you have to uninstall it, but do uninstall the whole product (not piece by piece) as you’re quickly going to find a lot of problems if you try uninstalling piece by piece. I fixed my problems using the MSI Cleanup Utility.
• Goblin Camp v001 is out. You can call it a Dwarf Fortress killer, I call it cool. Anyhow it’s anonuncing the next generation of ascii graphics city builders. If you’re so confused right now, check http://www.goblincamp.com/ and Dwarf fortress. Only for hardcore people who play hardcore games.

I think the only way you need a better random number generator than the .NET Random is when your game is totally relying on random numbers. Games like Roguelikes or Diablo style hack n slash with lots of item drops and random dungeon generation probably use their own random number generator because the built in ones often give a pattern over a large number of samples. In fact I don’t know that much about random numbers, so just read Shawn’s article.

 
1. First a bit of back info. What’s our goal? To make some connected vertices that can be controlled by a number of joints. Each vertex has a List of values indicating how much a certain bone is affecting it. This is done by a technique called smooth skin binding. First make some geometry. It doesn’t matter if the geometry is a single big mesh or a number of smaller meshes. In the end they’re all vertices. I’ll be working with a very simple object and a very simple animation – a door which can open and close. Next is the joint placing. Next is skin binding. This connects the geometry to the joints, and is the backbone of this whole process. After that is weight painting – assigning values to vertices depending on how much do you want a bone to influence that single vertex. Next is animating or keyframing. Essentially remembering the posing of  bones at various times in our timeline. This is directly linked to the animations refresh rate. zAnimation requires special timeline format, but we’ll get to that. And the last step will be exporting, making sure that our data reaches XNA. Have fun!

 

2. I’ll show you how to properly animate a model for export to XNA via zAnimation. Load up your model in Maya. I’m using Maya 2010, but an older version should work. I’m using a model with only 2 joints but models with more joints will work correctly as well.
    
   

 

3. In case you have a skin already attached and weights painted, skip this step. Select your root joint and your geometry and go to Skin > Bind Skin > Smooth Bind (with options). Also make sure you’re in the animation mode. Setup your skin here including max influences, bind method and other options. When you’re done select your geometry and go to Skin > Edit Smooth Skin > Paint Skin Weights Tool (with options). Paint your bone weights here. Don’t miss a bone, because if a bone doesn’t have skin weights attached to at least a single vertice it will be ignored during the import into XNA, and all its children will be lost and you’ll get an error probably. So these are my weights.
    
   

 

4. Try moving a joint now, see if your geometry is moving as expected. If that’s alright we can begin keyframing. Select all your joints by clicking on the root joint, right clicking and selecting “Select Hierarchy”. We have to key each joint on the first and the second frame in their original positions. This is called a bind pose, a reference to all future joint transformations. Place the timeline marker to the first frame, go to your “Channel Box” (shown in the image), select all the translation, rotation and scale values, right click and select “Key selected”. To this again but with the timeline marker on the second frame, and again at the fourth frame. In the third frame move all your joints a bit and keyframe them. You can skip this last step if you have a bigger animation moving ALL your joints. If a joint isn’t moved in the animation it will be ignored by the XNA FBX importer, and will probably generate an error. After this you can continue with your animation clips as desired (from frame 5 onward). I’ll make a simple open and close animations. Be aware that the default refresh rate is 60 frames per second and zAnimation will import animation at that frame rate, so time your animations properly.
    
   

 

5. Bake your animation. Select all your joints by clicking the root joint and selecting “Select Hierarchy”, go to Edit > Keys > Bake Simulation (with options). Keep the default settings except start/end time and select “Driven channels” and remove “Keep unbaked keys”. Be sure to bake the entire animation timeline. This step is required because zAnimation doesn’t interpolate the joint transformations between the keyframes. Yet. Press Bake. After this is done, position your timeline marker at frame 1 and select you geometry. From there select Skin > Go to Bind Pose, and you’re ready for export.

 

6. Export your geometry and joints by selecting all of them (the entire joint hierarchy) and selecting File > Export Selection. After picking the file name and path you’ll be greeted by the FBX export dialog. Be sure you have the newest Maya FBX exporter (I have FBX201000). The important things for zAnimation are “Animation”, “Deformed models” and “Skins”. You should select them all. Click Export, and you’re done!

 
This has been a fast rundown of how to export a model from Maya to XNA using zAnimation. In the next post I’ll be explaining how to create a new XNA game with zAnimation and playing an animation. Regarding IK handles, they don’t get exported so be sure to bake the animation to your joints. You don’t have to delete them they won’t interfere. Please post feedback if you encountered problems or if you just have something to say!

It’s all very basic for now, no samples or documentation yet. The code is somewhat documented. I believe experienced people will have no problem using it. It’s just a matter of selecting the right content processor, checking out my past blog entry to write a definitions file, and writing model.Play(“Walk”); I won’t be working on the documentation or samples the next 2 weeks, my exams are still more important.

Pre-clip interpolation:

Before a clip is played, the model interpolates over a customizable number of frames to the starting position. It delays an animation a bit but removes jerky transitions between animations.

Per-bone animation:

When defining a clip within the animation, you also define what bones does the clip affect. Based on that you can play an animation that animates all the bones in a model, and easily override the animation on one or more bones to make them move in a different way.

Below I’m listing a couple of things that I encountered while writing zAnimation:

Maya gets all your animation keyframes and exports it in a single take called “Take 001″.

To deal with this I introduced another file (the take definition file) which contains where does a certain animation start and end, and also what bones does it affect.

XNA FBX Importer removes redundant bones.

If a bone has no weights defined on a skin it gets deleted. The same thing happens if the bone doesn’t move (change) in the keyframes. So I introduced 2 special parts of the animation, the “Bind” part and the “Init” part. The bind part acts like a starting transform, and the init part is just there so you don’t forget that you have to animate a bone if you want to have it.

So based on that there are a few rules and limitations to zAnimation:

- smooth binding only

- each bone in each skin has to have some weights, so no root bones with no weights (or it won’t be imported as a bone)

- each bone has to have at least 2 keyframes that are not the same (or it won’t show up in the keyframes at all)

- strictly defined animation timeline:

-at frames 0 and 1 keyframe every bone at its bind pose position. This is the position your animation starts with.

-at frame 3 you should keyframe every bone it any position other than its bind pose. I select all my bones and rotate them in the x-axis about 45 deg.

-at frame 4 you should keyframe your bind pose again.

- after frame 4 animate your model as you wish

- when importing a model create a takes.def file in the same directory as your exported fbx is in the XNA content folders, set its build action to none from Visual Studio

- takes.def file has a specific structure that is line delimited, so the first line should look like this:

Bind, 0, 2, AffectedBone0, AffectedBone1, AffectedBone2

and each line after that should look like this:

AnimationName, StartFrame, EndFrame, AffectedBone0, AffectedBone1, AffectedBone2

here’s an example of a takes file

Bind, 0, 2, root, door
Open, 4, 34, door
Opened, 34, 36, door
Close, 36, 66, door

That’s more or less it. I’ll release it on codeplex in a couple of days. Check it out if you’re a XNA developer working with Maya.

Aaron Stebner’s WebLog
http://blogs.msdn.com/astebner/rss.xml

Another Early Morning
http://www.anotherearlymorning.com/feed/

Beautiful Pixels
http://feeds.feedburner.com/BeautifulPixels

Blender3d.org: Latest News
http://www.blender.org/feed/

Brian Goldfarb’s Blog
http://blogs.msdn.com/bgold/rss.xml

C0DE517E
http://c0de517e.blogspot.com/feeds/posts/default

Catalin’s XNA Experiments
http://www.catalinzima.com/?feed=rss2

Coding Efficiency
http://www.codingefficiency.com/feed/

Cooking With Code
http://blogs.msdn.com/ashtat/rss.xml

Cornflower Blue
http://blogs.msdn.com/etayrien/rss.xml

Danc’s shared items
http://www.google.com/reader/public/atom/user/04653747362202207327/state/com.google/broadcast

Diary of a Graphics Programmer
http://diaryofagraphicsprogrammer.blogspot.com/feeds/posts/default

Gamasutra Feature Articles
http://feeds.feedburner.com/GamasutraFeatureArticles/

GameDev.Net
http://www.gamedev.net/xml/

GameDevBlog
http://www.gamedevblog.com/atom.xml

Graphics Runner
http://graphicsrunner.blogspot.com/feeds/posts/default

Jesse Liberty – Silverlight Geek
http://feeds.feedburner.com/JesseLiberty-SilverlightGeek

Krishna’s XNA Space
http://cid-cdfded0a2593c8e1.users.api.live.net/Users(-3603463498990630687)/Main?$format=rss20

Legalize Adulthood!
http://legalizeadulthood.wordpress.com/feed/

Let’s Kill Dave!
http://feeds.feedburner.com/LetsKillDave

level of detail
http://www.jshopf.com/blog/?feed=rss2

Lost Garden
http://lostgarden.com/atom.xml

Machaira’s Space
http://cid-c6a0309746469d9e.users.api.live.net/Users(-4134251031648887394)/Main?$format=rss20

Method ~ of ~ failed by Tim Heuer
http://feeds.timheuer.com/timheuer

Michael Klucher’s Blog
http://klucher.com/feed/

Nazeeh’s Little Corner on the Web
http://feeds.feedburner.com/nazspace/kFwA

Nerd Herding – The Care and Feeding of Software Developers …
http://blog.calevans.com/feed/

Nick Gravelyn
http://nickgravelyn.com/feed/

Ozymandias
http://ozymandias.com/feed/

Pandemonium
http://bittermanandy.wordpress.com/feed/

Petri’s space
http://cid-2b7007e9ec2ae37b.users.api.live.net/Users(3130010442293502843)/Main?$format=rss20

Pieter Germishuys
http://www.pieterg.com/blog/syndication.axd?format=rss

RandomChaos
http://xna-uk.net/blogs/randomchaos/rss.aspx

Real-Time Rendering
http://www.realtimerendering.com/blog/feed/

Sharky’s Blog
http://sharky.bluecog.co.nz/?feed=rss2

Shawn Burke’s Blog
http://blogs.msdn.com/sburke/rss.xml

Shawn Hargreaves Blog
http://blogs.msdn.com/shawnhar/rss.xml

Shawn Oster
http://blog.enginefour.com/blog/syndication.axd?format=rss

Silverlight Releases Rss Feed
http://silverlight.codeplex.com/Project/ProjectRss.aspx?ProjectRSSFeed=codeplex%3A%2F%2Frelease%2FSilverlight

Ska Studios
http://skasoftware.wordpress.com/feed/

The Daily WTF: Curious Perversions in Information Technology
http://syndication.thedailywtf.com/TheDailyWtf

The Game Dev Guy
http://gamedevguy.com/blog/?feed=rss2

Virtual Realm
http://feedproxy.google.com/mykre

www.enchantedage.com
http://www.enchantedage.com/rss.xml

xkcd.com
http://xkcd.com/rss.xml

XNA Creators Club – News List
http://public.xna.com/Feeds/CcoFeeds.svc/CmsFeed?group=News%20List&format=rss

XNA Team Blog
http://blogs.msdn.com/xna/rss.xml

XNAinspired
http://xnainspired.com/feed/

Ziggyware.com
http://www.ziggyware.com/news-rss.php

Ziggyware.com XNA Articles
http://www.ziggyware.com/articles.rss.php

OPML file on pastebin: http://pastebin.com/f6c8cc804

OPML file on megaupload: http://www.megaupload.com/?d=4IGSP2AX

GameOfLifeGPU is a simple project to implement Conway’s Game Of Life algorithm on a GPU. I’m using a 400×300 grid with edge wrapping, loading premade patterns from 400×300 content files and a simple mechanism for switching between those premade patterns. I’m also using a QuadDrawer class which you can find somewhere on Ziggyware.

GameOfLife.cs:

using System;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using System.IO;

namespace GameOfLifeGPU
{
 /// <summary>
 /// This is the main type for your game
 /// </summary>
 public class GameOfLife : Microsoft.Xna.Framework.Game
 {
 GraphicsDeviceManager graphics;
 SpriteBatch spriteBatch;
 private QuadRenderer quadDrawer;

 private int width = 400;
 private int height = 300;
 private RenderTarget2D gridRT;
 private Texture2D texture;

 private Effect clearEffect;
 private Effect updateEffect;

 private string currentTexture = "gliders";

 private KeyboardState keyState;
 private KeyboardState oldKeyState;

 public GameOfLife()
 {
 graphics = new GraphicsDeviceManager(this);
 Content.RootDirectory = "Content";

 quadDrawer = new QuadRenderer(this);
 Components.Add(quadDrawer);
 }

 /// <summary>
 /// Allows the game to perform any initialization it needs to before starting to run.
 /// This is where it can query for any required services and load any non-graphic
 /// related content.  Calling base.Initialize will enumerate through any components
 /// and initialize them as well.
 /// </summary>
 protected override void Initialize()
 {
 graphics.PreferredBackBufferWidth = 1024;
 graphics.PreferredBackBufferHeight = 786;
 graphics.PreferMultiSampling = false;
 graphics.ApplyChanges();

 IsFixedTimeStep = true;
 IsMouseVisible = true;
 TargetElapsedTime = new TimeSpan(0, 0, 0, 0, 10);

 base.Initialize();
 }

 /// <summary>
 /// LoadContent will be called once per game and is the place to load
 /// all of your content.
 /// </summary>
 protected override void LoadContent()
 {
 // Create a new SpriteBatch, which can be used to draw textures.
 spriteBatch = new SpriteBatch(GraphicsDevice);

 clearEffect = Content.Load<Effect>("Effects\\clear");
 updateEffect = Content.Load<Effect>("Effects\\update");
 gridRT = new RenderTarget2D(GraphicsDevice, width, height, 1, SurfaceFormat.Color);

 texture = Content.Load<Texture2D>("glider");
 }

 /// <summary>
 /// UnloadContent will be called once per game and is the place to unload
 /// all content.
 /// </summary>
 protected override void UnloadContent()
 {
 }

 /// <summary>
 /// Allows the game to run logic such as updating the world,
 /// checking for collisions, gathering input, and playing audio.
 /// </summary>
 /// <param name="gameTime">Provides a snapshot of timing values.</param>
 protected override void Update(GameTime gameTime)
 {
 oldKeyState = keyState;
 keyState = Keyboard.GetState();
 if (keyState.IsKeyDown(Keys.Space) && !oldKeyState.IsKeyDown(Keys.Space))
 {
 string[] textures = Directory.GetFiles(Content.RootDirectory);
 for (int j = 0; j < textures.Length; j++)
 {
 textures[j] = Path.GetFileNameWithoutExtension(textures[j]);
 }

 int i = Array.IndexOf(textures, currentTexture);
 texture = Content.Load<Texture2D>(textures[(i + 1)%textures.Length]);
 currentTexture = textures[(i + 1)%textures.Length];
 Window.Title = "GameOfLife - " + currentTexture;
 }

 base.Update(gameTime);
 }

 /// <summary>
 /// This is called when the game should draw itself.
 /// </summary>
 /// <param name="gameTime">Provides a snapshot of timing values.</param>
 protected override void Draw(GameTime gameTime)
 {
 GraphicsDevice.SetRenderTarget(0, gridRT);
 updateEffect.Begin();
 updateEffect.Parameters["Texture"].SetValue(texture);
 updateEffect.Parameters["GridSize"].SetValue(new Vector2(width, height));
 updateEffect.CurrentTechnique.Passes[0].Begin();
 quadDrawer.RenderFullscreen();
 updateEffect.CurrentTechnique.Passes[0].End();
 updateEffect.End();

 GraphicsDevice.SetRenderTarget(0, null);
 texture = gridRT.GetTexture();
 GraphicsDevice.Clear(Color.Black);
 spriteBatch.Begin();
 spriteBatch.Draw(texture,
 new Rectangle(0, 0, GraphicsDevice.PresentationParameters.BackBufferWidth, GraphicsDevice.PresentationParameters.BackBufferHeight),
 Color.White);
 spriteBatch.End();

 base.Draw(gameTime);
 }

 }
}

Just simple pattern switching code in the Update region and the draw mechanism in the Draw region.

Content\Effects\clear.fx:

struct VertexShaderInput
{
 float4 Position : POSITION0;
};

struct VertexShaderOutput
{
 float4 Position : POSITION0;
};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
 VertexShaderOutput output;
 output.Position = input.Position;

 return output;
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
 return float4(0, 0, 0, 1);
}

technique Technique1
{
 pass Pass1
 {
 VertexShader = compile vs_1_1 VertexShaderFunction();
 PixelShader = compile ps_1_1 PixelShaderFunction();
 }
}

Content\Effects\update.fx:

texture Texture;
sampler2D TextureSampler = sampler_state
{
 Texture = <Texture>;
 ADDRESSU = WRAP;
 ADDRESSV = WRAP;
 MAGFILTER = POINT;
 MINFILTER = POINT;
 MIPFILTER = POINT;
};

float2 GridSize;

struct VertexShaderInput
{
 float4 Position : POSITION0;
 float2 Texcoord : TEXCOORD0;
};

struct VertexShaderOutput
{
 float4 Position : POSITION0;
 float2 Texcoord : TEXCOORD0;
};

VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
 VertexShaderOutput output;

 output.Position = input.Position;
 output.Texcoord = input.Texcoord;

 return output;
}

float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
 float4 cell = float4(0, 0, 0, 1);
 float4 alive = float4(1, 1, 1, 1);
 float4 dead = float4(0, 0, 0, 1);

 float2 pixel = 1.0f / GridSize;

 float n = 0.0f;

 // count neighbours
 n += tex2D(TextureSampler, float2(input.Texcoord.x - pixel.x, input.Texcoord.y - pixel.y)).r;
 n += tex2D(TextureSampler, float2(input.Texcoord.x - pixel.x, input.Texcoord.y)).r;
 n += tex2D(TextureSampler, float2(input.Texcoord.x - pixel.x, input.Texcoord.y + pixel.y)).r;
 n += tex2D(TextureSampler, float2(input.Texcoord.x, input.Texcoord.y - pixel.y)).r;
 n += tex2D(TextureSampler, float2(input.Texcoord.x, input.Texcoord.y + pixel.y)).r;
 n += tex2D(TextureSampler, float2(input.Texcoord.x + pixel.x, input.Texcoord.y - pixel.y)).r;
 n += tex2D(TextureSampler, float2(input.Texcoord.x + pixel.x, input.Texcoord.y)).r;
 n += tex2D(TextureSampler, float2(input.Texcoord.x + pixel.x, input.Texcoord.y + pixel.y)).r;

 if (tex2D(TextureSampler, input.Texcoord).r == 1.0f)
 {
 if (n == 2.0f || n == 3.0f)
 cell = alive;
 else
 cell = dead;
 }
 else
 {
 if (n == 3.0f)
 cell = alive;
 else
 cell = dead;
 }

 return cell;
}

technique Technique1
{
 pass Pass1
 {
 // TODO: set renderstates here.

 VertexShader = compile vs_2_0 VertexShaderFunction();
 PixelShader = compile ps_2_0 PixelShaderFunction();
 }
}

The algorithm kicks in the update.fx. Space cycles the premade patterns and you can make your own patterns by inserting your own 400×300 images. Check out the premade patterns. Wrapping edges were so easy to do. Easy like writing ADDRESSU = WRAP;  ADDRESSV = WRAP;. In the CPU version they are a bit more complicated. So here you go. Simple and easy. Here’s the complete project in a zip file (73kb), which you can download from MU or RS:

http://www.megaupload.com/?d=PMV3OPJF

http://rapidshare.com/files/290162624/GameOfLifeGPU.zip

EDIT: I’ve corrected a typo in the LoadContent method. The starting texture name shouldn’t be “gliders”, but “glider”. Please correct this in your downloaded project file also.