DigitalRune Blog

Research: Augmented Reality with Microsoft Kinect

Tue, 01 May 2012 14:21:03 GMT

This is a guest post by Kairat Aitpayev.

Augmented Reality (AR) technology allows adding virtual object to the real world using special markers. By merging it with Microsoft Kinect I have created new approach which allows users to use their own body as a collision object in the 3D world and interact with augmented objects.

Video

Here the presentation of the demo application which by itself is a part of bigger project related with online sport education:

(Full video of entire project: See https://vimeo.com/41136278)

The project was created in the MultiMedia Lab of Kazakh-British Technical University (Kazakhstan) in collaboration with University of Technology of Belfort-Montbeliard (France).

DigitalRune libraries are used to improve the interaction between the real and the virtual world.

Real-Time Motion Capture using Kinect and XNA (Part 2)

Tue, 03 Apr 2012 14:12:02 GMT

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.

Video

Here are the results of the new sample application:

…

Real-Time Motion Capture using Kinect and XNA

Tue, 03 Jan 2012 11:15:56 GMT

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.)

…

Happy New Year!

Sat, 31 Dec 2011 17:53:14 GMT

Here are few thoughts about 2011, the coming year and one uncommented video…

How to Build an Animated, State-Based Game Menu in XNA (Part 3)

Wed, 30 Nov 2011 17:11:51 GMT

It is time to make the game menu built in the previous two blog posts (Part 1, Part 2) more dynamic. Currently all screens are static. When another game screen is opened the change is instant – there is no transition phase between screens.

This is what we want to achieve:

The DigitalRune Animation library provides an animation system for animating objects. In Part 1 and Part 2 the animation system has already been set up and is ready to be used.

Animations can be applied to objects that implement the interface IAnimatableObject and properties that implement IAnimatableProperty. The UI controls, used for rendering the screens, already implement the required interfaces.

Animating the Start Text

First, we want to improve the “Start” screen. When the loading process is complete, the text “Loading…” changes to “Press Start button”. We can animate the text to draw the player’s attention to it. The easiest way is to animate the opacity of the TextBlock.

/// 
/// Called when "Start" state is entered.
/// 
private void OnEnterStartScreen(object sender, StateEventArgs eventArgs)
{
  // Show the "Press Start button" text centered on the screen.
  _startTextBlock = new TextBlock
  {
    Name = "StartTextBlock",
    Text = "Press Start button",
    HorizontalAlignment = HorizontalAlignment.Center,
    VerticalAlignment = VerticalAlignment.Center,
  };
  _screen.Children.Add(_startTextBlock);

  // The text should pulse to indicate that a user interaction is required.
  // To achieve this we can animate the opacity of the TextBlock.
  var opacityAnimation = new SingleFromToByAnimation
  {
    From = 1,                             // Animate from opaque (Opacity == 1)
    To = 0.25f,                           // to nearly transparent (Opacity == 0.25)
    Duration = TimeSpan.FromSeconds(0.5), // over a duration of 0.5 seconds.
    EasingFunction = new SineEase { Mode = EasingMode.EaseInOut }
  };

  // A SingleFromToByAnimation plays only once, but the animation should be 
  // played back-and-forth until the user presses a button.
  // We need to wrap the SingleFromToByAnimation in an AnimationClip or TimelineClip.
  // Animation clips can be used to cut and loop other animations.
  var loopingOpacityAnimation = new AnimationClip(opacityAnimation)
  {
    LoopBehavior = LoopBehavior.Oscillate,  // Play back-and-forth.
    Duration = TimeSpan.MaxValue            // Loop forever.
  };

  // We want to apply the animation to the "Opacity" property of the TextBlock.
  // All "game object properties" of a UIControl can be made "animatable".      
  // First, get a handle to the "Opacity" property.
  var opacityProperty = _startTextBlock.Properties.Get(TextBlock.OpacityPropertyId);

  // Then cast the "Opacity" property to an IAnimatableProperty. 
  var animatableOpacityProperty = opacityProperty.AsAnimatable();

  // Start the pulse animation.
  var animationController = _animationService.StartAnimation(loopingOpacityAnimation, animatableOpacityProperty);

  // Enable "automatic recycling". This step is optional. It ensures that the
  // associated resources are recycled when either the animation is stopped or
  // the target object (the TextBlock) is garbage collected.
  // (The associated resources will be reused by future animations, which will
  // reduce the number of required memory allocations at runtime.)
  animationController.AutoRecycle();
}

