The latest version of the DigitalRune Engine adds support for Windows Store (WinRT) and Windows Phone 8.
Here is summary of changes and new features in the latest release of the DigitalRune Engine.
Here is summary of improvements in the latest release of DigitalRune Graphics.
Rendercode Games has released the new Xbox LIVE Indie game Racedrome City:
The latest chapter in the Racedrome saga raises the bar with improved handling, physics, and visuals. Enjoy high-speed urban racing against strong AI, or challenge up to 8 players online. Also included is local multiplayer, global scoreboards, rewind function, and more!
Here is the trailer:
Racedrome City uses DigitalRune Physics to simulate the vehicles. More specifically, …
A while ago we have blogged about our car physics implementation (see Car Physics for 3D Games). Today we release an alternative implementation:
Our last post about real-time motion capture using Kinect seems to be pretty popular. And for the small amount of time (only a few hours) that we put into this example, the results are satisfying – but we can do better! We have updated the project and included a brand new sample. The new sample uses skeleton mapping to animate 3D models using Kinect. The code is much simpler, and exchanging the 3D model is a lot easier. We have also updated the example application to use Kinect SDK v1.0 instead of Kinect SDK beta2. You can download the sample project (including the source code) at the end of this post.
Here are the results of the new sample application:
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.
This time we take a look at how the DigitalRune Game UI library handles input.
Here is a class diagram showing only the types and type members related to input processing:
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.
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:
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.)
Richard Moss (http://cyotek.com/) has written a very good article about how to add CSS syntax highlighting to the DigitalRune Text Editor Control.
Check it out: CSS Syntax Highlighting in the DigitalRune Text Editor Control (by cyotek.com)
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.
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.
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!):
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:
In our company we do not program in VB.NET. Not that we have anything against it, we have just specialized in C# when we program .NET applications.
We are are aware that our WinForms libraries (DigitalRune Docking Windows and the DigitalRune Text Editor Control) are used by many VB programmers. And they regularly ask for VB example code.
Here are a few ways to automatically convert C# code to VB (or the other way around):
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.
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:
(on Documentation page)
DigitalRune is a trademark of Garstenauer Information Technology OG.
Garstenauer Information Technology OG
Weingartenstrasse 35, 4452 Ternberg