In short, it has been almost a year since I’ve graduated Full Sail University and since then I have had a number of experiences that made me on numerous occasions question the validity of my life-choices. This stems from the idea of immediate sacrifice and delayed gratification towards a brighter and happier future. This for most is an accepted part of life and being successful. While ultimately we all strive for happiness and each time we sacrifice and give we hope it to be a means to an end. Of course as we grow older we slowly but surely realize the real cynical nature of human life.

I’ve asked myself on occasion; what makes me happy? Is it having a high paycheck? Is it the process of creating video games? Is it sitting at a bar? While I’ve questioned my motives, I always arrive at the same answer sooner or later. I realize that I simply wish to be challenged and learn. At the core that is what drives me! That is what motivates and inspires me. Still I’ve never been able to make the jump to a full time Indie, or a commit towards academia.

In the near future I hope to reevaluate why I have failed to follow my real agenda. Attain courage, and achieve some closure.

This is essentially a slightly longer twitter post. Thanks for reading.

Wordpress Page Templates

My first question was how to create a new page in wordpress and apply to it my own layout and stylesheets. This was incredibly easy and intuitive.

1. Create a new .php page that will serve as a template for your new wordpress page.
2. Page templates are easily recognized by the wordpress CMS via a magical comment.

1
2
3
4
5

<?php
/*
Template Name: Your Template Name Here
*/
?>

3. Navigate to /wp-admin/ and depending on the version of your dashboard click add page.
4. Here you can give your page any title you want. And somewhere on the page you should see an option to apply a template to the page (again this varies with wordpress versions so Google or check documentation). If you uploaded your new .php template to the proper location you should conveniently see “Your Template Name Here” as an option.

Installing a Pagination Plugin

I decided to use WP-PageNavi although there are several alternatives I’ve found.

• WP Page Numbers
• Different Posts Per Page

To download and install follow these instructions:

1. Download WP-PageNavi
2. Upload folder “pagenavi” under wp-contents/plugins
3. Activate the plugin
4. Add the following code into your current theme’s php file.

5. Configure the settings under WP-Admin -> Options -> PageNavi
6. Click “Update Options” and you are done.

The Lonely Loop

The reason I titled this lonely loop is because most wordpress documentation will refer to the post entries as “THE LOOP“. The final code snippet that finally got things rolling for me was as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

<?php $page = (get_query_var('paged')) ? get_query_var('paged') : 1; 
 
		$my_query = new WP_Query('showposts=5&paged=$page');
		$wp_query = $my_query;
 
		query_posts("showposts=5&paged=$page");
 
		while ( have_posts() ) : the_post() ?>
  			<div class="post" id="post-<?php the_ID(); ?>">
                    <div class="date">
                    	<div class="day"><center><?php the_time('d') ?></center> </div>
                    	<div class="month"><center><?php the_time('F') ?></center> </div>
                    	<div class="year"><center><?php the_time('Y') ?></center> </div>
                    </div>
 
                    <h2><a href="<?php the_permalink() ?>" rel="bookmark" title="Permanent Link to <?php the_title_attribute(); ?>"><?php the_title(); ?></a></h2>
 
                    <?php the_content('Read the rest of this entry &raquo;'); ?>
 
                    <p><?php comments_popup_link('No Comments &#187;', '1 Comment &#187;', '% Comments &#187;'); ?></p>
                </div>
                <br class="clear" />
                <br class="clear" />
		<?php endwhile; ?>
 
 
       <div><?php next_posts_link('Older Entries')?></div>
       <div><?php previous_posts_link('Newer Entries')?></div>
 
        <?php if(function_exists('wp_pagenavi')) { wp_pagenavi(); } ?>

Obstacles Overcome

One of the first challenges I faced was realizing that the default loop provided in index.php did not properly render posts but instead interpreted function calls like the_title() with regard to the title of the page (template) opposed to individual posts. I later found according to slightly misleading documentation that a new query object is required. I proceeded to create one called $my_query. Where I would prefix function calls as such.

$my_query->have_posts()

and

$my_query->the_post()

This seemed to work, but the next problem was getting pagination to work in synch with this new query. The problem was that WP-PageNavi only listens to $wp_query. I had wondered around for some time trying to resolve this particular delima short of writing ajax and the pagination functionality by hand or maybe trying a different plug in. Thank fully after jumping from link to link I finally stumbled onto the following code block.

<?php $page = (get_query_var('paged')) ? get_query_var('paged') : 1;
query_posts("showposts=5&paged=$page");
while ( have_posts() ) : the_post() ?>
<h2><a href="<?php the_permalink() ?>"><?php the_title() ?></a></h2>
<span class="entry-date"><?php the_time('F d, Y'); ?></span>
<?php the_content(); ?>
<?php endwhile ?>

