Wolfire Games Blog

Old School Color Cycling with HTML5

2010-07-27T19:25:14Z

In the last day, a number of people have sent me this awesome link, so I figured I would post it here as well. It is an awesome mix of HTML5, game tech, and nostalgia:

Joe Huckaby of Effect Games has created a neat HTML5 tool for rendering old school game backgrounds that use color cycling. For all of the technical details, check out Joe's blog post.

Click above to check it out

It should work in all browsers except the IEs (although IE9 should support it.) The art was created by Mark Ferrari.

Overgrowth Alpha 89

2010-07-27T01:55:13Z

Here is what is new in Overgrowth in the 89th weekly alpha. If you are confused what a weekly alpha is, or even what Overgrowth is, please read our fancy FAQ. Basically, we are developing a massive video game from the ground up -- we are able to do this completely independently by accepting preorders for the game before it's done!

Here are a few highlights from the source repository:

More modular IK calculation
Started hooking up IK animation widgets
Fixed ctrl-click crash bug
Fixed a bone labels bug
Starting Blender PHXBN import/export script

Checking out some ruins

Thanks as always for all the support! See you guys in IRC and the forums.

Overgrowth Tutorial: Playing With BVH Animations

2010-07-24T17:55:07Z

David already teased everyone with the new animation tech in Overgrowth with his initial motion capture tests video. However, this week I had a chance to really go into the nitty gritty details of the new features. So without further ado, I humbly present to you a new Overgrowth tech demo.

Be sure to check it out in HD!

In summary, BVH animation files can now be loaded into the engine and David has created an animation algorithm that can translate the orginal humanoid BVH data to suit the specific size and dimensions of the current humanoid character you have rigged (assuming it has the same core structure). Last but not least, once you have a BVH animation loaded, you can save it out as an ANM file which can then be utilized by the scripting layer.

