Perfectly Accurate Game Timing

These days, I designed a timing system for my game. Doesn’t really sound impressive, eh?

The problem with accurate timing, apart from hardware faults making timers change speed or jump back, is to resample a high-frequency clock running at 3+ MHz to the update rate your game is running with.

The naive approach would be to just cast the clock to a double and divide it by one 60th (if you want 60 Hz updates) of the clock’s frequency. But that’s not really such a good idea. Let me illustrate:

int main() {
  float a = 20000000;
  ++a;
  // a is still 20,000,000. The accuracy of the float has diminished so
  // much that you not only have zero decimal places, it cannot even assume
  // the value 20,000,001 -- only 20,000,002!
 
  double b = 10000000000000000;
  ++b;
  // b is still 10,000,000,000,000,000. Same reason.
}
Continue Reading →

Ogre 1.8.0 RC1 for WinRT/Metro

Ogre 3D Logo

Here’s an interesting hypothesis: when Apple started its App Store, it was the El Dorado of software developers. Now Microsoft is adding an App Store to Windows 8. The Windows user base is huge, much larger than even the number of people running around with iPhones in their pockets (some estimates I came across average to around 75 million iPhone users [1] [2] versus around 600 million Windows users [3] [4]). Even if Windows 8 adoption rates are as bad as Vista’s you could turn a mighty profit!

What better way could there be to achieve that than to publish a 3D game on the Windows App Store when most of the world’s developers are still trying to get a grasp of WinRT? 🙂

Of course I wanted to use an existing 3D engine, so I reviewed my options:

EngineStatus
Ogre 3D A user named Eugene on the Ogre forums already did all the work required fixing invalid API calls so Ogre compiles and validates on WinRT. This is what this post is about!
C4 Engine No word on WinRT/Metro support. C4 is based on OpenGL, but Windows App Store only allows Direct3D 11 to be used. I’ve seen someone on C4’s forums working on a Direct3D 11 renderer, so if its source is released, C4 users might get lucky.
Unity I believe Unity is well positioned for Metro support (they have an experimental Direct3D 11 renderer, I wouldn’t rule out porting Mono to WinRT either). No official statement yet and I’ll not risk betting on some kind of surprise. You can vote for Unity WinRT/Metro support here.
Axiom 3D Axiom 3D is a .NET rewrite of Ogre. Work on a SharpDX renderer is on its way, and SharpDX will support WinRT/Metro. Sadly, Axiom 3D is severely understaffed, thus, despite fantastic people like Borrillis, the massive size of the code base means it’s moving slowly.

Continue Reading →

How to Consume DLLs in a WinRT/Metro Project

Yesterday, I published a small guide on how to consume DLLs in Visual C++ that explained how to best integrate a third-party library into a Visual C++ project. This is a follow-up article for Visual Studio 11 Beta users that contains the additional steps required to consume a normal (non WinRT Component) DLL in a WinRT/Metro project.

Assuming you have the DLL integrated into a WinRT application project as explained in my previous blog post, you will notice that when you try to run the application, there will be an error message stating that the Windows Metro style application could not be activated and the output window will report a missing dependency:

Screenshot of Visual Studio 11 reporting an activation error on a WinRT/Metro application

Continue Reading →

How to Consume DLLs in Visual C++

For the C++ game programmer, there’s a huge collection of Open Source and commercial libraries available doing all kinds of things from simulating physics, reading common image formats or storing your data to rendering cutting-edge 3D graphics. But consuming those libraries in you own applications is often accompanied with a bit of hazzle since you need to point your linker to the right import libraries, copy the right DLLs into your project’s output directory and add the directory containing the matching headers to your compiler’s "include" directories.

It will get a little harder even when you target the Windows 8 App Store, where you need to provide binaries compiled for 3 platforms: x86, x64 and arm. I’ve been using C++ for over 10 years now and over time, I have come up with a method for organizing and consuming libraries that has served me very well.

Continue Reading →

IslandWar: Animating Turrets

Given that a lot of my game involves turrets attacking and defending, after setting up my water plane and a small height-mapped island in it, the next thing I attempted was to import an animated turret in a way that lets me control its orientation and elevation from code.

To start with, I already used a consistent naming scheme for the bones in all my turrets:

Screenshot of Blender showing my bone naming scheme