This finally got the ball rolling. I had only correct a few errors that sparked from the constant experimentation like a random reseting of the query at the end of the while loop. Conveniently above the pagination caused the current page to always read 1.

Hope this will be helpful to someone in the future. Here is an unordered list of sources.
http://codex.wordpress.org/Template_Tags/query_posts
http://codex.wordpress.org/The_Loop
http://codex.wordpress.org/Function_Reference/WP_Query
http://codex.wordpress.org/IRC
http://almosteffortless.com/2006/12/21/wordpress-pagination-on-a-page/
http://jarodtaylor.com/blog/wordpress-ultimate-archive-index-with-pagination/
http://www.w3cgallery.com/w3c-css/wordpress-pagination-in-pagephp-or-display-subpages-as-paging-under-parent-page
http://wordpress.org/support/topic/256899
http://www.lesterchan.net/wordpress/readme/wp-pagenavi.html

Download the latest stable release http://www.wxwidgets.org/downloads/
Go ahead and grab wxMSW - installer for Windows. Make sure your visual studio is closed so that the environment variable gets set up correctly.

Next your going to need to compile the library. So go ahead and navigate to installDir\build\msw.
Open up wx.dsw and convert it to your native Visual Studio format. Close visual studio back down and open up each vcproj in the current directory through notepad or notepad++. Search and replace each of the following:
- RuntimeLibrary=”3″ with RuntimeLibrary=”1″
- RuntimeLibrary=”2″ with RuntimeLibrary=”0″

Once your done. Open up the solution again, and right click the solution in the solution explorer. Select Batch Build. Select only the release and debug for each project. Once complete your ready to create your first wxWidget application with the added work of including all the directories and .lib in your project settings.

Here are two good links to help you get through this:
http://wiki.wxwidgets.org/Compiling_WxWidgets_on_Windows
http://wiki.wxwidgets.org/MSVC_.NET_Setup_Guide#Project_Properties

If it doesn’t work out right, go ahead and triple check everything!

What I learned from all this was that while wxWidgets are great for multiplatform development they are probably not a solution for developing game GUIs. I’d love to hear what others think on this subject, meanwhile I’ll move on to setting up my own GUI framework after a few hours of sleep.

Download the latest stable release http://www.wxwidgets.org/downloads/
Go ahead and grab wxMSW - installer for Windows. Make sure your visual studio is closed so that the environment variable gets set up correctly.

Next your going to need to compile the library. So go ahead and navigate to installDir\build\msw.
Open up wx.dsw and convert it to your native Visual Studio format. Close visual studio back down and open up each vcproj in the current directory through notepad or notepad++. Search and replace each of the following:
- RuntimeLibrary=”3″ with RuntimeLibrary=”1″
- RuntimeLibrary=”2″ with RuntimeLibrary=”0″

Once your done. Open up the solution again, and right click the solution in the solution explorer. Select Batch Build. Select only the release and debug for each project. Once complete your ready to create your first wxWidget application with the added work of including all the directories and .lib in your project settings.

Here are two good links to help you get through this:
http://wiki.wxwidgets.org/Compiling_WxWidgets_on_Windows
http://wiki.wxwidgets.org/MSVC_.NET_Setup_Guide#Project_Properties

If it doesn’t work out right, go ahead and triple check everything!

What I learned from all this was that while wxWidgets are great for multiplatform development they are probably not a solution for developing game GUIs. I’d love to hear what others think on this subject, meanwhile I’ll move on to setting up my own GUI framework after a few hours of sleep.

What I have so far:

• Math Library
• Event Handler
• Win32 Framework
• Resource Manager
• DirectX Initialization and Callbacks

What I’m tackling this week:

• GUI Framework
• wxWidgets Integration
• Network Framework
• Console Debugger

What I have so far:

• Math Library
• Event Handler
• Win32 Framework
• Resource Manager
• DirectX Initialization and Callbacks

What I’m tackling this week:

• GUI Framework
• wxWidgets Integration
• Network Framework
• Console Debugger

After high school I was very frustrated by the core classes that defined the first two years of a regular University. I was becoming even more frustrated by the partying, and lack of vision most of my friends and peers were only concerned about. I don’t remember what conversation made me remember Full Sail but it was a school I had known about since middle school and I truly felt my passion was in game development. I decided that I want two things out of my career. First interesting and challenging work that would keep me ever interested. Second I wanted to work at a fun place that allowed for creativity. So long story made a little shorter, Full Sail University is one of two schools at the time that might hope to provide for the sort of education that really teaches you the internal workings of making a game. I took the plunge. I packed up everything I owned into my car at the time 1998 Nissan Maxima, and drove it from Philadelphia to Winter Park FL. Thankfully my apartment was ready; I choose to stay at Winter Park Pointe apartments because they were the closest and cheapest in the area. I also decided to not have a roommate after a few disappointing attempts. So for the next few months I slept on nothing but a mattress.