Remember you can download all the CMU motion captured data I used in this video (as well as 2500 other animations I didn't use) from this web site. The animations come with a nice index explaining what actions each file contains.

Hopefully the video makes it pretty clear how everything is working right now. The tech isn't finished yet but I thought it was especially fun to see Robbert performing a high-detail boxing animation.

What do you guys think of the new animation technology?

Blender as an animation editor

2010-07-23T04:30:28Z

While working on some combat animations, I decided that the current Phoenix animation editor is too hard to use, and there are too many bottlenecks in the route to making it better. So, for now, I am looking into alternative approaches to editing animations.

So far I am leaning towards integrating Blender animation, perhaps with custom import and export scripts. One of my original motivations for creating an animation editor was to make it available to all players without any expensive or platform-specific software. Blender fulfills this requirement because it's free, cross-platform, and open-source. Many valuable resources are free and open-source as well: for example, this great animation tutorial series here, and this reusable character rig here. Here is Robbert set up with that rig:

Dramatic combat pose!

Blender also already has tools for working with blend shapes (aka morph targets) for per-vertex effects like facial expressions, so this could save a lot of time in that regard as well. However, the existing Phoenix animation editor would still be useful for adding important meta-data like ragdoll joint limits, animation events, and scripted IK lines.

Robbert takes a bow

I've heard complaints about the user interface in Blender, but I've always found it to be pretty consistent-- once you learn a few basic rules, everything makes sense. It has also made a lot of progress while being battle-tested in shorts like Elephants Dream, Big Buck Bunny, and the soon-to-be-released, Sintel.

What do you think, would it be a good idea to use Blender as the primary animation tool for Overgrowth?

Linear algebra for game developers ~ part 3

2010-07-21T04:17:50Z

I introduced vectors in Part 1, and a toolset for working with them in Part 2. However, today I would like to talk about perhaps the most important concept for game developers. This is the concept of the transformation matrix.

Let's start by looking at the building blocks of the transformation matrix:

Basis Vectors

Let's say we're making an Asteroids game on really old hardware, and we want to have a simple 2D space ship that can rotate freely. The ship model looks like this:

So how do we draw it when the player rotates by an arbitrary amount, like 49 degrees counter-clockwise? Well, trigonometry we can create a function for 2D rotation that inputs a point and an angle, and outputs a rotated point:

   vec2 rotate(vec2 point, float angle){
           vec2 rotated_point;
           rotated_point.x = point.x * cos(angle) - point.y * sin(angle);
           rotated_point.y = point.x * sin(angle) + point.y * cos(angle);
           return rotated_point;
   }

Applying this to our three points gives us the following shape:

Cosine and sine operations are pretty slow, but we're only doing them on three points, so it can smoothly on our old hardware. But now we decide to upgrade the ship to look like this:

Now our old method is too slow! We don't have enough sine and cosine operations to rotate this many points. There are many ways to solve this problem, but an elegant solution comes to us like this: "What if instead of rotating each point in the model, we just rotate the model's x and y axes instead?"

How does this work? Well, let's look at what coordinates mean. When we talk about the the point (3,2), we are saying that its position is three times the x-axis plus two times the y-axis. The default axes are (1,0) for the x-axis and (0,1) for the y-axis, so we get the position 3(1,0) + 2(0,1). But the axes don't have to be (1,0) and (0,1). If we rotate these axes, then we can rotate every point at the same time.

To get the rotated x and y axes we just use the trigonometric function above. For example, if we are rotating by 49 degrees, then we get the new x-axis by rotating (1,0) by 49 degrees and we get the y-axis by rotating (0,1) by 49 degrees. Our new x-axis is (0.66, 0.75), and our new y-axis is (-0.75, 0.66). We can do this by hand for our 3-point model to prove that it works:

The top point is (0,2), which means its new position is zero times the rotated x-axis plus twice the rotated y-axis.

0*(0.66,0.75) + 2*(-0.75, 0.66) = (-1.5, 1.3)

The bottom-left point is (-1,-1), which means its new position is negative one times the rotated x-axis plus negative one times the rotated y-axis.

-1*(0.66,0.75) + -1*(-0.75, 0.66) = (0.1, -1.4)

The bottom-right point is (1,-1), which means its new position is one times the rotated x-axis plus negative one times the rotated y-axis.

1*(0.66,0.75) + -1*(-0.75, 0.66) = (1.4, 0.1)

What we are doing here is using the ship coordinates as if they exist in a separate coordinate system with rotated axes (or 'basis vectors'). This is useful in this case because it separates the cost of manipulating the orientation of the ship from the cost of applying the orientation to the model points.

Whenever you have modified the basis vectors (1,0) and (0,1) to (a,b) and (c,d), then the modified point (x,y) can be found using this expression:

x(a,b) + y(c,d)

Normally the basis vectors are (1,0) and (0,1) so you just get x(1,0) + y(0,1) = (x,y), and you don't have to bother with this. However, it's important to remember that you can use other bases (plural of basis) as well.

Matrices

Matrices are like 2-dimensional vectors. For example, a typical 2x2 matrix might look like this:

   [a c 
    b d]

When you multiply a matrix by a vector, you sum the dot product of each row of the matrix with the vector. For example, if we multiply the above matrix with the vector (x,y), we get:

(a,c)•(x,y) + (b,d)•(x,y)

Written another way, this is:

x(a,b) + y(c,d)

Look familiar? This is the exact same expression that we use when changing the basis vectors! This means that multiplying a 2x2 matrix with a 2D vector is the same thing as changing its basis vectors. For example, if we plug the standard basis vectors (1,0) and (0,1) into the matrix columns, we get:

[1 0 
 0 1]

This is the identity matrix, which has no effect, as we would expect from the neutral basis vectors we chose. If we plug in our 49-degree rotation bases, we get:

[0.66 -0.75 
 0.75  0.66]

This matrix will rotate any 2D vector counter-clockwise by 49 degrees. We could write our asteroids program with a lot more elegance by using matrices like this. For example, our ship-rotation function could look like this:

void RotateShip(float degrees){
        Matrix2x2 R = GetRotationMatrix(degrees);
        for(int i=0; i<num_points; ++i){
                rotated_point[i] = R * point[i];
        }
}

However, it would be even more elegant if we could include translation (movement through space) in the matrix as well. Then we would have a single data structure that can elegantly store and apply the orientation and position of each object. Fortunately, there is a way to do this, even though it's a bit of an ugly hack. If we want to translate by a vector (e,f), we can just tack it onto our change-of-basis matrix like this:

[a c e 
 b d f 
 0 0 1]

And then we add an extra [1] to the end of each position vector like this:

[x y 1]

Now when we multiply them together we get:

(a,c,e)•(x,y,1) + (b,d,f)•(x,y,1) + (0,0,1)•(x,y,1)

Which can essentially be rewritten:

x(a,b) + y(c,d) + (e,f)

So now we have the entire transformation in a single matrix! This is important for many reasons aside from just elegant code, because now we can use all of the standard matrix manipulation tools on it. For example, we can multiply matrices together to add their effects, or we can invert a matrix to give it the exact opposite transformation.

3D Matrices

Matrices in 3D work just like they do in 2D -- I just used 2D examples in this post because they are easier to convey with a 2D screen. You just define three columns for the basis vectors instead of two. If the basis vectors are (a,b,c), (d,e,f) and (g,h,i) then your matrix should be:

[a d g 
 b e h 
 c f i]

If you need translation (j,k,l), then you add the extra column and row like before:

[a d g j 
 b e h k 
 c f i l 
 0 0 0 1]

And add an extra [1] onto the vectors like this:

[x y z 1]

There is a lot more to say about matrix transformations, but I thought I should stop here to see if this makes any sense. Do you have any questions about this topic, or any ideas for future ones?

Overgrowth Alpha 88

2010-07-20T06:48:35Z

Here is what is new in Overgrowth in the 88th weekly alpha. If you are confused what a weekly alpha is, or even what Overgrowth is, please read our fancy FAQ. Basically, we are developing a massive video game from the ground up -- we are able to do this completely independently by accepting preorders for the game before it's done!

Here are a few highlights from the source repository:

Fixed "terrainlow.obj" write directory issue
Fixed stippled line drawing bug
Safer one-shot animations without script callbacks
Vertexstream merging and splitting
Added script query for unmodified IK target positions
Started on alternate controls for creating animations
Fixed frustum culling issue for duplicated objects
Improved undo
Testing out lying-down animations using IK

Thanks as always for all the support! See you guys in IRC and the forums.

Cyberpunk sketches

2010-07-17T04:16:51Z

Here at Wolfire we think it's a good idea to keep thinking of new ideas for games (as we mentioned in this blog post), because you never know when you will hit on something cool. Because of the 10-year anniversary of Deus Ex, I have been thinking a lot about the cyberpunk setting, so I decided to do a few concepts and a test asset to explore some of those ideas.

First, here are some sketches of robots that inhabit this setting:

Next are some thumbnail sketches of the humans who live and fight here:

These quick drawings are good for comparing the shapes and silhouettes of the different character, but we need more color and detail to really show off their different styles:

Finally, I made a 3D character asset to test out hand-painted shading:

I hope you like these sketches! I still devote almost all of my effort to Overgrowth, but I find that sketching out other ideas helps get my mind from getting cluttered with them. Who knows, we might even use them one day! What do you think of these sketches? Are these characters you would like to see in a game one day?

Indie Water Cooler interview

2010-07-15T05:58:16Z

Our buddies at Dejobaan (makers of the recent AaaaaAAaaaAAAaaAAAAaAAAAA!!! video game) recently hosted a novel interview with Eitan Glinert, Andy Moore, and me on their new site Indie Superstar.

Click to go to the interview

It was really interesting being interviewed by a fellow indie developer, alongside two other developers. There are some interesting anecdotes.

Check it out here: Indie Water Cooler.

Overgrowth Alpha 87

2010-07-13T08:56:24Z

Here is what is new in Overgrowth in the 87th weekly alpha. If you are confused what a weekly alpha is, or even what Overgrowth is, please read our fancy FAQ. Basically, we are developing a massive video game from the ground up -- we are able to do this completely independently by accepting preorders for the game before it's done!

As you might have noticed from the lack of blog updates this week, it has been unusually slow. This is because David was visiting San Francisco this week for his (and my) birthday. We were in Sierra City for a good chunk of the week, so coding was not optimal. He is back in position now and we should be back in business!

Here are a few highlights from the source repository:

Improved automatic bone weights
Fixed file manipulation issues without admin access
Better rolling off edges

Some new art assets coming soon in the data pack.

Thanks as always for all the support! See you guys in IRC and the forums.

Odds and ends

2010-07-12T06:16:57Z

Here are a few odds and ends that I have done that I thought were worth showing off on the blog. The first is a collection of thumbnail images I did for level set pieces. I plan to do a lot more of these, but I'm still trying to come up with cool ideas!

You may remember my previous dog clan concept art (here and here). This clan specializes in using the spear in formation tactics. Long ago their clan was saved from certain destruction by the Storm Runner clan, and so they pledged their lives, and the lives of all their descendents, to repaying their debt to clan Storm Runner. As a result of the close association between the clans, the Fartooth clan has developed unique battle tactics that depend on the support of the fast moving Storm Runners.

And finally I have drawn up a new plan for the current set of assets I am working on. Here it is!