In short, all turrets have a bone to change their yaw that is called "Rotor". The pitch of the gun barrels is changed by "Elevators" (there can be more than one in case the turret has multiple weapon arms). Finally, each gun barrel has a bone whose name contains the word "Barrel", i.e. "UpperLeftBarrel" or "Barrel1" and an associated muzzle bone exists named identically but with "Muzzle" instead of "Barrel":

Continue Reading →

IslandWar in Unity

Logo of the Unity Engine

I decided to give an old project of mine another try. Back in 2007, after I finished my freeware game Ball Race, I ventured forth to create my first indie title, IslandWar. This is what gave rise to a lot of the classes that can now be found in my Nuclex Framework, including the GUI system that I originally wanted to avoid because I knew it would sidetrack me.

Well, combine some procrastination with a beginning burnout (at the end of 2009 I was certain that I never wanted to work with computers again) and the game was left on hold indefinitely. In the meantime, someone else even published an iPhone game by that title with a very similar concept, so that means I’ll have to find a new title if I ever publish this game.

Unity 3D Logo

Since I originally started working on IslandWar in XNA 1.0 Refresh, several XNA versions have come and gone and Unity, which I already reviewed favorably in 2007 has now gained Windows authoring support (it originally was MacOS-only) and sports a free basic edition. So given the choice between updating all of the game’s code to XNA 4.0 and SunBurn or porting it to Unity, I decided to give Unity a try.

So these are my first steps in Unity. Try not to laugh too hard 🙂

Continue Reading →

Windows 8 Consumer Preview

The new logo Microsoft uses for Windows 8

The Windows 8 Consumer Preview just went live. According to Microsoft, this is a stable public preview, not a beta.

Windows 8 Logo

I’m still in the process of downloading it, but in a presentation, Microsoft claimed a large number of changes since the Windows 8 Developer Preview last years.

Oh, and all apps in the Windows Store will be free until Windows 8 is officially released in October.

Download Links

Windows 8 Consumer Preview

Visual Studio 11 Beta for Windows 8 Consumer Preview

Continue Reading →

Moving to WordPress

The WordPress logo, a W in a circle over the text WordPress using small caps

After running Drupal for 3 years, then Joomla for another 3 years, I have now moved my website to WordPress — after almost picking Drupal again. So here’s the obligatory write-up of my experiences, why I switched and where I think the problems lie in those three CMSs.

Drupal

In August 2006, after trying about a dozen CMSs, I went live with my website built on Drupal. It promised the greatest flexibility and had a very active community with countless free plugins.

The Drupal logo, a blue water drop with a face, the eyes forming an infinity sign

I was happy with that, for a time. Drupal enabled me to define my own category trees, article types and mix WYSIWYG editors with filters for highlighting code, disarming HTML code in posts and letting users write comments.

Continue Reading →

McMyAdmin as Daemon on Linux

I’m pretty sure that by now, everyone reading this blog has heard of or probably even played Minecraft himself. It’s a sweet little game that tosses you into a simplified world that you can freely (and easily!) shape in any way you want. Your tasks: feed yourself, keep monsters out of your buildings and build something remarkable.

A screenshot of the game Minecraft

Minecraft can, of course, be played with any number of players online. All you need is a server with shell access and Java on it. If you also have Mono on your server, you can use McMyAdmin, a very convenient web frontend for the Minecraft server to manage users and perform automated backups.

Continue Reading →

NHibernate

In spring this year, I began work on a moderately sized business application. The time from learning what the program should do to the first prototype were less than 2 weeks. To pull it off, I basically ditched any sane development practice and started throwing code at the problem as fast as I could.

The application required a client/server model and the server had to store its data in a database. At that point in time, I knew about ORMs but had never used one before, but hoping for the best, I picked Microsoft’s Entity Framework because it had a visual designer and looked like I could just drag & drop my data model together and then figure out how to perform queries.

The NHibernate logo, a rolled-up (hibernating) squirrel

It fell flat when I noticed that I could only choose between TPT (Table Per Type) and TPH (Table Per Hierarchy) globally for the whole freakin’ model. So I tried NHibernate and quickly rebounded due to its learning curve, resorting to writing SQL queries myself and loading them into objects with a very basic class mapper that I had written for another, much smaller project some time ago.

It was tedious work, but at least hacking away for two hours got you two hours further, not one step forward and two steps back figuring out the ORM. And so I managed to get the prototype done with two all-nighters. In autumn, when the heat was off, I decided to do the database properly, using NHibernate…

Continue Reading →