The first three months are crucial at Full Sail; they help separate those who can and cannot handle the program. Odd schedules that have classes end at 1am and start again at 9am the next day. It was interesting trying to adapt to it, and many of us became nocturnal. The next month the schedule changed again. Oh yes, a semester is only a month long and classes are 40 hours a week. The pacing was perfect for me and I really dug all the knowledge. I was excited to be there, and I was just amazed at the different types of people I was surrounded by and all of whom held a strong interest in video games. I bought a PS3, and started playing games a lot more than ever before in my life. At some point along the way I think I lost sight of my goal and what was at stake. After the first three months I felt like I had C++ down solid.

The rest of the year we spent learning MFC, Win32, C#, DirectX, and Design Patterns. Along the way we also had a few general education classes needed for accreditation, but they too were all geared towards Game Development. This included an English course that had us write a full game design document. Math in Linear Algebra, Calculus, and Physics all laid out the foundation for what was to come.

The first game making experience was defined by two classes; Software Game Development and Software Game Production. I feel like both experiences deserve a post mortem but the lessons learned cannot be learned from reading this.

After the half way point it felt like we did something really great. We made a game! A great one at that. I, Casey Flach, and Charlie Prouse put together a 3D top down shooter in a roughly five weeks. Who knew that making a game doesn’t take months but weeks? Well we were hungry for more knowledge and the next few months more than helped satisfy that appetite. We took classes in Artificial Intelligence, Networking, Machine Architecture, OpenGL, Optimization, and Engine Development.

And we finally made it … final project… to be continued….

After high school I was very frustrated by the core classes that defined the first two years of a regular University. I was becoming even more frustrated by the partying, and lack of vision most of my friends and peers were only concerned about. I don’t remember what conversation made me remember Full Sail but it was a school I had known about since middle school and I truly felt my passion was in game development. I decided that I want two things out of my career. First interesting and challenging work that would keep me ever interested. Second I wanted to work at a fun place that allowed for creativity. So long story made a little shorter, Full Sail University is one of two schools at the time that might hope to provide for the sort of education that really teaches you the internal workings of making a game. I took the plunge. I packed up everything I owned into my car at the time 1998 Nissan Maxima, and drove it from Philadelphia to Winter Park FL. Thankfully my apartment was ready; I choose to stay at Winter Park Pointe apartments because they were the closest and cheapest in the area. I also decided to not have a roommate after a few disappointing attempts. So for the next few months I slept on nothing but a mattress.

The first three months are crucial at Full Sail; they help separate those who can and cannot handle the program. Odd schedules that have classes end at 1am and start again at 9am the next day. It was interesting trying to adapt to it, and many of us became nocturnal. The next month the schedule changed again. Oh yes, a semester is only a month long and classes are 40 hours a week. The pacing was perfect for me and I really dug all the knowledge. I was excited to be there, and I was just amazed at the different types of people I was surrounded by and all of whom held a strong interest in video games. I bought a PS3, and started playing games a lot more than ever before in my life. At some point along the way I think I lost sight of my goal and what was at stake. After the first three months I felt like I had C++ down solid.

The rest of the year we spent learning MFC, Win32, C#, DirectX, and Design Patterns. Along the way we also had a few general education classes needed for accreditation, but they too were all geared towards Game Development. This included an English course that had us write a full game design document. Math in Linear Algebra, Calculus, and Physics all laid out the foundation for what was to come.

The first game making experience was defined by two classes; Software Game Development and Software Game Production. I feel like both experiences deserve a post mortem but the lessons learned cannot be learned from reading this.

After the half way point it felt like we did something really great. We made a game! A great one at that. I, Casey Flach, and Charlie Prouse put together a 3D top down shooter in a roughly five weeks. Who knew that making a game doesn’t take months but weeks? Well we were hungry for more knowledge and the next few months more than helped satisfy that appetite. We took classes in Artificial Intelligence, Networking, Machine Architecture, OpenGL, Optimization, and Engine Development.

And we finally made it … final project… to be continued….

Take a look and I hope you like this Unity3D Particle Demo.

Take a look and I hope you like this Unity3D Particle Demo.

