The code that I am going to provide is written for the XNA framework and the Visual Studio testing framework but the concepts that are described in this post can be applied to any game development and testing platforms.

In many cases ensuring that a vector is the one we expect is not as straight forward as writing:

Assert.AreEqual(expectedVector, actualVector).

To illustrate the problem imagine that we have a vector (0, 0, -200), we perform some operations that transform the vector by rotating it around the Y axis by 90 degrees, and we want to assert that the operation is done correctly. You might be baffled to find that after the transformation the vector does not equal exactly (-200, 0, 0), but rather something like (-200, 0, 0.000008742278). This “error” has to do with floating-point numbers and round-off errors. So in order to be able to test our code we have to allow for such imprecision.

The Visual Studio testing framework provides a method that we can use to compare floating-point numbers with a specified tolerance. We just have to build on top of that in order to create a method that we can use for vector comparison. Let’s call the method VectorsAreEqual and inplement it in a class called MathAssert.

public static class MathAssert
{
    private static float precisionDelta = 0.00001f;

    public static void VectorsAreEqual(Vector3 expected, Vector3 actual)
    {
        Assert.AreEqual(expected.X, actual.X, precisionDelta);
        Assert.AreEqual(expected.Y, actual.Y, precisionDelta);
        Assert.AreEqual(expected.Z, actual.Z, precisionDelta);
    }
}

The method is very simple and probably the only question remaining is what a good value for the delta is? The value should be as precise a possible, but at the same time not too precise so it can eliminate the floting-point errors. In my tests I am using a value of 0.00001 which in my opinion is good enough.

Now that we have created our method we can easily compare the vectors (-200, 0, 0.000008742278) and (-200, 0, 0) and assert that they are equal:

Vector3 expectedVector = new Vector3(-200f, 0f, 0f);
Vector3 actualVector = new Vector3(-200f, 0f, 0.000008742278f);

MathAssert.VectorsAreEqual(expectedVector, actualVector);

Transformations are another fundamental part of game programming and being able to test them is crucial. If you are building a scene graph, for example, you probably want to make sure the when a parent node rotates all of its child nodes rotate as well. So we need a way to verify that the resulting transformations are computed as expected. As you might know transformations are composed of linearly independent vectors called basis vectors. A 2D transformation matrix has 2 basis vectors, while a 3D matrix has 3.

The illustrations above show 3 different two-dimensional transformations and their basis vectors. First (on figure 1) we have identity transformation which does not alter vectors in any way. On the second figure we have a transformation that performs 90 degree rotation of vectors. On figure 3 we have a transformation that performs scaling along the X axis.

As you might know every basis vector corresponds to a single axis of the coordinate space that its transformation describes. In figure 1, for example, the first basis vector corresponds to the X axis and the second vector corresponds to the Y axis. Similarly on figure 2 the first basis vector corresponds to the X axis but the difference there is that the X axis of this transformation points up.
In order to test a transformation for correctness we need to assert that the basis vectors are the ones that we expect.

XNA’s Matrix class can give us a lot of information and we can easily get the basis vectors. The three basis vectors are Matrix.Right, Matrix.Up, and Matrix.Forward. So if we expect to have a transformation that would rotate a vector around the Y axis by 90 degrees we would expect to have (-1, 0, 0) for Forward, (0, 0, -1) for Right, and (0, 0, 1) for Up.

So in order to test a transformation we have to test the 3 basis vectors. For convenience we create a a new method called BasisIsCorrect in our MathAssert class:

public static class MathAssert
{
    private static float precisionDelta = 0.00001f;

    public static void VectorsAreEqual(Vector3 expected, Vector3 actual)
    {
        Assert.AreEqual(expected.X, actual.X, precisionDelta);
        Assert.AreEqual(expected.Y, actual.Y, precisionDelta);
        Assert.AreEqual(expected.Z, actual.Z, precisionDelta);
    } 

    public static void BasisIsCorrect(Matrix basis, Vector3 expectedForward, Vector3 expectedRight, Vector3 expectedUp)
    {
        MathAssert.VectorsAreEqual(expectedForward, basis.Forward);
        MathAssert.VectorsAreEqual(expectedRight, basis.Right);
        MathAssert.VectorsAreEqual(expectedUp, basis.Up);
    }
}

Now all we have to do to test a transformation is to use this method.

Happy testing.

Print Friendly

There are primarily two problems of finding good books about game development. First there are many of them our there. Probably not as many as in some other fields but still you should spend considerable time for research. The second problem is that game development tends to be a very complex and very extensive field and unfortunately not every author can present such complex material in a digestible form.

When I first started with game development I bought about 2 dozen books and as you might expect some of them were great while others proved to be a waste of money. In attempt to save someone some time and money I have listed several books that, in my opinion, are the best.

So here is my list of the best books about game development:

3D Math Primer for Graphics and Game Development

This is one of my favorite books. It is a great source for learning the mathematics behind game development. Important concepts like coordinate spaces, vectors, matrices, quaternions, transformations, etc are clearly explained. The understanding is aided by good illustrations and sample code written in C++. Moreover, the last part of the book introduces many technologies like collision tests, lighting, etc that are used in today’s games and are build upon the concepts introduces in the first part of the book.
Great book.

Introduction to 3D Game Programming with DirectX 9.0c a Shader Approach

Another favorite. Great introduction to the DirectX API. Most importantly the book focuses on the use of shaders and the High-level shading language. The book demonstrates how you can use shaders to create special effects like reflections, shadows, lighting, particle systems, etc.
The latest iteration of this book focuses on DirectX 10. I haven’t been able to check it our so far but I’m sure that it is a must have introduction to DX 10.

Game Coding Complete, Second Edition

One of the best books about computer technologies that I have ever read. Great writing style and most importantly great content. The book explores game development on a higher level by introducing the concept of game engines. If you want to learn about the building blocks of today’s games and how those blocks interact with one another this book is probably the best starting resource available.

Shader X Series

No doubt one of the best sources for intermediate to advanced knowledge in the field of graphics. Every edition provides a look into cutting-edge computer graphics techniques that take advantage of the latest advancements in computer hardware. Truly a remarkable resource and a must-have.

I have got a couple more good books on my shelves, but I will leave them for another time.
Share your thoughts about my book selection. What are your favorite books?

Print Friendly