I just found out yesterday that the major NGP project we were working on has now been canned by Sony…
All the hard work we’ve been putting in over the past several months to get the game ready for it’s big E3 debut was all in vein…
& even though I still have a job I can’t help but feel bad for all the talented young men & women who have been let go as a result of this…

I know this kind of thing happens all the time in the games industry but it just sucks so bad when it finally happens to you & your left wondering whether the complete lack of developer stability & job security really makes this worth it in the long term… I wanna have a family someday too…

All I can do is pray for all those who got let go, that they can hopefully find something better & (knowing how small this industry really is) rest on the knowledge that we’ll probably work together again sometime in the future…

Wish you all the best guys…

In this post I’m  going to be dealing with the subject of modern graphics development & a topic that alot of studios probably do but likely don’t tell anyone how they do it (in detail)…

In modern day console hardware we generally find that dynamic branching sucks..
This generally wouldn’t be a problem outside of the fact that sometimes when trying to maintain a well structured and organised shader library for your game, should you choose to go the uber shader route, you generally need to use some form of branches or switches to determine which features of the shader are used by each model material.
In an ideal world we’d just stick a load of “if” statements in the shader code (like we do in most modern HLLs) and walk away, however the apparent cost of these simple branches on a piece of hardware thats built for maximising data throughput, can easily render our efforts prohibitively crippled performance-wise…

So what’s the solution?

In short, static branch removal…

Now those of you who are familiar with uber shaders will know exactly what this is however for the rest of you who don’t I’ll try to explain..
The aim is to mitigate the cost of dynamic branches in your uber shader by effectively trading computation time for memory. This is done by simply compiling your shader multiple times, with each “permutation” defined by turning on or off various parts of/features in the code. These collections of shaders can then be used at run time so when a material is set to be rendered it chooses the correct permutation it needs & runs that. This method provides the benefit of both maintaining the centralisation of code of the uber shader paradigm whilst providing a necessary means of significantly simplifying the compiled code for materials that only use a subset of the uber shader’s featureset.

Sounds easy right?

Not so much in reality as it can take some careful planning and, depending on the shader asset pipeline for your game, may be much harder to engineer and integrate than initially perceived.
As far as the core implementation goes however, there are various approaches that can be taken in order to do this and since branch removal is performed as a pre-process before compilation, it can be done in any number of ways. The most flexible approach would probably be in setting up a tool that parses the shader source and locates branches on literal “if” statements on any feature switch/bool shader constant of interest, generating duplicate sources of the code with and without the conditional-code-to-be-executed present or not. This is however a very complex task & not one I’d advice anyone to attempt as it would take a lot of work to get the parsing code robust enough to be useable in the real world.
The alternative however is to get the compiler to do it for you by replacing branches of interest in the code with special macros defined which enable you to configure at compile time the code that is and isn’t present in the shader.
In general I’ve performed this step by doing the following:-