In this tutorial we’ll go straight to the source with the creation of our Maya exporter. We will not be covering Mel, or building our own GUI. Instead we’ll be adopting from the MPxFileTranslator, a maya file exporter. We’ll be saving out our code into an XML file format that can then be used as input for character models, or even levels.

Understanding Maya’s naming convention is key to feeling comfortable and eventually predicting variable names when exploring further feature sets of the Maya API.

Nearly all Maya prefixes begin with the letter M; which of course stands for Maya and defines a Maya wrapper class. Next we have MFn; which stands for Maya Function set. For example MFnMesh, contains specific functions and variables that appropriately define a mesh (a mesh is a collection of vertices, normals and uv coordinates in 3D space) object in Maya. The MFn prefix is not limited to only visible objects in Maya. For instance, MFnDependencyNode is a conceptual object that is used to define a node inside the Maya graph architecture (we’ll cover the Maya architecture shortly, so don’t stress it).

Another important prefix in Maya is the MIt prefix that stands for Maya iterator. An iterator is not a difficult concept for those who are familiar with the STL library. It points towards some position in a data set (in this case a tree) and allows us for easy traversal, going to the next object ( itr.next() ) and looping until done ( while(!itr.isDone()) ).

The last and final prefix to take note of is the MPx. It stands for Maya Proxy object (see proxy). Quite simply it provides us with an interface towards integrating into Maya itself. Common uses of MPx are the MPxFileTranslator which we will be focusing on in this tutorial and the MPxCommand which allows the user to create his or her own custom Maya commands. For more information please reference the Maya Documentation.

Now that we are past the formalities, we can begin to talk about how Maya organizes it’s data, so that we can begin to extract from it. Essentially everything in Maya is stored inside a Directed Acyclic Graph or DAG (this one keyword will be very important so please take note of it now). For those familiar with web design this is equivalent to the HTML DOM object, for those not familiar I will refer to the data structure of a graph. The major difference in definition of a graph data structure and the DAG is that child nodes cannot be their own parents. See picture below.

Step 1 – creating a proxy

Create a new class and derive from MPxFileTranslator.

class CFileTranslator : public MPxFileTranslator

You will need to overload the following functions

static void * creator(void);

MStatus writer(const MFileObject& file, const MString& optionString, FileAccessMode mode);

bool haveWriteMethod(void)const { return true; }

MString defaultExtension() const { return “xml”;}

MString filter() const { return “*.xml”;}

Step 2 – creating a an exporter class

Our Maya exporter will execute after pushing file -> export all or file -> export selection. Our entry point is than inside the writer() function that we have overloaded. In order to check for selection we can perform the simple if check for mode == kExportActiveAccessMode else we export all. Since this is more of a feature than base functionality I won’t cover exporting by selection in any great detail but its implementation is not very different from exporting all.

We now have the simple design decision to write all our code inside the CFileTranslator class we created earlier or simply create a new class that will be specific towards our needs. We will want this new class to contain a few basic functions. Such as ClearAndReset(), ExportVertexData() and WriteToFile(). We will call these in that sequence from within the CFileTranslator’s writer() function.

Step 3 – data structures and data members

Next we’ll create some basic data structures that we’ll fill out during exporting. One thing to note is that we’ll be using Maya’s intrinsic data types such as MFloatPoint which is essentially Maya’s version of a 3-tulupe vector that contains floats for the x, y, and z coordinates.

typedef struct _tVertex

{

MFloatPoint point;

MFloatVector normal;

float uv[2];

}UniqueVertex;