Playing a Fade-Out Animation

Once the player has pressed the Start button, we want to smoothly fade-out the TextBlock. Instead of triggering the transition from the “Start” screen to the “Menu” screen right away, we first play the fade-out animation.

This is the new update method of the “Start” screen:

private bool _exitAnimationIsPlaying;                 // true if fade-out animation is playing.
private AnimationController _exitAnimationController; // Controls the fade-out animation.

/// 
/// Called every frame when "Start" state is active.
/// 
private void OnUpdateStartScreen(object sender, StateEventArgs eventArgs)
{
  if (_exitAnimationIsPlaying)
    return;

  bool transitionToMenu = false;

  // Check if the user presses A or START on any connected gamepad.
  for (var controller = PlayerIndex.One; controller <= PlayerIndex.Four; controller++)
  {
    if (_inputService.IsDown(Buttons.A, controller) || _inputService.IsDown(Buttons.Start, controller))
    {
      // A or START was pressed. Assign this controller to the first "logical player".
      _inputService.SetLogicalPlayer(LogicalPlayerIndex.One, controller);
      transitionToMenu = true;
    }
  }

  if (_inputService.IsDown(MouseButtons.Left)
      || _inputService.IsDown(Keys.Enter)
      || _inputService.IsDown(Keys.Escape)
      || _inputService.IsDown(Keys.Space))
  {
    // The users has pressed the left mouse button or a key on the keyboard. 
    if (!_inputService.GetLogicalPlayer(LogicalPlayerIndex.One).HasValue)
    {
      // No controller has been assigned to the first "logical player". Maybe 
      // there is no gamepad connected.
      // --> Just guess which controller is the primary player and continue.
      _inputService.SetLogicalPlayer(LogicalPlayerIndex.One, PlayerIndex.One);
    }

    transitionToMenu = true;
  }

  if (transitionToMenu)
  {
    // Play a fade-out animation which changes the opacity from its current value to 0.
    var fadeOutAnimation = new SingleFromToByAnimation
    {
      To = 0,                               // Animate the opacity from the current value to 0
      Duration = TimeSpan.FromSeconds(0.5), // over a duration of 0.5 seconds.
    };
    var opacityProperty = _startTextBlock.Properties.Get(TextBlock.OpacityPropertyId).AsAnimatable();
    _exitAnimationController = _animationService.StartAnimation(fadeOutAnimation, opacityProperty);

    // When the fade-out animation finished trigger the transition from the "Start" 
    // screen to the "Menu" screen.
    _exitAnimationController.Completed += (s, e) => _stateMachine.States.ActiveState.Transitions["StartToMenu"].Fire();

    _exitAnimationIsPlaying = true;
  }
}

When we exit the “Start” state, we can stop the animation:

/// 
/// Called when "Start" state is exited.
/// 
private void OnExitStartScreen(object sender, StateEventArgs eventArgs)
{
  // Clean up.
  _exitAnimationController.Stop();
  _exitAnimationController.Recycle();
  _exitAnimationIsPlaying = false;

  _screen.Children.Remove(_startTextBlock);
  _startTextBlock = null;
}

Animating the Menu Items

The menu items should dynamically slide in from the left. To achieve this effect we can animate the opacity and the RenderTranslation of the Button controls. The RenderTranslation is an offset which is only applied during rendering. (It does not affect the layout of the controls on the screen.)

The same animation effect can be applied to the “SubMenu” screen, therefore we put the code in a general helper method:

/// 
/// Called when "Menu" state is entered.
/// 
private void OnEnterMenuScreen(object sender, StateEventArgs eventArgs)
{
  // Show a main menu consisting of several buttons.
  ...

  // Slide the buttons (contained in the stack panel) in from the left to make 
  // the screen look more dynamic.
  AnimateFrom(stackPanel.Children, 0, new Vector2F(-300, 0));
}