• In the shader or a shader header file the preprocessor checks if a macro to define branch removal macros (brms) is defined & if not, defines it setting it to false (e.g. think #ifndef DEFINE_BRANCHREMOVALMACROS  #define DEFINE_BRANCHREMOVALMACROS=0 etc..)
• If your brm’s define macro is set to false, define your brms to resolve to bog standard “if” statements (this allows an environment that’s not setup to deal with your branch removal system to still be able to compile and run your shader, useful if your artists are using it directly for visualising materials in Maya or FXComposer for example..) otherwise resolve them to a special case “if” statement where your condition is now a compiler input macro
• During branch removal the compiler is setup and the brm’s define macro is set as a compiler macro define input as well as a list of branch condition input macros which resolve directly to either true or false depending on the current permutation you wish to generate
• The compiler is then run multiple times with each run modifying the values of the branch condition input macros in order to generate different code for each permutation. This works as each branch condition now resolves fully to either “if( true )” or “if( false )” by the compiler, which will then proceed to optimise out/in code, mitigating the generation of any branch instructions in the compiled binary

In order to do this your system still needs to be able to somehow analyse the shader source code and identify all the dynamic branch bools/switches used in the vertex and pixel programs as it’s these bools/switches you’ll be replacing with your macros when the time comes to compile. If your shaders are strictly Cg, NVIDIA provides a Cg API that allows you to quickly and conveniently interrogate your shaders in this way in order to retrieve the information needed.

Once you’ve compiled your list of switches you’ll need to categorise and tag your permutations so that you can identify what configuration of these bools each permutation represents. This will allow you to select the correct shader permutation at run-time for each material by matching the permutation’s switch configuration tag against that of the correct shader binary, probably via some sort of hashing setup.
In the implementation I did, I used a 16-bit bitmask to represent the hashkey for each configuration of the uber shader where each bool was added into a switch-table (made up of a bit shift position and id pair) & each one represented a single bit in the mask. This meant that no uber shader could define anymore than 16 switches however, given that the total number of permutations for any given shader program  is 2^n (where n = number of switches), I figured trying to generate more than 2^16 or 65,536 possible permutations would be undesirable at best (both in terms of run-time memory overhead and compilation-time).
Also one of the benefits of using the 16-bit bitmask key was that the algorithm for generating the switch values for compiling the shader programs was simple as I could simply iterate from 0 to the maximum number of configurations of my shader, with each iteration simply taking the iterator index value, treating it as a bit mask and using those values to set each branch condition input macro values (e.g. MYMACROSWITCH=true or false).

Once you’ve got this far the only thing left to do is re-wire your run-time to load each group of permutations in-place of the old, single shader & during render setup, as each material sets the values of the bools to configure the shader for use, the system internally takes each bool, searches the switch-table for the corresponding bit in the current active config mask and sets the bit to the value of the bool for the material. Then when it comes to render with the material, the current active config mask is used to index into the hash structure of shader program permutations to select the correct one for use…

That’s about it folks!

Not the most straight-forward  system to engineer however a little patience, thought and proper code design can go along way into helping you put something together thats both robust and scalable.
Other factors to note also are generally related to the memory-footprint of the system and with so many permutations of each shader, you can quickly end up in a situation where it’s easy to run out of memory if you’re not careful. There are however steps that can be taken to reduce the memory load however these require a much more analytical approach as they’re generally much more specific to the needs of your team/game/engine (i.e. stripping permutations of shaders you know will never be used either because they don’t logically make sense given the semantics of the switches themselves, or because they’re known to never get assigned for use at run-time, if material parameters never change for example…)

For more details on this however you’ll probably want to check out an awesome tri-ace GDC presentation [here].

That’s all from me for now…

Hope this post has been useful and insightful…

More to come in future

- The Hog

First time out in San Fran too which is a great bonus. After arriving on Saturday and spending a couple of days recovering from jet lag & getting accustomed to the surroundings we finally made it to the main conference sessions today. Had a couple of seminars; one from Blizzard on performance & optimizations, one from Epic on building (or rather decorating) procedural buildings & a couple on asset management systems (which were reassuring in that they kinda validated the way we’re handling it at Curve). Tried to make it to the Sony motion controller (i.e. Playstation Move) seminar but it was packed (seriously! waaaay too many students this year…) but we did manage to have a wander around the expo & check out some cool stuff from:-

- God of War III (looked amazing)
- Live demonstrations of the Playstation Move technology (seems very accurate & responsive which is encouraging)
- Nvidia & Sony 3D stereoscopic games (tech works quite well…)
- etc etc

All in all a rather packed out day & more to come tomorrow & Saturday…

Looking forward to it…

Well it turns out xcode doesn’t have any native support for this (good ol’ xcode) but they do provide a plug-in system for you to write your own custom data formatters. So I had a trudge through the relevant site &, using the sample formatter bundles they provide, tried to put a unsigned short* string formatter together..

Except I couldn’t get it to work..

Every attempt I made at trying to get xcode to register the formatter & format my data in the debugger window failed miserably. I was initially planning on writing a tutorial on this too but after several attempts I gave up & decided to move on..

If I get a bit of time though I’d like to revisit this and try & get it to work so I can put together a tutorial on what I did and how to overcome the gotcha’s I had to overcome. So watch this space I guess..

In the meantime if anyone else has had any experience withthis stuff & wants to leave a few comments then that would be cool..

- The Hog

& what better way to do so then beginning a new series on iPhone development. Over the next few months I’ll try to keep the blog up to date with useful tips & tricks I’ve picked up along the way. Hope it helps someone out!!

DEBUGGING TIPS

After wrestling furiously with xcode over the past several months I bumped into a few useful tid-bits that might help with debugging. I would like to vent about the god-awful nature of the IDE & how much it makes me want to boil a pet in anger but I wont. I will say one thing though; boy have I learnt to appreciate the joys of Visual Studio & programming in a Windows environment (VS2008 + Visual Assist + RockScroll = WIN). Now to the topic at hand:-

“EXC_BAD_ACCESS” Debugging

I ran into one of these babies recently & after surfing the net for some info on the subject it looks like it’s the result of a signal sent from an active thread which hung on trying to release memory that has already been released (or something like that..). Now the great thing about this error is you don’t get any call stack or console output to tell you where things when kabloom but thankfully there are a few things you can try to in order to isolate the problem..

• Good ‘ol process of elimination - whittle down the last several code changes you made until you can home-in on the section of code that’s causing the problems. Not a great solution I know.. That’s why you should really try the next options:-
• Set the NSZombieEnabled environment variable (with the value of “YES”) in your executable –  this will leave dummy object references around so when the system dies you can get a useful stack trace to the problem. You can set this by right clicking on your executable and navigating to the “Arguements” section of the “Get Info” page. Use the plus icon to add a new environment variable & set the value accordingly. Also make sure the check box is ticked so that it’s active when you deploy. Personally I’ve found that this works fine provided the problem lives somewhere in your Obj-C code using any of the Cocoa frameworks but for me, the first time I encountered this issue it was hiding somewhere in my own C++ library code & thus I ended up trying the next solution:-
• Use Guard Malloc – This is a great little option that can catch invalid access crashes immediately as they occur but bear in mind it WILL slow down your application considerably when used. You can enable/disable it in the Run menu for xcode & then just run the app, get it to crash & it’ll take you directly to the call stack item which killed your flOw. Just make sure to disable it when you’re done otherwise you’ll end up worrying about where all that performance went..

Hope some of these tid-bits can be of use to someone & I’ll be posting more useful stabs of info as I continue my adventures in the land of iPhone development hades..

- The Hog

The days have been pretty busy of late having been moved into the core engine team at my current studio and spending a vast amount of time learning what it takes to make a next-gen multi-platform engine tick and writing everything from particle editors to flash native rendering systems and more.

It is however time to get back into imparting some of the things i’ve learned & so stay tuned for some more (hopefully) useful tutorials soon..

- The Hog

Before we begin I’d just like to make a note that I’m going to be using C# for all my examples considering this blog are generally c#/XNA-centric (however i’m pretty sure the same functions for the modulus operator can be applied in C/C++ & most other languages)..

So What Is The Ol’ Mod..?

The Modulus operator (sometimes termed ‘Modulo‘ in computing fields) defines an operation which returns the remainder of a division of one number by another. So for example if we take the any dividend ‘a’, & a divisor ‘n’ then we can define a % n (a modulo n) as the remainder.

So if we have 7 % 3 then we look at it as an integer division of only the proportion of the numbers which can evaluate to a whole number. In this case we see that 7 / 3 doesn’t equal a whole number (equals 2.333) however 6/3 does (leaving no remainder) so to find the modulus of this expression we can treat 7 / 3 as 6/3 + remainder which tells us that the remainder is 1. Here’s a few more examples just to help you get your head around the idea:-

8 % 4 = 0
12 % 16 = 12

So a few rules to bear in mind which will help you use the operator in practice:-

1. if a / n equals a whole number then a % n  always equals 0
2. if a is less than n then a % n always equals a
3. if a is greater than n then a % n always equals a value between 1 and n-1

As we can see these three simple rules help put things into perspective & should now hopefully give us a really sound idea of some of the ways we can use the operator in practice.

Let’s Get To The Main Course Already..!

OK so now we’re ready to begin looking at some of the ways we can use the modulus operator & it’s unique properties for something useful. Here’s what I have so far:-

Wrap-Around & Looping Number Iteration

Sometimes in our travels we may need to iterate through an array in such a way that we can use an incremental index value that can be reset once it goes beyond the bounds of the array. Modulus is really useful for doing these tasks as, looking at rules 1, 2 & 3, we can see that it’s zero-based in nature & perfectly suited to this kind of ‘wrap-around’ processing. So where we would have once had something like this

// increment index & return the item in the array
i++;
if (i >= maxNumValues) i = 0;
return foo[i];

We can now substitute it for something like this

// increment index & return the item in the array
return foo[ (i++)  %  maxNumValues ];

Not a massive change but at least we’ve saved ourselves a few extra lines of code & removed the branch statement.

2D Coordinate Indexing

On several occasions i’ve found that I needed to index data in a 2D grid format. Whether it be indexing tiles on a spritesheet or onscreen items in a grid there’s generally a tendencies to define the data in a ‘flattened’ array format & make the grid-like behaviour implicit in it’s use. So say we have a sprite sheet containing a grid of tiled sprites of size d x d pixels and arranged in a grid of 4 x 4 tiles. if we treat the tiles as a 1D array of data then we can index each value from left-to-right, going from top-to-bottom starting at 0 and ending at 15 (4 x 4 -1 since it’s zero-based). in this case if we wanted to get the coordinates of a tile as say index = 9 we could do the following

• count up the indices from 0 to 9 & in each step:-
• add 1 to x & if x is greater than the number of tiles in a row then remove the number of tiles in a row from x & add one to y
• multiply x by the tileWidth & y by the tileHeight & return the two values

This will work if you use a while loop and branch statements but it will end up taking up several lines of code & could end up being overly complex. However if we use the modulus operator we can do it much quicker/cleaner

x = index % numTilesRow;
y = ( index – x ) / numTilesRow;
return new TileDims( x * tileW, y * tileH );

I added the struct TileDims just for illustration purposes but beyond that it’s a pretty neat & cheap solution. Also we can reverse this & retrieve the index from the coordinate values in a simple fashion

// return the index for x & y
return x + ( numTilesRow * y );

Detemining Odd or Even Numbers

We can use % to determine whether a number is odd or even by examining exactly what it is we mean by ‘odd’ & by ‘even’ first. by definition an odd number is any number that cannot divide into 2 (i.e. odd / 2 != wholeNum). With this in mind we can do a simple check for this

// odd number check
if ( num % 2 != 0)
// odd number..
else
// even number..

Simple to use but it can save alot of time trying to determine whether this is true using a brute force, iterative approach.
How Many 10s, 100s etc In A Decimal Value

Sometimes we may need to figure out how many 10s are in a number for example, which can be especially useful of you need to separate the digits of a number for rendering on multiple quads. Again the implementation is pretty simple

// find the number of 10s & 100s in num
tens = ( num – (num % 10) ) / 10;
hundrds = ( num – (num % 100) ) / 100;

So that’s it from me!

Please feel free to drop any comments you have & also I’d love to hear about any other neat little % tricks you’ve discovered during your own coding travels..!
- The Hog

Well ok I guess it isn’t all the time but no matter how bad things might get, you always get those instances (however brief) that things start looking up to the point where you start to wonder “Hmmm.. Many things might turn out OK after all..”

Take these past few months for instance,
I’ve been busy as a beaver organizing my wedding, knocking out PSP code for the current project at work & more importantly doing quite a bit of XNA development.
So it came as icing on the cake when MS recently announced their plans to monetize their Community Games platform launching this holiday. I’d always dreamed of shipping a nice little polished game for people the world over to enjoy & now it seems that not only can a little dedication & hard work secure my dreams coming true, but they may also net me a bit of pocket money in the process..

In such an exciting time it only helped both motivate and accelerate my drive to get the two XNA projects i’m working on out the door. Also I figure now would be as good a time as any to post a little progress on one of them:-

solace engine menu test

It’s a test render of the early menu system for the game. The design is essentially a dial mechanism (apologies for the not-so-l337-programmer-art..) that rotates persistently & all the menu options are procedurally distributed as label links around the screen. So far it’s fully functional (complete with transitions & floaty, turny dynamics..) & adding new menu screens are as easy as creating a new menu overlay object & adding strings for each menu element.

On the other side of the development field..

After a bit of a long break, me & rich have been working rigorously to get SMC into a state where it’s playable & it’s really coming along now. We’ll be posted some new updates on houseofsmash soon so don’t forget to look out for updates in the coming days/weeks..

P.S.

After developing the current engine (which I’m using on both my current projects) for over a year now it’s really been an interested ride for me that’s helped me to learn alot. I’m looking forward to taking the platform from strength to strength as development progresses & I have alot of plans for what I would like to do with it even after I complete (or bust) the two current projects..

Stay tuned for more soon!

- The Hog

So far I’ve got the character edit suite fully fleshed out & operational with only some minor tweaks needed going forward.. I’m currently working on the animation systems which I hope to share between the editor & the game & so hopefully once thats in & setup i’ll be able to slap up a couple of test animations & a character for when I start working on the game itself.. I’ll be looking to post some media soon so watch this space for more info.

Cheers!

Orbit is a 2D puzzle game I started working on one day when I was bored at work.. It really speaks something regarding the productivity of XNA as a development platform considering I got as far as this with only a few days of development time.. Then again I did have the benefit of using the engine i’ve been working on for SMC for the past several months and so I guess it did kind of make life alot easier. I guess it also says something about the flexibility of my little engine there too! The game is fairly simple so far & most of the basic functionality is there. The graphics are currently placeholder (since some of them were ripped from the inet…) & i’m sure as soon as I can find an artist I can redo them

Anyways now I finally gotaround to having the internet setup at home i’ll be getting back into SMC in full swing and then maybe if I get some free time I can finish off orbit too..

Until then!