Here we created a new datatype that will contain the vertex position (point), the vertex normal (normal) and the UV texture coordinates (uv[2]). As we export our data we’re looking to optimize Maya’s vertex list by creating avoid duplicate vertices and creating a unique vertex list. We’ll than create our own triangle list that store indices into this our array of unique vertices. For a better idea on how index buffers work, reference Chad Vernon’s website at (http://www.chadvernon.com/blog/tutorials/directx9/vertex-and-index-buffers/). So the last important data structure we’ll need to generate is our triangle.

typedef struct _tTriangle

{

unsigned int verts[3];

}Triangle;

std::vector<UniqueVertex>    m_UniqueVertList;

std::vector<Triangle>    m_TriangleList;

Wrapping the above into a mesh structure would allow us to export more than one mesh at a time. These are further improvements that you may consider making to the base exporter.

Step 4 – the loop

The idea is quite simple, but the work may become a little tedious. Our goal is to go through go through Maya’s DAG , find all the Meshes and export them. The tedious part is that we’ll be doing a very similar traversal for just about each part of the export process since the DAG contains everything from Mesh objects to lights and transforms.

Thankfully the iteration process is quite straightforward. We begin by creating a MItDag. We specify that we’ll be traversing in depth first order, and we’ll be looking for Meshes. The code should look something like this.

MItDag dagIt(MItDag::kDepthFirst, MFn::kMesh);

Next we loop through each element, each time checking if the Mesh is an intermediate object, which simply means it’s something left over in Maya history but is not the current model we continue. Else we begin exporting by calling GetMesh(), our own function that will fill out our data structures from earlier.

for (;!dagIt.isDone(); dagIt.next())

{

MDagPath currPath;

dagIt.getPath(currPath);

MFnMesh currMesh(currPath);

if (currMesh.isIntermediateObject())

continue;

GetMesh(currMesh);

}

Step 5 – Creating a unique vertex list from Maya’s data

We’re now inside the GetMesh() function at which point our prime objective is to fill out our m_UniqueVertList and m_TriangleList for our mesh. This is also a good time to go ahead and pull out things like the mesh transform, or any custom attributes if you so wish. Again we will not focus on these features and move onto the actual data.

We begin by creating a MDagPath object which essentially will contain the directory, or path if you will, of the mesh we are attempting to export.

MDagPath path;

currMesh.getPath(path);

Next we’ll create a new itterator to traverse the polygons of our mesh (aka triangles). We’ll also create a few arrays that we’ll populate with Maya’s vertex positions, vertex normals, and UV coordinates.

MItMeshPolygon polyItr(path);

MFloatPointArray _tPoints;

currMesh.getPoints(_tPoints);

MFloatVectorArray _tNormals;

currMesh.getNormals(_tNormals);

MFloatArray _tVArrays;

MFloatArray _tUArrays;

currMesh.getUVs(_tVArrays,_tUArrays);

Something to take note of now, is that the index of the vertex positions, normals, and UVs will all be unique. Although the index of the U and V coordinates is a 1:1, and will use the same value.

If you have kept up with this tutorial so far, congratulations, we’re now in the final stretch and I will simply go ahead and post up the code for generating the unique vertex list and triangle list per mesh. Remember that this code snippet is my own and your coding style may or may not adhere to it. The important part is that you understand the process involved.

for (; !polyItr.isDone(); polyItr.next())

{

Triangle tmpTriangle;

for (int vertIndex = 0; vertIndex < 3; ++vertIndex)

{

UniqueVertex tmpVertex;

tmpVertex.point = _tPoints[polyItr.vertexIndex(vertIndex)];

tmpVertex.normal = _tNormals[polyItr.normalIndex(vertIndex)];

int uvIndex = -1;

if(polyItr.getUVIndex(vertIndex, uvIndex))

{

tmpVertex.uv[0] = _tVArrays[uvIndex];

tmpVertex.uv[1] = _tUArrays[uvIndex];

}

else

continue; // this is a bad place to be!

bool exists = false;

int i = 0;

int size = m_UniqueVertList.size();

for (; i < size; ++i)

{

if(m_UniqueVertList[i].point == tmpVertex.point && m_UniqueVertList[i].normal == tmpVertex.normal &&

m_UniqueVertList[i].uv[0] == tmpVertex.uv[0] && m_UniqueVertList[i].uv[1] == tmpVertex.uv[1] )

{

exists = true;

break;

}

}

if (exists)

{

tmpTriangle.verts[vertIndex] = i;

continue;

}

tmpTriangle.verts[vertIndex] = m_UniqueVertList.size();

m_UniqueVertList.push_back(tmpVertex);

}

m_TriangleList.push_back(tmpTriangle);

}

Since I didn’t cover everything involved with creating a Maya exporter and assumed some familiarity, or rather ability to use the Maya Documentation, please feel free to post comments and ask questions. I’ll be glad to make clarifications, but at the moment I need to get back to work.

We finally made it to Final Project! The next five months will be the most important months for me at FullSail. They will define all that I’ve learned, they will define all that I’m capable of. These last months will be the last stepping stones towards breaking into my dream job. There’s nothing more to say but this.

No matter what happens, no matter what goes wrong, no matter what challanges lie ahead. Our final project will be amazing, I know it. And with the months to come, I think I’ll convince you!

I recently wrote a paper on my research into procedural animation. We are only a few days from final project and my big game proposal is largely animation based. I thought it would be a good idea to put together a simple demonstration of Inverse Kinematics before Wednsday.

Although I was fairly successful at implementing the basic hierarchy, I am miles away from true IK. At the moment I’m attempting to comprehend Jacobians, but I feel my understanding for Calculus is really holding me back, as I’m having a hard time understanding fundemental concepts such as partial derivatives and how to represent derivites in code. Of course these are only set backs that I will resolve in the coming days.

For one I am glad I decided to keep this Unit Test very light and keep the process very itterative. This is usually quite the opposite to how I approach problems, but in this case it was largely to my benefit, as it allows for the implementation of small features before tackling the monster that is IK.

The steps I took are as follows:

1. Render a joint on screen using D3DXCreateTeapot (later changed to D3DXCreateSphere)
2. Add simple camera controls
3. Build a simplified skeleton architectures. This involves joints, and bones.
   • A joint is packed with a 4×4 local and global matrix representing both orientation and translation.
   • A local matrix is relative to its parent or @ origin (identity matrix) if no parent is present.
   • A global matrix is set or computed by taking the inverse of the local matrix. (this step will refined later)
   • A joint contains a list of children (bones). This allows us to climb down the hierarchy.
   • A joint contains an index into it’s parent (joint). This allows us to climb up the hierarchy.
   • A bone contains an index into it’s fromJoint, and an index into it’s toJoint.
   • If a a bone contains no toJoint it is assumed as the endeffector.
4. Build a DummySkeleton function that initializes a simple arm hierarchy as seen above. This is fast and easy, and would be later replaced with a filestream and a tool.
5. Render the skeleton.
   • Rendering joints as sphere will allow for simple collision tests when regarding picking
   • Bones are rendered through D3DPT_LINELIST.
   • Utilization of recursive breadth first traversal and ID3DXMatrixStack for push, and pop functionality.
6. Add picking (simply changing the appearance color of the joints for visual confirmation)
   • This will probably involve having to add additional information to an already rather large joint class.
7. Add highlighed, and selected states to the joints.
   • Again I opted to keep these inside the joints
8. When selected, translate the joint based on cursor position (should already be taken care of inside the picking algorithm). There is again some heavy use of inverses in this function, and this is where we can draw relationships between the data, to hopefully create better data structures during the next iteration.
9. Although imo, a minor step before attempting true IK. Implementing bounds based on bone length and DOF values for the axis, we will be officially at the milestone of Dynamic Control.

Introduction

Next generation games are becoming more demanding of large behavior sets, and therefore more animations per character. This trend is primarily noticeable through third person action adventure games such as Naughty Dog’s Uncharted, and Rockstar’s Grand Theft Auto 4. This demand is easily the prime reason for increased budgets when creating a next-gen video game [11]. Art assets are numerous and motion capture is often very expansive, especially so for startup studios. Thanks largely in part to systems like Natural Motion’s Euphoria, and Will Wright’s Spore; the industry has turned towards procedural animations.
Animation Systems

There are various forms of animation systems available. These range from simple free-bodies, morphing, articulated animations, and skin-bone animation [00]. This paper will focus on implementing a skin-bone animation, and analyze the restrictions and limitations of such a system.

Skin bone animation combines hierarchical joints that stem from the root (usually being the pelvis area), and associate sets of vertices to a single or multiple bones as is the case with smoothed skin animation.

In order to implement a hierarchical system, each node usually contains a several degrees of freedom, a quaternion to represent rotation, and a vector to represent translation. By distributing the matrix in such a form we cut back from the rather redundant <0, 0, 0, 1> vector for the last row or column in the matrix. Each joint is in reference to its parent, and the root note is respectively in global space. Due to this incoherency, the vertices will need to be translated into world space. This process is often referred to as flattening the hierarchy.

Below is a list of common structures that I will reference in the coming paragraphs. This will also give you a good sense of the architecture [10].

Transform
class transform_t
{
public:
transform_t();
quaternion rotation;
vector3<float> position;
};
A spatial transform structure is a good way to represent joints inside a skeleton structure and similarly we can include the bone information inside this same structure. It’s important to begin to get a good grasp over the required data, over a static composition.

Bone
class bone_t
{
public:
enum
{
X_ROTATION =1<<0,
Y_ROTATION =1<<1,
Z_ROTATION =1<<2
};
bone_t();
float dof[6];
float distance;
int parent;
int options;
};
The bone primarily represents the edges for the skeleton. This one way to go about your architecture and in reality there are many. In this example we specify in the options bit field which degree of freedom we’ll use. Based on that, we can also use the enum declared above to specify which dof (degrees of freedom) we’d like to access. The stored value of a dof is a pair of minimum and maximum values in radians for that joint. Where distance, is the offset along Z-axis. Finally the parent points us towards the index of our parent bone

Animation Sequence
class sequence_t
{
public:
sequence_t();
float fps;
int index;
int numframes;
};
Sequences act very much like mini-players in our architecture where we reference the time, in this case our fps, the index into our frames list which has a reference to a complete pose, and the number of frames to play for.

Our final structure would be a skeleton or a character class that encapsulates all of the above, and handles the hierarchy flattening, updating, rendering, and the animation. In the next section we will discuss motion graphs and talk and how modern games procedurally generate it’s animation from limited budgets.

Motion Graphs
Procedural animations can be classified into three forms. The most common in triple A titles is the parametric approach, which we’ll focus on here. This method is a combination of motion graphs and blending functions. Another approach is often presented by Ken Perlin [03] on his website, where walk cycles, butterfly wings, and other forms of movement are defined by math functions. Spore to some surprise is the former of the two, and the animation system is actually defined backwards where the mesh defines the bone structure and not the other way around. Finally a we have the Euphoria approach which combines rag doll physics system with an animation system and some clever AI to create its own set of procedural animations [11][13].

Taking into consideration only the parametric approaches, data is usually represented through either move trees or motion graphs. The former involves a designer to specify the exact transitions from one animation to another, and usually is done with short clips of animation. Although this process is considerably simpler than motion graphs it is also proportionally more expansive. Each time a new clip of animation is needed, the studio must reserve time for professional actors and/or stunt men to produce, and so these are usually all done in one go and often times don’t come out perfect. At the current state of the industry it is safe to assume that this is the most used approach.

Motion graphs help define transitions from one animation into another where smooth, seamless set of actions can be generated on the fly. This technique to my knowledge was pioneered or made popular by Lucas Kovar [09]. We begin with a corpus of motion capture data. Someone than edits the footage and associates each set of frames with labels. Labels simply act as human-legible strings that define the motion, such as “jump”, “walk”, “kick”, or “ballet”. I will not attempt to recreate Kovar’s work in this paper since his paper on motion graphs is largely distributed over the internet and is cited at the end of the paper. Instead I will help draw an understanding and familiarity with the algorithms involved.

After the motion capture data is recorded and labeled, we begin by generating an error function based of point clouds [16]. For each frame we compute the average distance of from frame i to frame j. From this data we can now generate our error function. See figure above. Next we compute the minima, which are simply points with the highest probability for transitions. Since this error function is based off point clouds, we are now less focusing primarily on the mesh as opposed to the bones which may lead to miss-interpretation. Such as certain rotations, like those in the wrist are sometimes less significant than those of the waist. After our minima is calculated we use those points to build the nodes of our animation and create transitions into other minima via blending functions (see blending below). Next we prune our graph against; dead ends - nodes with no children, sinks – nodes that contain one or only a few children but have many connections pointing towards them. And finally we want to prune our data against nodes that take in one type of label but who’s children do not share the same label for n depth. This final prune helps avoid a character from transition into awkward states in order to reach his goal; like going from “boxing” into “ballet”.

After the graph is properly generated we can utilize A* with heuristics to generate walk paths for our animations. For more on this, again, please reference Kovar’s work.

Blending
Real time animation in video games is evolving beyond cut-scenes and the fidelity involves balancing responsive controls towards smooth animations. We will consider blending techniques from linear interpolation to the more advanced approaches such as discussed by Leslie Ikemoto from the University of Berkley in her paper on Quick Transitions with Cached Multi-Way Blends [02].

Interpolation through functions is the most common form of transitioning from frame to frame of animation. Linear interpolation is the simplest way to handle translation without the seeing obscure artifacts. When handling rotation, by using a quaternion we can avoid scaling artifacts that can arise when using matrices. Spherical interpolation, commonly referred to as slerp is performed on the quaternions [06].

Breezier functions are often also good function to use, since it quite simply the interpolation of A onto B and C onto D and than AB onto CD. For further research on blending, and more particularly motion graph blends, I recommend reading Leslie’s paper on Multi-Way blends, where multiple samples are taken and an average motion is assumed.

Sliding Foot Syndrome

A very common problem when it comes to procedural animations, is the uncanny foot sliding, that creates unrealistic locomotion. This is often due to interpolation blending, that can creates unrealistic forward kinematics, particularly in the feet, since our eyes are so in tune to picking up such subtleties in human motion, the common solution is to perform an inverse kinematics algorithm onto the feet, and essentially clamp them to the ground.

To perform IK, we begin at the end-effectors [07] of the bones, in this case the feet nodes, and then perform the following steps:

1. Given a target point, we perform attempt to rotate our joint towards the target and perform a distance check from the tip of our bone to the target.

2. If we can’t reach the target based on the allowed degree’s of freedom we, begin a recursive process of moving down our hierarchy and readjusting our angles to achieve the maximum possible distance.

This algorithm will not guarantee realistic motion, and weights are often used to prefer one joint to another. Another approach is to split up the geometry into multiple parts, such as the body, arms, and legs. This allows for some optimization, particularly in a system that utilizes instancing. It also avoid obscure postures.

Remember that sometimes reaching the target is not possible, and this should be accounted for, since it may produce artifacts [10].
Creating Intelligence: Behavior Tree Design and Implementation
Due to higher expectations and level of interaction of AI agents, current-gen titles need to be both goal oriented and quick to make changes. The solution has grown to be hierarchical logic. These include HFSM (hierarchical Finite State Machine), HTN (hierarchical task network planner), and hierarchical scripting. Each given advantages and disadvantages, one new technique has emerged that was largely adopted by Damian Isla Halo 2 to be more precise. Behavior trees are the best compromise for the previous three techniques.

A behavior tree, is a tree that defines animations, sounds, into actions and conditions, that make up a task node. A task node can either succeed or fail. Before moving on, I’ll quickly define a composite. A composite can be considered children nodes from a task. These are not leaf nodes usually, but are broken down into two types. Sequencers, and selectors. A sequence is a condition in which case all child nodes must be successful to return true, and selectors return true if any of the children return true. As Alex Champandard points out, these are simply the AND/OR logic that most people are quite familiar with. Sequences and selectors are usually added onto basic state machine by a designer (usually through some sort of GUI). Similarly this has application into scripting. The final piece that makes behavior trees extremely powerful are filters that can be applied between nodes. These filters utilize the decorator design pattern, and can attempt to prune the hierarchy based off specific criteria. Creating multiples of such filters, a behavior tree specific design patterns will begin to immerge. Examples of which are timers, loops, counters, and so on. To learn more about behavior trees, I highly recommend AIGameDev.com, and Alex’s three part video tutorial on the subject.

To relate the topic back to procedural animation, a good approach is to split up the motion graph queries from the higher level logic. Which can be better handled through a separate data structure. Let’s consider a dog that’s currently eating a bowl of dog cereal, but is suddenly attacked. This would involve several very specific animations before going straight into his bark animation. The dog would first stop eating, look around, after he finds his target, glare at it, and begin to growl.

Work Cited
[00] Lecture notes from Real Time Animation by Shawn Stafford. FullSail University.

[01] Learning to Move Autonomously in a Hostile World, Leslie Ikemoto, University of California at Berkeley. http://www.animate-me.com/~leslie/papers/moveAutonomous.pdf

[02] Quick Transitions with Cached Multi-way Blends, Leslie Ikemoto, University of California at Berkeley. http://www.animate-me.com/~leslie/papers/i3d2007.pdf

[03] Ken Perlin’s Experiments on Procedural Animation, http://www.mrl.nyu.edu/~perlin/

[04] Inverse Kinematics by Hugo Elias, http://freespace.virgin.net/hugo.elias/models/m_ik.htm

[05] Inverse Kinematics – Improved Meathods by Hugo Elias, http://freespace.virgin.net/hugo.elias/models/m_ik2.htm

[06] The Matrix and Quaternion FAQ, http://web.archive.org/web/20041029003853/http:/www.j3d.org/matrix_faq/matrfaq_latest.html#Q47

[07] Physics Based Animation by Erleben, Sporring, Henriksen, Dohlmann.

[08] Inverse Kinematics Using Jacobians, http://diegopark.googlepages.com/computergraphics

[09] Motion Graphs by Lucas Kovar, University of Wisconsin Maddison. http://www.cs.wisc.edu/graphics/Papers/Gleicher/Mocap/mograph.pdf

[10] Inverse Kinematics for Humanoid Skeleton Tutorial by Jonathan Kreuzer. http://www.3dkingdoms.com/ik.htm#ikappen

[11] Planting Spores of Procedural Animation? by Dave Mark. http://aigamedev.com/discussion/planting-the-spores-of-procedural-animation

[12] The Crysis of Integrating Next-Gen Animations and AI, by Alex J. Champandard. http://aigamedev.com/reviews/crysis-animation-integration

[13] 9 Tips for Creating Rich Behaviors on a Low Animation Budget, by Alex J. Champandard. http://aigamedev.com/animation/budget-rich-behaviors

[14] The Backbone of AI Behaviors: Movement and Animation, by Alex J. Champandard. http://aigamedev.com/tutorials/backbone-behaviors-movement-animation

[15] Behavior Trees for Next-Gen AI, by Alex J. Champandard (3 parts). http://aigamedev.com/videos/behavior-trees-part1

[16] Point Cloud, Wikipedia (2008). http://en.wikipedia.org/wiki/Point_cloud