/// 
/// Animates the opacity and offset of a group of controls from the specified value to their 
/// current value.
/// 
/// The UI controls to be animated.
/// The initial opacity.
/// The initial offset.
private void AnimateFrom(IList controls, float opacity, Vector2F offset)
{
  TimeSpan duration = TimeSpan.FromSeconds(0.8);

  // First, let's define the animation that is going to be applied to a control.
  // Animate the "Opacity" from the specified value to its current value.
  var opacityAnimation = new SingleFromToByAnimation
  {
    TargetProperty = "Opacity",
    From = opacity,
    Duration = duration,
    EasingFunction = new CubicEase { Mode = EasingMode.EaseOut },
  };

  // Animate the "RenderTranslation" property from the specified offset to 
  // its current value, which is usually (0, 0).
  var offsetAnimation = new Vector2FFromToByAnimation
  {
    TargetProperty = "RenderTranslation",
    From = offset,
    Duration = duration,
    EasingFunction = new CubicEase { Mode = EasingMode.EaseOut },
  };

  // Group the opacity and offset animation together using a TimelineGroup.
  var timelineGroup = new TimelineGroup();
  timelineGroup.Add(opacityAnimation);
  timelineGroup.Add(offsetAnimation);

  // Run the animation on each control using a slight delay to give the first controls
  // a slight head start.
  var numberOfControls = controls.Count;
  for (int i = 0; i < controls.Count; i++)
  {
    var clip = new TimelineClip(timelineGroup)
    {
      Delay = TimeSpan.FromSeconds(-0.04 * (numberOfControls - i)),
      FillBehavior = FillBehavior.Stop,   // Stop and remove the animation when it is done.
    };
    var animationController = _animationService.StartAnimation(clip, controls[i]);

    // Enable "auto-recycling" to ensure that the animation resources are recycled once
    // the animation stops or the target objects are garbage collected.
    animationController.AutoRecycle();
  }
}

Previously, in the “Start” screen, we have applied the animation directly to the opacity property. In this case we are animating two properties at once. The opacity animation and the position animation are grouped together and the combined animation is applied to the target object. The animation system takes care of the rest and applies the animations to the correct UI control properties.

And so forth…

The remaining animation and screens are similar, so I will skip any further explanations.

This article concludes the three part series. I tried to keep explanations brief and I am aware that I skipped some of the details. I recommend you check out the sample, if you haven’t already. The source code contains a lot of additional comments. It is included in the download package of the DigitalRune Engine (see folder \Samples\DigitalRune.Game.UI\GameStatesSample).

My original goal, when initially writing the sample, was to introduce the StateMachine offered by DigitalRune Game. In Part 2 we have used the state machine to separate the logic of different game screens. But this actually only scratches the surface. The state machine has a lot more to offer, such as nested states, parallel states, timed transitions, etc. I am curious whether you will find it helpful.

More ...

How to Build an Animated, State-Based Game Menu in XNA (Part 2)

Tue, 29 Nov 2011 15:56:50 GMT

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…

How to Build an Animated, State-Based Game Menu in XNA (Part 1)

Mon, 28 Nov 2011 11:42:27 GMT

The latest release of the DigitalRune Engine contains a new sample called GameStatesSample which covers a some of the basics:

How to set up the game loop.
How to define a theme for rendering the user-interface.
How to create a game menu which can be controlled via gamepad, mouse, and keyboard.
How to manage different game screens using a state machine.
How to transition between screens using animations.

The result is a stripped down XNA application – no fancy graphics, no gameplay, just a few screens and menus. Take a look:

...

Upcoming Mono Support for the DigitalRune Engine

Wed, 16 Nov 2011 16:41:34 GMT

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.

About Mono

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. …

Creating an XNA Tree View Control

Fri, 07 Oct 2011 17:29:20 GMT

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.

…

DigitalRune Game UI: GUI Input Handling

Tue, 04 Oct 2011 15:39:32 GMT

This time we take a look at how the DigitalRune Game UI library handles input.

Overview

Here is a class diagram showing only the types and type members related to input processing:

…

DigitalRune Game UI: The UIRenderer

Fri, 30 Sep 2011 09:00:54 GMT

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.

…

DigitalRune Game UI: The GUI Rendering Process

Wed, 28 Sep 2011 18:37:53 GMT

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…

DigitalRune Game UI: The GUI Layout Process

Mon, 26 Sep 2011 19:48:30 GMT

Here is another in-depth article about the DigitalRune Game UI. This article discusses the layout process of GUI controls.

…

DigitalRune Game UI: UI Control Properties

