This is the second part of the step-by-step tutorial for building a simple game menu in XNA. Previously we have set up the project, the game loop, and added the UI theme. Now it’s time to implement the game logic…
The latest release of the DigitalRune Engine contains a new sample called GameStatesSample which covers a some of the basics:
The result is a stripped down XNA application – no fancy graphics, no gameplay, just a few screens and menus. Take a look:
...
Together with yesterday’s update we have also put a new version of DigitalRune Game UI online. Below you can find a list of a few things that have changed.
The most important – though maybe not obvious – change is that all GUI controls can now be animated using our new DigitalRune Animation library. Properties such as foreground color, background color, x, y, width, height, opacity, etc. can easily be controlled using animations. A new sample is included which demonstrates some of the possibilities.
…
We are about to release the first (alpha) version of our new animation library for XNA: DigitalRune Animation.
I am currently working on the documentation and have just finished writing the summary of all features. This library is packed with features! I dare to say that this is the most comprehensive animation library for .NET and XNA to date.
(I am personally really excited about this new product. It is the result of months – actually years – of research and hard work.)
The current alpha release of the DigitalRune Game UI does not not have built-in support for animations. This will change when we release our DigitalRune Animation library. Here is a preview video of an XNA application with animated GUI controls:
The DigitalRune Game UI is a very flexible XNA GUI library that can be used in games for Windows, Xbox 360 and Windows Phone 7. The library can be used to create a simple menu in a console game or a complex GUI in a game editor.
It contains several predefined UI themes. Yesterday, we have created a new theme that will be included in the next release. This blog post shows the necessary steps to create a new UI theme.
The DigitalRune Game UI package is a set of .NET libraries that help to handle device input and create graphical user interfaces (GUIs) in XNA. The libraries support Windows, Xbox 360 and Windows Phone 7. The GUI can be controlled using mouse, keyboard, gamepad or touch input.
With the DigitalRune Game UI you can create a simple game menu for your Xbox 360 or Windows Phone 7 game. Or, you can create a complex user interface for your MMORPG or your game editor. The GUI can be a normal 2D user interface, but is also possible to project the GUI onto 3D surfaces to create in-game user interfaces.
We have made several improvements to our 3D character controller, which we want to discuss in this post. (Reminder: A character controller is the game module that computes the movement of a player character, including walking, jumping, climbing, etc.)
Following video shows the new character controllers in action. (The code is included in the DigitalRune Physics Bundle).
We have recently added 3D vehicle physics to our DigitalRune Physics library. In this post we will explain how the car physics works, so that you can either create your own car physics, or you can understand and tune the car physics that comes with our libraries.
Let’s have a look at what we want to achieve. Following Vehicle Sample is an XNA example project that is included in the DigitalRune Physics Bundle:
The .NET Framework 4 contains the Task Parallel Library (TPL). It introduces the concept of tasks. Tasks represent asynchronous operations that can be executed concurrently. Developers no longer have to manage threads or thread pool work items directly. The library provides a higher-level API for writing multi-threaded application or games. The only negative thing we can say about the TPL is that it is not supported on the .NET Compact Framework and is therefore not available on the Xbox 360 (or the WP7).
When we added multithreading support for our libraries, we looked for an easy-to-use, cross-platform threading library. After evaluating a lot of solutions we found the ParallelTasks library on CodePlex. The library is a lightweight replacement for the TPL. It offers all relevant features such as …
In the previous post I wrote about the resource pool implementation offered by the DigitalRune Helper library. In this post I will show the pattern we use to make objects reusable.
When we start to design a class library we usually don’t care about resource pooling. Only when the major parts of the API and the internal algorithms are done we start to measure performance and profile memory usage. When we started optimizing DigitalRune Geometry and Physics we realized that some objects needed to be pooled in order to avoid garbage on the Xbox 360. So a few types had to be made reusable.
The following pattern has proven very handy for turning a normal object into a pooled object.
By now, we probably all know that the latency of the garbage collector on Xbox 360 and Windows Phone 7 can be a problem. One solution is to avoid frequent memory allocations by using resource pools (or free-lists).
This blog post provides some information about the resource pool implementation provided by the DigitalRune libraries.
In all XNA games you have to create your own Game class that derives from the Game base class. Here is a pattern in which we use the service provider pattern to create a clear structure for our game class.
In many XNA games and samples the Game class does a lot of stuff and is maybe the most complex class of the application. This makes the source code difficult to understand and hard to re-use. We suggest two things to improve this:
In almost all 3D games collisions between complex shaped objects must be detected. For collision detection the triangle meshes can be used directly but this is a lot slower than using boxes, spheres or convex shapes. Therefore, for each model a collision model should be created that consists only of simple primitives. This collection of shapes approximates the shape of the detailed 3D graphics model. This blog posts discusses how we can use the XNA content pipeline to load shapes from a collision model created in a 3D modeling tool. The example source code can be downloaded.
In the previous post I have introduced the concept of a Pose. A Pose is a new type defined in DigitalRune Geometry. It defines the position and orientation of an object in 3D space.
In this post I will describe how a Pose can be used to define a World or View transformation matrix…
The task of positioning an object in space is so important in a game that we have introduced a type called Pose in DigitalRune Geometry. A Pose describes a position (a Vector3F) and an orientation (a Matrix33F or a QuaternionF) in 3D space. It is very similar to a transformation matrix…
Here is another Windows Phone 7 physics example: It shows a few bodies and a 3d ragdoll. Tilt or shake the phone to move the bodies.
Windows Phone 7 is awesome! – This blog post shows DigitalRune Physics on a real Windows Phone 7 in action. The full sample source code can be downloaded at the end of the posting.
Following video shows the sample running on a Samsung Omnia 7 (a great WP7 device!):
We have created class diagrams for the Microsoft XNA Framework 4.0 assemblies (including Content Pipeline). (If you are looking for XNA 3 class diagrams, take a look at this post: XNA 3.x Framework Class Diagrams).
For the new DigitalRune Geometry library we have created a simple 3D character controller example (including source code).
A character controller, as understood in this context, is a game engine module that computes the movement of an avatar in a game. The input for the character controller is the desired movement (e.g. “move forward with 5 m/s speed”, or “jump”) and the output is the new corrected avatar position in the 3D game world. The character controller has to apply gravity, avoid penetration of walls and other solid objects, handle stepping up/down slopes and stairs, and more.
If you don’t know how to create class diagrams for the XNA classes in Visual Studio, here is a quick summary of the process.
When I learn a new API I like to look at the API using different views: example code, API documentation, and class diagrams. When we started to learn XNA, we created class diagrams for the XNA framework. This helped a lot in getting an overview and seeing relationships between types.
I haven’t seen XNA class diagrams publicly on the internet. So it might help if I post our class diagrams here.
This is a collection of various links about character animation and related topics.
A collection of the most useful blog articles can be found here:
Article Collection (on Documentation page)
DigitalRune is a trademark of Garstenauer Information Technology OG.
Garstenauer Information Technology OG Weingartenstrasse 35, 4452 Ternberg Austria (EUROPE) office@digitalrune.com