A while ago we discussed in the Forum how to use the Microsoft Kinect SDK to animate a character model in real-time and how to apply movement constraints (e.g. joint rotation limits). Yesterday our company got a new Kinect device and I figured I might spend the rest of the afternoon trying to write a small XNA sample.
Here is the result: (You can download the source code below the video.)
…
Here are few thoughts about 2011, the coming year and one uncommented video…
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:
...
In the last months we have received a few requests about Mono support for our DigitalRune Engine libraries. I have spent some time to get familiar with Mono, and to see what implications Mono support would have.
If you are not familiar with Mono: Mono is an open source implementation of Microsoft’s .NET Framework. It makes the .NET framework available under Linux and Mac OS X. …
This article is a step-by-step description of my first attempt to create a tree view control. I spent less than 4 hours of work on the control and this was the result:
In this article I will explain the development steps, as well as my thought process. At the end of the article you can download the source code.
While we discussed the GUI rendering process in the last article, we left out any details about the default UI renderer. if you plan to create custom controls, you will want to extend the standard renderer, and this blog post will hopefully provide the missing explanations.
In the last article about the DigitalRune Game UI we examined how the size and position of a GUI control is determined. Yet we have not discussed where and how the controls are drawn to the screen. This the topic of this article. – This will be another rather dry article, but we are trying to get a lot of information and knowledge across for those who want to extend or learn from our DigitalRune Game UI library. So let’s jump right in…
Here is another in-depth article about the DigitalRune Game UI. This article discusses the layout process of GUI controls.
So you need a custom control in your XNA game? A new control that is not yet supported in the DigitalRune Game UI? - No problem. There are many ways to extend the DigitalRune Game UI library - as we will discuss in this and upcoming blog posts. We will start by describing a few core concepts that you need to understand before you can take full advantage of the DigitalRune Game UI library.
In this first post we will discuss the concept of UI control properties and events.
Recently I made some improvements to the character controller in DigitalRune Physics. I became aware of some issues while reading the article “Jump To It” (Game Developer Magazine, issue 11/2008, pp. 38). It turns out that the jumping mechanic can be improved.
The KinematicCharacterController can be used to control the movement of a player character. The character controller handles moving, sliding along obstacles, walking slopes, stepping over obstacles, … and jumping. (Reminder: If you have an Indie or Standard license of DigitalRune Physics, you can download the source code of the character controllers from the Downloads page. See “Additional Downloads”.)
Jumping works fine in most cases. That is, …
Skeletal animation is the most common way to animate a 3D character: Transformations are applied to a set of bones (skeleton), which is then used to deform the mesh (skin) of the character. When using key frame animations the bone transforms need to be stored at certain key times. Depending on the complexity of the character and the length of the animation, the required amount of data can become quite large. Let’s see what we can do to reduce the amount of data.
Here is a code snippet that draws the bones of a 3D character skeleton for debugging (similar to the original SkeletonHelper.DrawBones method). The result looks like this:
(Click image to enlarge.)
Here is the code:
Manually creating good ragdolls in code can be tough. This blog post takes you on a hands-on ragdoll creation journey and provides several tips.
The DigitalRune Animation library supports ragdolls. DigitalRune Animation has a lot of helpful methods for character animation and ragdoll creation, but it does not yet have a method that visualizes ragdoll constraints. Choosing good joint limits and correct joint orientations can be really difficult without a visualization. – But do not fear, constraint visualization is here!
The following .zip archive contains a “RagdollHelper” class that draws constraints for a ragdoll. It also contains an updated “DudeRagdollCreator.cs”.
In DigitalRune Animation, motion retargeting (or more precise: animation retargeting) is the process of transferring the animations of one character to another character with a different skeleton topology.
In the video below, the walk animation of the Dude model (left) is applied to the PlayerMarine model (right).
At the first look the models seem similar, but a look at skeletal structure reveals a number of differences: …
This time we take a look at the TwoJointIKSolver class of DigitalRune Animation. This IK solver can be used to control an arm or a leg. In the following video the IK solver is used for foot placement:
The DigitalRune Animation library contains several inverse kinematics (IK) controllers that can be used to procedurally animate a 3D character. This blog post demonstrates the Look-At IK solver. So, have 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.
As shown in the last posts, we can use scattered interpolation for height field creation or to animate a hand model with a data glove. Now, it is time to dive into the mathematics. Especially, we examine scattered interpolation using radial basis functions.
In the last blog post (Scattered Interpolation – Example 1: Smooth Height Fields) we introduced the concept of scattered interpolation, how scattered interpolation is supported in DigitalRune Mathematics, and how it can be used to create smooth height fields. Here is another example that shows how useful this technique is. The mathematical details of scattered interpolation will follow in the next blog post.
Scattered Interpolation is a very useful mathematical method, but it is not widely known among game developers. Once you understand it, it can solve many problems. Creating smooth height fields from random points or smoothly interpolating animations are only two examples. It is definitely worth to dig through a bit of mathematics to add a handy new tool to your toolbox. This tool is also readily available in the DigitalRune Mathematics library.
In this post we are going to look at an examples. In future blog posts, we will look at other examples and explain Scattered Interpolation with all the scary mathematics.
Do you multiply matrices and quaternions from the left or from the right? Do you use a left-handed or a right handed coordinate system? How do you define the front-side of a triangle? What units of measurement do you use? – This blog post explores the math conventions that we use and a few more helpful details…
In the last articles (Part 1 and Part 2), we have introduced our input service and commonly used functions of the input service. In this post we will delve into more advanced functions. We will discuss how we
In the last post, we introduced the (still empty) input service interface. Now it is time to add a few functions. This blog post describes
XNA makes input handling very easy. It provides one static class for each input device: Keyboard, Mouse, and GamePad. In each frame, you can query the device states and examine the current key and button states. But sooner or later you discover that there are a few tasks that are not supported:
This becomes especially apparent when you create a game with a complex user interface (windows, text boxes, etc.).
And to be clear: It is ok that these tasks are not supported because the XNA Framework is not a game engine!
While creating our XNA GUI library (see DigitalRune Game UI), we have identified several commonly needed tasks and packed them into an input service. This and the next blog posts describe our input service design.
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 …
The new version of the DigitalRune Helper Library (DigitalRune.dll, which is part of DigitalRune Physics Bundle) has not 1 but 2 profiler classes. The “simple profiler” class was introduced in the previous blog post. In this blog post, we talk about the second profiler, which is a “hierarchical profiler”. It was inspired by the article Real-Time Hierarchical Profiling (Game Programming Gems 3).
Do we really need another profiler class? – Yes, really! This class has slightly different goals. The main goal is to measure the timing of nested method calls. This is extremely helpful in many applications – in particular if you need to optimize your game loop. An important difference between the simple profiler and the hierarchical profiler is that the hierarchical profiler does not work across multiple threads. That’s why we still need the simple profiler. The simple profiler can be used to collect values and to profile code in multi-threaded scenarios.
Here is a short description of a new Profiler class that comes with the new release of the DigitalRune Helper Library (DigitalRune.dll, which is part of DigitalRune Physics Bundle).
The Profiler class provides following features:
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.
We are Windows Phone 7 owners, have a 3D game physics library, and play Dungeons & Dragons… That leaves us no choice: We have to make a D20 dice app for the phone!
Here is an early work-in-progress video:
The phone’s accelerometer can be used to shake the dice. This short clip is from an early stage. With the current build, the dice do not leave the viewport anymore and can be dragged or pushed with the finger.
We plan to release the core source code for all DigitalRune Physics customers as free bonus sample after we have released the app.
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:
We have discussed the Service Provider pattern in the last blog post and in this post we will show how to implement a service provider, how the DigitalRune libraries support this pattern, and how to use it in an XNA game.
Implementing a basic service provider with a Dictionary is simple:
The service provider pattern is one of my favorite patterns: It creates clean, slick code when used right - but when used in the wrong places it creates libraries that are hard to use, difficult to understand and a nightmare to maintain. In this blog post we examine the service provider pattern, related concepts, like global variables, services, managers, service providers, contexts and how they can be used in games.
In computer games damping is used to slow down a moving object. For example, a sphere is rolling on a plane and should slow down due to air resistance. Or, we make a flick gesture on the Windows Phone 7 to scroll a screen. The screen scrolls and slowly comes to rest.
Damping is related to concepts like friction, air resistance, viscous drag, etc. In this post we look at a few damping methods from the perspective of a game developer (and not the perspective of physicist).
Reducing the speed sounds easy – but is it really?
A big hello to all readers,
here is a brief status update to let you know where our current development focus lies.
A minor update including small bugfixes and improved samples will arrive next week.
We are also working on a Windows Phone 7 dice app. The D20 dice app will hit the Windows Phone 7 market place in the next weeks. The source code will be released as a free premium download for all existing DigitalRune Physics users.
Still under development. Currently, the development has sparked two new byproducts: The DigitalRune Game UI library and the DigitalRune Animation library.
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!):
Besides DigitalRune Physics we have been working on DigitalRune Graphics for several month now. I thought it would be nice to use a few graphics effects of DigitalRune Graphics to make our physics demos more interesting. – And here is the result: A short video testing screen space ambient occlusion, an atmospheric scattering skydome and god rays in a simple XNA physics demo. (Implementation details follow after the video.)
Fine, we have found a way to implement Continuous Collision Detection (CCD), but how do we integrate this into our game physics library?
This article explains how to use CCD in game physics; especially a technique called motion clamping that is used in DigitalRune Physics and possible pitfalls you could come across when you use game physics with CCD.
The last posts (Continuous Collision Detection – The Problem and Continuous Collision Detection – Solutions) covered Continuous Collision Detection (CCD). Here are a few more notes related to CCD.
In the last post we talked about the shortcomings of discrete collision detection and why we need continuous collision detection (CCD). Now it is time to discuss ways to implement CCD to avoid tunneling of objects (missed collisions) and find the time of impact.
Collision detection in 3d games detects whether objects are intersecting. The normal discrete collision detection does so by checking the objects at their current position. Then the game moves the objects and the collision detection checks the objects at their new positions.
This method works for slow moving objects, but for fast moving objects critical collisions can be missed. To detect all collisions we need “Continuous Collision Detection” (CCD), which we will discuss in this and the next blog posts.
Multi-monitor support in Visual Studio 2010 is great. However, there is no direct way to switch between different window layouts.
In Visual Studio 2003 and 2005 you could use the addin VSWindowManager to manage window layouts. With some minor adjustments you could also run the addin in Visual Studio 2008. But the addin is not compatible with Visual Studio 2010.
Luckily, there is a simple solution…
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).
Our new physics library is nearly finished. Here is a compilation of a few tests:
When writing a 3D collision detection system you will most likely run into the following problem: Given a convex polygon (in 2D) or a convex polyhedron (in 3D), which of its vertices is the extreme point in a given direction. The problem is known as Support Mapping or Extremal Query. (The resulting vertex is called Support Point or Extreme Point.) Algorithms like GJK, EPA (Expanding Polytope Algorithm) or MPR (Minkowski Portal Refinement) rely heavily on extremal queries.
For simple polyhedra (small number of vertices) you can simply do an exhaustive search to find the extreme point in a given direction. However, for complex polyhedra you want to find a way to accelerate the query…
In the last post we computed convex hulls for the XNA dude. Convex hulls are useful approximations for collision detection because many algorithms like GJK, EPA (Expanding Polytope Algorithm) or MPR (Minkowski Portal Refinement) can handle arbitrary convex objects. We also used simplified convex hulls. In this post we describe how we have implemented convex hull generation, convex hull simplification and skin width.
Actually, there are many convex hull algorithms. Here is a java applet showing different algorithms: http://www.cse.unsw.edu.au/~lambert/java/3d/hull.html
We started with incremental construction as described in this book:
DigitalRune Geometry supports automatic generation of bounding shapes and convex hulls. Using simple bounding shapes or convex hulls is more efficient than using arbitrary triangle meshes in game physics. In this post we will investigate different kinds of bounding shapes.
Let's look at a practical example. Here is the Dude from the XNA Skinned Model Example:
The model has 13132 vertices and the skeleton has 60 bones.
Here is the same model where a bounding sphere is computed for the vertices of each bone.
Somewhere I read that characters in Quake-style first-person-shooter games have a speed of 10 m/s. To account for this unnatural speed the gravity is often set to a higher than normal value, like 16 m/s² (instead of 9,81 m/s²).
We haven't verified this statement, so let's put this in perspective (with collected notes from our internal knowledge base):
Seriously. If I cannot jump in an action game, chances are high that I will not play it.
Do you remember that there once was a game type called "Jump'n'Run" – where according to the genre name jumping was 50% of the gameplay and the joy? Jumping on its own is fun and it is a natural way to show emotion. In World of Warcraft, for example, jumping is the simplest expression of feelings. – Typing emotes is way to complicated for me ;-)
When implementing jumping an interesting question arises: How much control does the user have while jumping?
Ok, this one is simple - but simple things matter. Take a block of wood, drill three holes and add 3 colored pencils. If you do it right, you might get something like this:
Yet another blog post about character controllers for 3D games, and this time we will talk about the actual implementation.
Here is how the character controller in our Character Controller Example works:
The character is represented as a an upright capsule that does not rotate:
There are at least two ways to implement a character controller for a 3D game: Kinematic and Dynamic Character Controllers. In this post we discuss the difference and which solution is better.
A short reminder: In this context a character controller is the piece of code that computes the movement of the player character in the game. It takes care that the user does not run through walls, can step up/down, jump etc. The character is often modeled as an upright capsule.
Related posts: 3D XNA Character Controller Example and Character Controller Requirements
In one of the last posts we introduced our Character Controller Example. In the next posts, we will discuss character controllers for 3D games in more detail, including: general requirements, kinematic vs. dynamic character controllers, implementation, character controllers in virtual reality.
This post starts the series with a discussion of requirements of 3D game character controller.
The first requirement is teleport because the character controller must be set to its initial position. A teleport sets the character to a new position. It doesn't matter where it was previously and if there are obstacles between the old and new position.
This blog post contains our collection of references for Collision Detection: website links, a list of collision detection libraries, list of books. This post will be updated from time to time.
If you know other useful links, please let us know and we will include them in this blog post.
This is a collection of various links about collision detection and related topics.
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.
Here is a list of physics engines. This blog entry will be updated from time to time. If you know other useful links, please let us know and we will include them in this list.
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.
Here is a list of books related to rigid body dynamics and game physics.
by David M. Bourg
This book is an easy-to-read introduction to game physics. It explains the basics (kinematics, kinetics, forces, particles, rigid bodies, collision response) and several applications (projectiles, ships, hovercrafts, cars, etc.). The book is for beginners. You will need other sources for advanced topics, like rigid body contacts or joint-handling.
I have encountered several errors while reading the book, so make sure to read the errata on the book's website: http://www.oreilly.com/catalog/physicsgame/
This is a collection of links about game physics, especially rigid body dynamics, and related topics.
This is a collection of various links about character animation and related topics.
In 2005 I finished my master thesis about rigid body dynamics. It shows how to build a rigid body physics engine for interactive 3d applications. I am sure it is a good starting point for everyone who wants to learn about game physics.
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