Wed, 21 Sep 2011 23:00:00 GMT

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.

Jumping is hard

Thu, 15 Sep 2011 10:03:38 GMT

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.

What is wrong with the current implementation?

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, …

Character Animation Compression

Wed, 31 Aug 2011 10:57:38 GMT

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.

…

Visualization of a Model Skeleton

Thu, 11 Aug 2011 23:00:00 GMT

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:

…

How to Create Ragdolls

Thu, 11 Aug 2011 14:33:14 GMT

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.

…

Visualization of Ragdoll Joints

Sun, 07 Aug 2011 09:50:08 GMT

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!

Download

The following .zip archive contains a “RagdollHelper” class that draws constraints for a ragdoll. It also contains an updated “DudeRagdollCreator.cs”.

…

Motion Retargeting in XNA

Fri, 29 Jul 2011 16:39:16 GMT

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.

Video

In the video below, the walk animation of the Dude model (left) is applied to the PlayerMarine model (right).

Description

At the first look the models seem similar, but a look at skeletal structure reveals a number of differences:
…

Inverse Kinematics in XNA: Foot IK Solver

Tue, 26 Jul 2011 19:12:52 GMT

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:

Video

Description

…

Inverse Kinematics in XNA: Look-At Inverse Kinematics Solver

Mon, 25 Jul 2011 14:44:23 GMT

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:

Video

Description

…

Changes in DigitalRune Game UI v1.0Alpha2

Fri, 22 Jul 2011 12:56:00 GMT

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.

Support for Animations

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.

…

New XNA Animation library is packed with features!

Thu, 14 Jul 2011 12:08:13 GMT

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.)

Features in DigitalRune Animation

…

XNA GUI Animation Test

Wed, 13 Jul 2011 12:19:41 GMT

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:

More ...

Creating a New UI Theme for the DigitalRune Game UI

Tue, 12 Jul 2011 12:15:57 GMT

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.

…

CSS Syntax Highlighting in the DigitalRune Text Editor Control

Sun, 10 Jul 2011 14:23:39 GMT

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)

More ...

Scattered Interpolation using Radial Basis Functions

Tue, 07 Jun 2011 23:00:00 GMT

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.

…

Scattered Interpolation – Example 2: Interpolation of Animation

Mon, 06 Jun 2011 12:30:03 GMT

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 – Example 1: Smooth Height Fields

Fri, 03 Jun 2011 12:13:20 GMT

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.

…

3D Math Conventions

Tue, 31 May 2011 12:18:13 GMT

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…

Input Handling in XNA Games – Part 3

Thu, 19 May 2011 10:44:02 GMT

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

use logical players to let the user play with any connected controller,
control the order of input handling and preemption when several components handle device input,
allow the player to re-configure the input.

…

Input Handling in XNA Games – Part 2

Thu, 12 May 2011 08:37:14 GMT

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

how to detect button clicks and double-clicks,
how to add key repetition for held down keys,
how to enable mouse centering for relative mouse input.

…

Input Handling in XNA Games – Part 1

Tue, 10 May 2011 15:16:47 GMT

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:

detecting button clicks,
detecting double-clicks,
keeping track of which of the 4 controllers the user is using,
making the controls configurable,
and more.

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.

…

DigitalRune Game UI (Alpha Version) Available!

Fri, 06 May 2011 12:57:38 GMT

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.

…

Character Controller Improvements

Thu, 14 Apr 2011 15:27:11 GMT

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).

Changes & Source Code

…

Car Physics for 3D Games

Mon, 11 Apr 2011 17:08:46 GMT

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.

Our Goal

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:

Requirements

…

DigitalRune Helper Library: Multithreading in XNA

Wed, 23 Mar 2011 18:06:09 GMT

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 …

DigitalRune Helper Library: Hierarchical Profiler

Tue, 15 Mar 2011 18:49:47 GMT

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.

…

DigitalRune Helper Library: Simple Profiler

Thu, 10 Mar 2011 17:56:44 GMT

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).

Simple Profiler Features

The Profiler class provides following features:

Measure code execution time.
Collect interesting values, like “How many collisions happened in this frame?”, “How many iterations did this algorithm make?”, etc.
Compute minimum, average and maximum values.
Thread-safety.
Do not influence performance in release builds – only in profiling builds of the game.

Overview

…