Blind Renderer

Crazy Eye Pain & Headache = MSG Side Effects?

2012-02-12T23:35:00.000-08:00

This morning, I woke up with some crazy eye pain, headache and nausea and I had no clue what caused it. This is my 2nd time having these symptoms. The first one was sometime last year when I had to call in sick. I usually don't have headaches. Just this one is too strong for me to do any normal works: the only thing I can do is just to lie down and do nothing.

Once I got better around 11 PM, I did some web search and now I think it might be related to the high intake of MSG. According to this site, my symptoms are MSG side effects, and guess what? I went to a Chinese restaurant last night and ate a lot! Too bad, I don't remember what I ate last time I had this problem. If I remembered, I would be more certain. :)

Oh well, MSG can be unhealthy anyways, so I guess it's time to cut, or reduce, MSG out of my diet?

[WIP] Music: Out of Reach Intro

2012-02-10T09:00:00.000-08:00

This is something I wrote last night.. It's still intro to a song I, for now, call Out of Reach. I quite like it, so I might finish it one day.. yes one day...

For comments, use my Facebook (one-man) band page I guess?

TFSA over RRSP? Probably Not for Game Devs

2012-02-09T19:14:00.000-08:00

Image Source: http://chelleyc.uibcsites.com/files/2011/02/TFSA-vs-RRSP.jpg

Since TFSA is introduced a few years ago, there has been good debates on which one one should max out first between TFSA and RRSP. And nowadays, a lot of financial advisers seem to advise TFSA over RRSP.

I don't think so, at least for game developers, who tend to get easily laid off, thus forced to be out of the job, compared to people in other industries. (TFSA over RRSP might make sense for people in other industries, but I don't really care).

Okay, here is the deal. You can buy up to 18% of last year's income. Let's say you make $100,000 am year. (for easy calculation) If you don't buy RRSP, you will be taxed $25,454 in BC according to this online calculator whether you buy TFSA or not. But if you max out your RRSP($18,000) you will only be taxed $18,623. So $6,831 saving.

Sure, you pay tax when you withdraw the RRSP, but based on the income of the year when you make the withdrawal. That's what makes RRSP a better choice for game developers. Say, you get laid off next year and you are out of the job for 6 months. Then your income and tax will be $50,000 and $8,848. You think this is not enough money to pay all your bills. So you withdraw RRSP, $18,000. Then your income and tax become $68,000 and $14,194. It's $5,346 extra tax for you for that year.

Since you saved $6,831 last year, but paid $5,346 this year your overall saving is $1,485. If you had put $18,000 in TFSA, do you think you can make $1,485 / $18,000 = 8.25% return? Doubt it. So to me, RRSP is a better choice in this industry. Well, maybe you haven't laid off so far, but it can happen anytime even if you are super competent. Sometimes, companies have to lay off people to show investors they are doing something to turn around.

Lying Throughout Your Career

2012-02-07T20:08:00.000-08:00

There was someone who did (have to) leave my company recently. He is one of those people who have to jump around companies after short stays. Yeah, you know why. And today, I happened to read his blog post explaining why he was leaving. A lot of my co-workers enjoyed it because it reminded us of the Lord of the Rings, arguably the best fantasy fiction to date.

Image Source: http://images.wikia.com/lotr/images/9/9e/Smeagol.jpg

I am not going to point out all the lies because 'someone' desperately needs those to stay in this industry. I just suspect pretty soon 'someone' will have to find a job outside of this beautiful city, Vancouver, because he seems to be very well-known here. Furthermore, dealing with a possible defamation charge is not something I want to do at this moment although I'm pretty sure I would enjoy it because I'll win no matter what: my claim is not false, that is. (after all, I'm still a lawyer, hah!) Just it's a headache dealing with an idiot with no clue, but if anyone asks me personally, I wouldn't hesitate to tell him/her. I'm an honest guy and can't lie or hide anything.

Oh, speaking of lies, I know how to distinguish facts from opinions or judgement. That's one thing I was trained for really hard at my lawschool. For the same reason, I call him a liar for claiming false facts, not because of his out-of-mind judgement or opinions. But if he truly believes in what he claims, I guess he has absolutely no minimum required skillset to be an engineer, or this place will be his new home.

Animation Sharing between Different Characters with Same Topology in Unity

2012-02-04T11:39:00.000-08:00

Image Source: http://answers.unity3d.com/questions/191282/sharing-animations-between-models.html

So let's say you have multiple characters with different bone lengths, but you just don't have manpower to author different animations for all of them. Can we share animations, instead? Sure, why not, if you can live without transition and scale animations on joints: in other words, you are only gonna use rotations. Think it this way. When you rotate your right elbow inward by 90 degrees, your pose will look same as your shorter friend applying the exactly same rotation on his right elbow. Got it?

Okay, so I was searching Unity forum to see if rotation-only animation is officially supported. Didn't look like it. Then next up. Can we somehow trim out non-rotational info from an anim file in the pipeline? I was not able to find the answer again~~, or even anyone asking~~. (Sorry, after finishing this post, I actually found someone asking, but noone really answered.)

And the good news is....... -drum rolls- .... I figured it out! :D

So this is what I came up with and it works great: (code shown below)

Make a script called ConvertToRotationOnlyAnim.cs inside of Assets/Editor folder.
Add a menu item invoking this script.
Import your animation into Unity. (doesn't matter where it's from as long as Unity sees it as animation)
Right-click on the imported animation asset and select the menu item we just added at step #2.
In the Script, copy over only the curves which have "m_LocalRotation" as propertyName field.
Now set the new _rot animation clip to your game object's animation component.
Hit play and enjoy... :)

And here is the full source code I wrote for this. Hopefully the comment is self-explanatory:

using UnityEditor;

using UnityEngine;

using System.IO;

public class ConvertToRotationOnlyAnim

{

[MenuItem("Assets/Convert To Rotation Animation")]

static void ConvertToRotationAnimation()

{

// Get Selected Animation Clip

AnimationClip sourceClip = Selection.activeObject as AnimationClip;

if (sourceClip == null)

{

Debug.Log("Please select an animation clip");

return;

}

// Rotation only anim clip will have "_rot" post fix at the end

const string destPostfix = "_rot";

string sourcePath = AssetDatabase.GetAssetPath(sourceClip);

string destPath = Path.Combine(Path.GetDirectoryName(sourcePath), sourceClip.name) + destPostfix + ".anim";

// first try to open existing clip to avoid losing reference to this animation from other meshes that are already using it.

AnimationClip destClip = AssetDatabase.LoadAssetAtPath(destPath, typeof(AnimationClip)) as AnimationClip;

if (destClip == null)

{

// existing clip not found. Let's create a new one

Debug.Log("creating a new rotation only animation at " + destPath);

destClip = new AnimationClip();

destClip.name = sourceClip.name + destPostfix;

AssetDatabase.CreateAsset(destClip, destPath);

AssetDatabase.Refresh();

// and let's load it back, just to make sure it's created?

destClip = AssetDatabase.LoadAssetAtPath(destPath, typeof(AnimationClip)) as AnimationClip;

}

if (destClip == null)

{

Debug.Log("cannot create/open the rotation only anim at " + destPath);

return;

}

// clear all the existing curves from destination.

destClip.ClearCurves();

// Now copy only rotation curves

AnimationClipCurveData[] curveDatas = AnimationUtility.GetAllCurves(sourceClip, true);

foreach (AnimationClipCurveData curveData in curveDatas)

{

if (curveData.propertyName.Contains("m_LocalRotation"))

{

AnimationUtility.SetEditorCurve(

destClip,

curveData.path,

curveData.type,

curveData.propertyName,

curveData.curve

);

}

Debug.Log("Hooray! Coverting to rotation-only anim to " + destClip.name + " is done");

}

"Fix" for ESC Not Working While Photoshop CS3 is Open

2012-01-31T18:56:00.000-08:00

So I have had this problem where ESC stops working globally while Adobe Photoshop CS3 is open for a few years. CS5 doesn't suffer from this problem, but getting upgrade to CS5 was not easy because CS3 was the version we were using for Space Marine.

So finally I spent some time to find a "fix": it was quite simple.. just open the task manager and kill ccc.exe (it's ATI control panel... so I don't give a shit). Now re-launching CS3 solved the problem. Yay.

Then I ran msconfig from Windows + Run, and then disabled CCC from launching when my machine starts up. If I need to use CCC, I'll manually launch it. I barely use it anyways, so not a big deal.

Compile-Time Hash String Generation

2012-01-11T21:00:00.000-08:00

Motivation
Recently, I worked on a code-base where everything was referenced by strings. It was quite expensive as you can imagine, so to avoid the cost of string comparison, hash values(ints) were used. This system had a giant hash string registry, which generates a hash value and stores both the hash and actual strings whenever the code sees a new string, well all during run-time.

I personally did not enjoy this system for a number of reasons:

it takes up too much memory

almost 90% of those strings were never really used as real char * string representation
they were simply just look-up keys
so no need to store actual string representations: just hash values were enough
then we can generate hash values offline

hash string registry was quite slow to be multithread-safe. New strings can be registered by any thread, so we had to have a locking mechanism, which turned out to be a bottle neck time to time
strings in the executable or data files are easy to read by anyone with a hex editor. Maybe it makes attackers' life a bit easier?

So I thought of doing something better...... (as follows)

We Need Two Different String Types

I think we should adopt two different ways of handling strings for those 90% and 10%.

1. Pure char* String (10%)

Any string that needs actual string representations should be in this format:

filenames that the game needs to load sometime (unless your filenames are hashed, too. If you wanna go nuts sure.. but I think it's too extreme)
any string that needs to be printed out on the screen. You really don't want your users to read some hex number like 0xFFFFF, 0x888888 or 0x000000, right? (looking at the picture below.. I think it might be okay... lol)

Image Source: icanhascheeszburger.com

Since they would be only 10% of the string for most games, probably you can just do strcmp() on them instead of generating and storing hash values for them. But if you really insist, you can still do the similar thing to what our hash string manger used to do. (still better than having 10 times more strings stored on memory)

2. Hash-Valued String (90%)

So all the other strings, of which char* representations are never used, will be just a simple hash value, an int. A good example is any strings

only used for comparison
only used as look-up key

#1(pure char* string) is very straight forward, so from now on I'll only focus on #2(Hash-Valued String) in this post.

Choosing a Good Hash Function: x65599

We all know what hash function is. Just in case you don't, it's just a function that will "hopefully" generate unique integer values for different strings. (I said "hopefully" because there is chance to have a same vale for tow different strings: we call it hash collision.) Once you have a unique hash value for each strings, you can simply compare two strings by those hash values instead of comparing every single characters in them What you get out of this? It's faster and simpler.

Then how do you generate a unique hash value for each string? Well, there a lot of different hash functions. Some have less collisions while the others have more. Some are faster while the others are slow. You can choose whatever based on your need. For me, a hash function for game should:

have near-zero collision
versatile enough to be used as run-time function: you will possibly need to concatenate strings and then generate hash value to compare in your game
be fast enough to be used in game

I did some research and found this amazing comparison chart by Chris Savoie, and I decided the best one for me is x65599. (Also I liked the name quite a lot. Anything that starts with X = a badass )

I also looked into the implementation (shown below). It's simple. You keep multiplying 65599. A-Ha! that's why it's called x65599 :D

// A hash function with multiplier 65599 (from Red Dragon book)

unsigned int generateHash(const char *string, size_t len)

{

unsigned int hash = 0;

for(size_t i = 0; i < len; ++i)

{

hash = 65599 * hash + string[i];

}

return hash ^ (hash >> 16);

}

Alright, now I picked the hash function. Let's move onto what to do in tools-side and code-side.

Saving Data from Tools

If there is any tool that used to save useless char* values into the game data, it's time to change it to save out a hash value, instead. It's simple. Just call that function from your tool (or implement same function if the tools use different language from your game).

Simply done. Moving onto in-game code.

Generating Compile-time Hash Value in Code

Alright let's say, I want to find a bone named "funny_bone". I would usually write a code like this:

bones.find("funny_bone");

but now the tools export a hash value for this string, so I have to write something like this:

const char * boneToFind = "funny_bone";

bones.find( generateHash(boneToFind, strlen(boneToFind) );

Sure, it would work. But wouldn't the string "funny_bone" into our executable? If so, it will use the same or more amount of memory than our old string registry. But this string is a const string, and compiler "might" know about it. Can we make sure the compiler does all the necessary computation during compile time and somehow magically spits out assembly code equivalent to this?

// yup 0XF1C66FD7F is the real hash value for "funny_bone"

bones.find( 0xF1C6FD7F );

I think we can if these two things can happen:

inlining the hash function: if compiler choose to not inline the hash function, there is no way it can calculate an int value during the compile-time. So this is a must. inline keyword is kinda a guideline on most compilers, but I don't think it's a hard thing to achieve.
unrolling the hash loop: we are dealing with constant length string, so if we have a way to tell compiler to unroll this and do all the calculation during compile-time, it would work.

Help Inlining generateHash(const char *, size_t)

First off, I want to make sure the implementation of generateHash(const char*, size_t) function is available for inlining when the compiler compiles the code. Also I want to allow programmers to use a simple macro without calling strlen(const char *) specifically. So I decided to add a define like this:

#define HASH_STRING(str) generateHash(str, strlen(str));

With this, my hash.h looks like this:

// compiile-time hash string test

// author: Pope Kim (www.popekim.com)

#include <string.h>

#define HASH_STRING(str) generateHash(str, strlen(str));

// A hash function with multiplier 65599 (from Red Dragon book).

// we put this implementation into header file so that compiler can

// always inline it.

inline unsigned int generateHash(const char *string, size_t len)

{

unsigned int hash = 0;

for(size_t i = 0; i < len; ++i)

{

hash = 65599 * hash + string[i];

}

return hash ^ (hash >> 16);

}

Test Code

Now I made a test code to see if different compilers and optimization options can flat down HASH_STRING(str) into a single integer value in compile-time.

This is my main.cpp:

// compiile-time hash string test

// author: Pope Kim (www.popekim.com)

#include <stdio.h>

#include "hash.h"

int main(int args, char** argv)

{

unsigned int hashValue = HASH_STRING("funny_bone");

printf("hash value is 0x%8x\n", hashValue);

return 0;

}

Now, let's see if the compilers do a good job on this.

With Visual Studio 2010 SP1

I've created a quick win32 console application project and tested it with different optimization flag. This is what I did.

Change project configuration to Release
To output assembly file, I went to Project Properties > C/C++ > Output Files > Assembler Output, and chose Assembly-Only Listing (/FA)
Then to test different optimization flag, I went to Project Properties > C/C++ > Optimization and compiled with the following settings:

Disabled (/Od)

Two findings:

generateHash() function call is not inlined, as expected
interestingly, strlen() is optimized: look at push 10

_main PROC ; COMDAT

; File e:\temp\x65599\x65599\main.cpp

; Line 11

push ebp

mov ebp, esp

push ecx

; Line 12

push 10 ; 0000000aH

push OFFSET $SG-5

call ?generateHash@@YAIPBDI@Z ; generateHash

add esp, 8

mov DWORD PTR _hashValue$[ebp], eax

; Line 13

mov eax, DWORD PTR _hashValue$[ebp]

push eax

push OFFSET $SG-6

call DWORD PTR __imp__printf

add esp, 8

; Line 15

xor eax, eax

; Line 16

mov esp, ebp

pop ebp

ret 0

_main ENDP

Minimize Size(/O1)

same as disabled, but the function call is inlined at least.

_main PROC ; COMDAT

; File e:\temp\x65599\x65599\main.cpp

; Line 12

xor ecx, ecx

xor eax, eax

$LL5@main:

movsx edx, BYTE PTR ??_C@_0L@DDOFCBGB@funny_bone?$AA@[eax]

imul ecx, 65599 ; 0001003fH

add ecx, edx

inc eax

cmp eax, 10 ; 0000000aH

jb SHORT $LL5@main

mov eax, ecx

shr eax, 16 ; 00000010H

xor eax, ecx

; Line 13

push eax

push OFFSET ??_C@_0BF@DJEFNLLJ@hash?5value?5is?50x?$CF8x?6?$AA@

call DWORD PTR __imp__printf

pop ecx

; Line 15

xor eax, eax

; Line 16

ret 0

_main ENDP

Maximize Speed(/O2)

You see the first line? push -238617217 which is 0xF1C6FDF? IT IS ALL FLATTENED DOWN TO AN INT!

; Line 13

push -238617217 ; f1c6fd7fH

push OFFSET ??_C@_0BF@DJEFNLLJ@hash?5value?5is?50x?$CF8x?6?$AA@

call DWORD PTR __imp__printf

add esp, 8

; Line 15

xor eax, eax

; Line 16

ret 0

_main ENDP

So I opened the resulting .exe file in a text editor to see if there's any string named "funny_bone". And I couldn't find any! YAY!

Full Optimization(/Ox)

Walla! again!

_main PROC ; COMDAT

; File e:\temp\x65599\x65599\main.cpp

; Line 13

push -238617217 ; f1c6fd7fH

push OFFSET $SG-6

call DWORD PTR __imp__printf

add esp, 8

; Line 15

xor eax, eax

; Line 16

ret 0

_main ENDP

But when I searched "funny_bone" in the exe file...

WTF? Why are you there, funny_bone?

Seriously? Full Optimization option doesn't strip unused strings? To be sure I tested with another simple program, but the result was same. Even this very simple string doesn't get stripped out with this compiler option.

void idiot()
{
const char* idiot = "OMG";
}

I talked to this to Karl, and he found String Pooling option is off for /Ox by default while it is on for both /O1 and /O2. Strange eh? As soon as I enabled C/C++ > Code Generation > Enable String Polling the string disappeared. YAY!

With G++

How can I finish a test without trying G++? I used G++ 4.5.3 to test this with this compiler flags:

g++ *.cpp -pedantic -Wall -S <optimization-flag>

Note that -S flag is to stop generating after assembler

-O0

-O0 flag means no optimization pretty much, so i didn't expect anything. Still strlen() function seems to be converted to 10, at least.

LFE4:

.def ___main; .scl 2; .type 32; .endef

.section .rdata,"dr"

LC0:

.ascii "funny_bone\0"

LC1:

.ascii "hash value is 0x%8x\12\0"

.text

.globl _main

.def _main; .scl 2; .type 32; .endef

_main:

LFB5:

pushl %ebp

LCFI4:

movl %esp, %ebp

LCFI5:

andl $-16, %esp

LCFI6:

subl $32, %esp

LCFI7:

call ___main

movl $10, 4(%esp)

movl $LC0, (%esp)

call __Z12generateHashPKcj

movl %eax, 28(%esp)

movl 28(%esp), %eax

movl %eax, 4(%esp)

movl $LC1, (%esp)

call _printf

movl $0, %eax

leave

LCFI8:

ret

-O1

now generateHash() function is inlined too. But still doing all the calculation.

.def ___main; .scl 2; .type 32; .endef

.section .rdata,"dr"

LC0:

.ascii "funny_bone\0"

LC1:

.ascii "hash value is 0x%8x\12\0"

.text

.globl _main

.def _main; .scl 2; .type 32; .endef

_main:

LFB5:

pushl %ebp

LCFI0:

movl %esp, %ebp

LCFI1:

andl $-16, %esp

LCFI2:

pushl %ebx

LCFI3:

subl $28, %esp

LCFI4:

call ___main

movl $LC0, %eax

movl $LC0+10, %ebx

movl $0, %edx

L2:

imull $65599, %edx, %edx

movsbl (%eax), %ecx

addl %ecx, %edx

addl $1, %eax

cmpl %ebx, %eax

jne L2

movl %edx, %eax

shrl $16, %eax

xorl %eax, %edx

movl %edx, 4(%esp)

movl $LC1, (%esp)

call _printf

movl $0, %eax

addl $28, %esp

popl %ebx

LCFI5:

movl %ebp, %esp

LCFI6:

popl %ebp

LCFI7:

ret

-O2

Same as -O1. Of course, loop unroll optimization is only enabled with -O3.

.def ___main; .scl 2; .type 32; .endef

.section .rdata,"dr"

LC0:

.ascii "funny_bone\0"

LC1:

.ascii "hash value is 0x%8x\12\0"

.text

.p2align 4,,15

.globl _main

.def _main; .scl 2; .type 32; .endef

_main:

LFB5:

pushl %ebp

LCFI0:

movl %esp, %ebp

LCFI1:

andl $-16, %esp

LCFI2:

subl $16, %esp

LCFI3:

call ___main

movl $LC0, %eax

xorl %edx, %edx

.p2align 4,,7

L2:

imull $65599, %edx, %edx

movsbl (%eax), %ecx

addl $1, %eax

addl %ecx, %edx

cmpl $LC0+10, %eax

jne L2

movl %edx, %eax

shrl $16, %eax

xorl %edx, %eax

movl %eax, 4(%esp)

movl $LC1, (%esp)

call _printf

xorl %eax, %eax

leave

LCFI4:

ret

Also I tried to search the string in the exe file, but it was not there.. YAY!

-O3

Finally... Seeing movl $-238617217, 4(%esp)? It's flattened down!

.def ___main; .scl 2; .type 32; .endef

.section .rdata,"dr"

LC0:

.ascii "hash value is 0x%8x\12\0"

.text

.p2align 4,,15

.globl _main

.def _main; .scl 2; .type 32; .endef

_main:

LFB5:

pushl %ebp

LCFI0:

movl %esp, %ebp

LCFI1:

andl $-16, %esp

LCFI2:

subl $16, %esp

LCFI3:

call ___main

movl $-238617217, 4(%esp)

movl $LC0, (%esp)

call _printf

xorl %eax, %eax

leave

LCFI4:

ret

-Os

-Os stands for size. And it didn't do good :(

LFE4:

.def ___main; .scl 2; .type 32; .endef

.section .rdata,"dr"

LC0:

.ascii "funny_bone\0"

LC1:

.ascii "hash value is 0x%8x\12\0"

.text

.globl _main

.def _main; .scl 2; .type 32; .endef

_main:

LFB5:

pushl %ebp

LCFI7:

movl %esp, %ebp

LCFI8:

andl $-16, %esp

LCFI9:

subl $16, %esp

LCFI10:

call ___main

movl $10, 4(%esp)

movl $LC0, (%esp)

call __Z12generateHashPKcj

movl $LC1, (%esp)

movl %eax, 4(%esp)

call _printf

xorl %eax, %eax

leave

LCFI11:

ret

Quick Summary

So let me quickly summarize which optimization flags you should use for VS 2010 SP1 and G++ to use this amazing(maybe a bit stupid if you are cynical :P) trick.

Visual Studio 2010 SP1

/O2
/Ox with Enable String Pooling on

G++ 4.5.3

Debugging

Alright. It's good we removed the string representations from code. The size of the executable is smaller, but it's horrible for debugging. When I got a crash on a bone "named" 0xF1C6FD7F, how do I know which bone I have to look at in 3DS Max? ARRGHH.. Okay, so apparently we really need char* string for at least debugging!

So should I revert everything I did so far? I don't want to. :) This data is only useful for debugging, so I should devise a way of debugging it without affecting the disc build. Actually, it is a very easy problem. I just need a string database, which has both pairs of <hash key, char*> for all the strings saved out from the data baking tools and used in our code.

Generating Debug String Database

In what format, should I store our string database? Using a light-weight SQL DB file is definitely an option. What about SQL-lite? I heard good things about it. Or I can simply outputs a list of pairs of <int, char*> values into a text file. I would probably choose a plain text file, or compressed text file, to make it easier to load the file in C++ codebase. Whatever it is, the filename will be debug.string_db.

Saving Debug String DB from Tools

So now I just need to change my tools to open debug.string_db file and insert any new string entries into this while it's saving game-ready data.

Very simply done!

Saving Debug String DB from Codebase

Then what do we do with the strings in the code? Luckily enough, I defined HASH_STRING("") macro. I can just write a C# or python script searching through all the text files in my codebase to find any char* strings wrapped by that macro. Regular expression? sure. Then I would run same hash generation code to get the hash key, and write this into debug.string_db file.

Not very simple. But easy and fast enough.... done!

Looking Up String Values

So now the question is how we can easily find what string it is while we are in Visual Studio.

String Lookup Tool

Do you remember using DirectX Error Lookup tool that comes with DirectX SDK? It looks like this:

Maybe I can write a tool like this. This tool would simply open debug.string_db file and find any hash value I type in. Yeah I can just copy and paste the hash value from Visual Studio Watch window into this. Yup, it's a bit annoying but it's easy to make.

Visual Studio Plug-in?

Next thought I have is something I'm not sure if it's possible because I don't know too much about making a Visual Studio plug-in.

If a Visual Studio plug-in is allowed to read a text file(or a SQL DB) and modifies what shows up in Watch window, maybe I can do this. It's just something I need to take some time and see if it's possible.. I haven't done it so far. I think I'll be fine with the string lookup tool for now

In-Game Hash/String Registry

Or I can make a debug-only hash/string registry, which simply loads debug.string_db file. Then anyone can find out the actual string representation easily in the code. This will be only available on debug build, and the loading code will simply disappear in the disc build.

Maybe I'm Crazy But

While I was thinking about the last option for looking up string values, I found this is actually very close to how the localization database works. You have a string id(key) and the value of the given language. If you want to swap to different language you will just load different localization database file. In the files, all the keys are same as before, just the string values are different.

So, if one decides to implement the in-game hash/string registry option for debugging, maybe he can use the same architecture for localization? I don't know too much about localization database, so I might be just being stupid. I just had this crazy idea. heh =)

One BIG Problem, Though
I was excited for a while. Then Noel, my buddie and one of the best programmers I've met in this industry, asked me if the loop unroll works if it the string length is longer. So I did a quick test.

With Visual Studio 2010 SP1
I found Visual Studio 2010 SP1 works only up to 10 characters. This is the result I got when I used 11 character-long string "funny_bone1".

_main PROC ; COMDAT

; File e:\temp\x65599\main.cpp
; Line 12
xor ecx, ecx
xor eax, eax
npad 12
$LL5@main:
movsx edx, BYTE PTR $SG-5[eax]
imul ecx, 65599 ; 0001003fH
inc eax
add ecx, edx
cmp eax, 11 ; 0000000bH
jb SHORT $LL5@main
mov eax, ecx
shr eax, 16 ; 00000010H
xor eax, ecx
; Line 13
push eax
push OFFSET $SG-6
call DWORD PTR __imp__printf
add esp, 8
; Line 15
xor eax, eax
; Line 16
ret 0
_main ENDP

With G++
G++ did a better job. G++ works up to 17 characters. This is the result I got when i used 18 character-long string "funny_bone12345678"

.def _main; .scl 2; .type 32; .endef
_main:
LFB5:
pushl %ebp
LCFI0:
movl %esp, %ebp
LCFI1:
andl $-16, %esp
LCFI2:
subl $16, %esp
LCFI3:
call ___main
movl $LC0, %eax
xorl %edx, %edx
.p2align 4,,7
L2:
imull $65599, %edx, %edx
movsbl (%eax), %ecx
addl $1, %eax
addl %ecx, %edx
cmpl $LC0+18, %eax
jne L2
movl %edx, %eax
shrl $16, %eax
xorl %edx, %eax
movl %eax, 4(%esp)
movl $LC1, (%esp)
call _printf
xorl %eax, %eax
leave
LCFI4:
ret

What Does This Mean?
This means it will optimize strings with length equal to or less than 10 or 17 depending on your compilers. For other strings, it'll do all the calculation during run-time. Is it still worth it? I think so. You will just need to follow this guideline:

if possible, keep look-up key strings short
don't call HASH_STRING() macro multiple times on a same string. In other words, cache the hash value somewhere(e.g, as a member variable of an object)

Also there's a chance that future compilers do a better job at unrolling this. Up to 64 characters would be nice. (Unfortunately, VS 2011 Preview doesn't do any better job....)

Or constexpr from C++11 can be used for this one day? It's not even being supported by VS 2011 Preview... so whateva......

The best solution would be a compiler switch like this:

inline unsigned int generateHash(const char *string, size_t len)
{

unsigned int hash = 0;

#pragma unroll

for(size_t i = 0; i < len; ++i)

{

hash = 65599 * hash + string[i];

}

return hash ^ (hash >> 16);

}

This would unroll the loop if len is constant. I believe the IBM compiler supports something similar to this. And we have this kinda switch in HLSL. So why can't we have it in our C++ compilers?

Microsoft, can we please have this option, pretty please?

Walkaround (for now)
Since my original was posted, Mikkel Gjoel let me know Humus had a way to generate compile-time hash more than this limit.

I tested it quickly and it works great. I tested up to 64 chars! There is an usability issue: you can't have a generic generateHash(const char*) function with specialized generateHash(const char &(string)[N]); functions together. Compiler gets confused. So now I have to make two different versions.

From the altdevblogaday link posted in the comment I found a nice way to get around the striked-through issue:

struct ConstCharWrapper
{
inline ConstCharWrapper(const char* str) : m_str(str) {}
const char* m_str;
};

inline unsigned int generateHash(ConstCharWrapper wrapper, size_t len)
{
const char* string = wrapper.m_str;

// same as before
}

Also I found VS 2010 is not smart enough to know these two are same, thus not flattening down the first even with my way: (g++ is smart enough to know it).

#1
const char * const funny = "funny_bone";
unsigned int hashValue = HASH_STRING(funny);

#2

unsigned int hashValue = HASH_STRING("funny_bone");

But using #1 confuses regex when generating the debug string DB anyways, so probably I can just ignore it. But how would I ~~force~~ educate other programmers to use the first form if the string is const? That's something I'm trying to figure out.

Anyways, if I figure out a nice way to use this new info in a less painful way, I'll write another post. This post has gotten too long already.. ugggh...

Antec 900 Hard Disk Cage Screws

2012-01-08T15:23:00.000-08:00

A few weeks ago, I got a free used Antec 900 computer case, and I like it a lot. Lots of room inside, good air flow, and easy to detach HDD cages.

Cages look like this. (Image source: http://hardwarelogic.com)

But I quickly found out there is a problem when I tried to add a couple more HDD. It uses a very long screws to fasten HDDs inside the cage, and extra screws didn't come with the case. :(

So I went to Home Depot and found matching screws: Machine Screws 6-32 X 1. This matches perfectly :) The only downside is the screw top is not cross. But I can still use the flat screw drivers instead the square ones. So oh well...

All the games I shipped

2012-01-02T10:00:00.000-08:00

Apparently I've shipped 13 SKUs so far.... and gonna add 3 soon-ish... jesus

Pictures of Me Presenting at KGC

2011-12-05T09:30:00.000-08:00

I received some pictures from KGC organizers:

New myFinancialTracker from RBC

2011-11-29T09:30:00.000-08:00

RBC just rolled out new myFinancialTracker, which seems to be very close to mint.com. I loved mint.com's ability to show all your bank accounts and assets at one place, but my concern was having all my account info in their database.

RBC's new myFinancial Tracker says:

myFinanceTracker now gives you complete control of your finances by letting you view all your accounts in one place.

Link your RBC Royal Bank mortgage, investments and loans.
Link accounts you have at other financial institutions.
Even add assets or liabilities not linked to a financial institution like a loan from a family member or the equity in your house.

See? Now it's same as mint.com, so if you are a RBC customer, why don't you give it a try?

Optimized Oren-Nayar Approximation Shader Code

2011-11-16T12:34:00.001-08:00

We presented this approximation code as part of our KGC 2011 presentation. Let me just show the code for those people who don't want to read the whole presentation. I've also mentioned this to Wolfgang Engel during KGC 2011 because our previous Oren-Nayar code was from his wiki book.

The best part of this approximation code is that we eliminated the texture look-up, which turned out to be bottleneck for us. It is not mathematically correct, but worked fine for our game, Warhammer 40,000: Space Marine.

half ComputeOrenNayarLighting_Fakey( half3 N, half3 L, half3 V, half roughness )
{
// Through brute force iteration I found this approximation. Time to test it out.
half LdotN = dot( L, N );
half VdotN = dot( V, N );
half result = saturate(LdotN);
half soft_rim = saturate(1-VdotN/2); //soft view dependant rim
half fakey = pow(1-result*soft_rim,2);//modulate lambertian by rim lighting
half fakey_magic = 0.62;
//(1-fakey)*fakey_magic to invert and scale down the lighting
fakey = fakey_magic - fakey*fakey_magic;
return lerp( result, fakey, roughness );
}

Related Posts:

Slides: The Rendering Tech of Space Marine

2011-11-15T19:23:00.001-08:00

One that Daniel and I presented at KGC 2011. First half is a quick overview of our rendering passes, and second half is about Screen Space Decal and World Occlusion technique we used for Space Marine.

Rendering Tech of Space Marine

View more presentations from Pope Kim

Feedback on My KGC 2011 Presentation

2011-11-15T12:55:00.001-08:00

After I presented The Rendering Tech of Warhammer 40,000: Space Marine at KGC 2011 with my co-worker, Dr. Daniel Barrero, I was curious what the audience thinks about our presentation. So, here I compiled all the feedback I was able to find on the net. All feedback is pretty positive so far.

1. http://agebreak.blog.me/60146508810

Original Text: 그래픽스 관련 강연을 주로 많이 들었는데, 괜찮은 강연들이 꽤 많았습니다. 새로운 기술을 설명하는 강연부터, 상용화된 게임에서 어떻게 적용하는지에 대한 내용들이 괜찮았습니다. 특히나 워해머 강연은.. 강추…ㅠ.ㅠ (자세한 내용은 다음 글에…)

Google Translation: I've heard a lot of graphics related primarily lecture, were many there are quite a good speech. From lectures to explain the new technology commercially available in the game of how to apply it was fine for the information. Especially Warhammer lecture. Gangchu ... tires screech (the following article for more information.)

My Translation: I attended mostly graphics-related presentations and a lot of them were pretty good. Some explained actual theory, and the other explained how to apply those to commercial games. Especially, I highly recommend Warhammer 40K lecture. (Will post more about this in another post later)

2. http://twitter.com/#!/TranosTria/status/133826484547764224

Original Text: kgc 1일차 2일차를 통 틀어서 워해머 스페이스 마린의 렌더링 기술 섹셕이 가장 좋은 세미나가 아닌가 싶다. 특히 "우린 수학적인 검증따윈 신경안쓴다. 오직 룩만 좋으면 그걸로 끝이다"라는 얘기가 무한 공감간다 ㅋㅋㅋ

Google Translation: kgc 1 Day 2 through Day Warhammer Space Marines lay seksyeokyi rendering technology like Is not the best seminars. In particular, "We do not care anymore mathematical verification, only if you're rukman're done with it," the story takes an infinite gonggam ㅋ ㅋ ㅋ

My Translation: Among the lectures presented on 1st and 2nd day of KGC 2011, I think the best one was The Rendering Tech of Warhammer 40,000: Space Marine. Especially, I completely agree with what they said during the presentation: "We are not really Nazi about mathematical correctness. If it looks right to artists, that's the end of the story".

3. http://beaumale.blog.me/80144986487

Original Text: ...해외 유명게임 개발자가 와서 강연해 주고 있는데(클라 프로그래머라면 누구든 꿈꾸는 그런 인물!) 맨 앞자리에서 쳐 졸고 있질 않나...(그래, 워해머40K 스페이스마린 렌더링 기술 강연때 맨 왼쪽 앞에 앉은 너희 두놈) 밖에서 받은 기념품 봉지를 뽀시락거리면서 싱경 거슬리게 하지 않나...

Google Translation: ... Internationally renowned game developers, and which came gangyeonhae (client programmers dream of such a person with anyone!), Hit the top in the front seat asleep, is not it displaced ... (yeah, Warhammer 40K Space Marines sitting in front of the left-rendering technology, you two clowns gangyeonttae ) received gift bags from outside, is not disturbed singgyeong pposirakgeorimyeonseo ...

My Translation: ... While famous foreign game developers, who any client programmers would look up to, were presenting, some stupid students were dozing at the first row. Yes I'm talking about you two who were sitting at the very front in the Rendering Tech of Warhammer 40,000: Space Marine presentation. Also some students annoyed me by making noise from the gift wrapping paper ...

4. http://m.inven.co.kr/powerbbs/powerbbs.php?come_idx=2813&l=38

Original Text: ... 꼭 듣고 싶은 강의는... 11월 8일... 16:30~18:40 = 스페이스 마린의 렌더링 기술

Google Translation: ... Lecturers want to hear it ... Nov. 8. 16:30 to 18:40 = rendering technology of the Space Marines

My Translation: Lectures I really want to attend... Nov 8, 16:30 ~ 18:40 = the Rendering Tech of Space Marine

5. http://blog.naver.com/taiger11/20141997930

Original Text: 제가 존경하는 게임개발자이신 포프님입니다 ㅇㅂㅇ.... 처음엔 게임개발에 관심가지고 정보 찾아보다가 포프님 블로그에서 북미게임기업취업에 대해 다루는 글을 보게 되었고 댓글을 달면서 소통하다가 알게된분이심. 작년엔 일이있으셔서 KGC 강연에 참가 못하셨는데 올해는 KGC에 참가하시네요 ㅇㅂㅇ ....(프로그래밍 잘 못하지만 가고싶은...근데 수능이랑 겹치지 ㅋㅋ OTL) 나도 커서 포프님처럼 남들앞에서 떨지않고 뭔가 발표하거나 강연해보고 싶은...

Google Translation: Hi I am Pope, who is a respected game developers ㅇ ㅇ f. .... At first I got interested in game development popeunim search of information on a blog that covers some of North America, game companies look for employment and have learned a comment dalmyeonseo minutes hadaga eccentric communication. Have you participated in twelve lectures last year for letting KGC KGC Did not participate in this year was rubbish ....( ㅇ ㅇ Programming f. .. Then I want to go but do not overlap and ㅋ ㅋ SAT OTL) I tremble at the cursor in front of others like you Pope announced, but something or willing to talk ...

My Translation: Pope, the game programmer I respect, is presenting at KGC 2011. I did get to know him while reading and replying to his blog posts on being a game developer in North America. (Although I'm not a good programmer yet, I wish I could attend his presentation. But I have to take SAT test that day.. -shrugs-)... In the future, I hope to present something in front of people confidently just like Pope.

6. http://media.daum.net/society/nation/others/view.html?cateid=100011&newsid=20110929141208516

Original Text: 다니엘 베리노 렐릭엔터테인먼트 프로그래머와 킴 포프 수석 그래픽 프로그래머도 공동연사로 나선다. 둘 다 게임엔진과 게임그래픽 분야의 대가다.

Google Translation: Daniel and Kim Pope berino relrikenteoteinmeonteu senior graphics programmer programmer co-speakers out there. Both the soldier in the field of game engine and game graphics.

My Translation: Also Daniel Barrero (Graphics Programmer) and Pope Kim (Senior Graphics Programmer) from Relic Entertainment are co-presenting at KGC 2011. Both are the masters of Game Engines and Computer Graphics.

I Figured Out Wild and Free Chords

2011-10-27T22:20:00.000-07:00

I have been trying to find the correct guitar chords for Wild and Free by Damian Rice for a while without any success. The closest one was this, but still not 100% correct.

So I just did it by myself.... Enjoy.. if you know how to play guitar and you are a fan of Damian Rice just like me. For lyrics, take a look at the above link. meh...

verse e - bm - c#m - g#m

prechrous a - e - bm - c#m

chrus f#m - c#m

(Damian does a simple finger trick with the last c#m chord. Lift and press again fourth finger at the first time and then fifth finger at the 2nd time)

I use int 3 for assert()

2011-06-19T17:39:00.000-07:00

C has assert() function. Sure.. I don't use it. I don't like the call stack it gives me. It is rather confusing: I want the line with the problem at the top of my call stack. Sure, there's a way to unroll stack for sure. Too much hassle. Instead, I use this for my own assert.

#define ASSERT(expr, ...) if(!expr) __asm{ int 3 }

What it does is basically breaking at the code where this ASSERT happens. So when I use this assert I would do something like this:

ASSERT( life == sucks, "LIFE CAN ONLY SUCK");

This string message is for my own reference. When the code breaks in debugger, it simply shows that code line, so I know what it is right away.

As it relies on HW interrupt, it only works on PC. If you want this to work on PowerPC CPUs, I heard you have to use this instead.

#define ASSERT(expr, ...) if(!expr) asm{trap}

Happy coding. Yay?

Inside of char* string buffer initialization

2011-06-09T09:18:00.001-07:00

I used to initialize a string buffer this way:

char temp[64];
temp[0] = 0;

A few years ago, one of my coworkers at my previous studio, Capcom Vancouver, told me the following way is better:

char temp[64] = {0, };

I don't remember why he said it was better. I've been just using this way since I'm a nice guy who trusts one's coworkers. But finally I figured it out.... well... by accident...

The other day I was doing some profile captures on Xbox 360 and I happened to see how the above code gets compiled into. Once compiled, it turns into this:

char temp[64];
memset(temp, 0, sizeof(char) * 64);

Interesting, huh? It takes a few micro secs, so not that bad, but now I think this type of initialization is not always necessary if the buffer is always filled by strcpy or similar functions right after. (so as long as it eventually becomes null-terminated)

Screen-space Lens-Flare in HomeFront?

2011-05-30T11:45:00.000-07:00

I consider myself a practical graphics programmer. I believe mathematically correctness is less important than what looks right(or okay) to gamers.

I recently saw an interesting lens-flare technique that goes along with my belief in a game called HomeFront.
In this game, lens-flare effect is a mere full-screen overlay of a bubble patterned image, which is revealed only on the pixels where bright lights are.

Look at my awesome picture below:

So from the left top picture, let's say the yellow part is where bright light is. (and the chance is you probably have some type of HDR buffer already to do effects like bloom.) Then it'll use the luminance on each pixel as blend factor for lens flare bubble texture, making the final scene reveal bubble pattern on those bright pixels

I found this lens flare technique looks good enough when the high luminance area is small enough. The only time it looked a bit weird was when a large light, such as campfire, covers a lot of pixel spaces, revealing too much bubbles altogether. It almost made me feel like I was doing bubble bath. Hah! But I won't complain.

Given that HomeFront was made by our sister studio, Kaos, I can probably ask them if my speculation(?) is correct, But if I do so, I won't be able to write this blog post without going through our legal team. So let's just leave it as my own speculation.

I liked this technique. That's all I wanted to say.

p.s. I saw this technique on PC version.

How to Add Generic Convolution Filter to NVTT

2011-05-21T13:58:00.000-07:00

A few month ago, I said I would write a post about how to add a generic convolution filter to NVidia Texture Tool once I get a clearance from our legal team. And finally they got back to me.

Background

The reason why I added this feature at work was because our artists wanted a sharpening filter on mipmaps. This feature was present with the original NVTT 1, but removed from NVTT 2. Given that sharpening filter is a simple 3x3 or 5x5 convolution filter, I've decided to add a generic convolution filter support which can take any arbitrary coefficients. With this approach, anyone can run almost every image processing algorithms based on on convolution.

NVTT Modification

So here's how. It requires only a few lines of change on 6 files. So I'll just walk you through.

Step 1. Get revision 1277 from NVidia Texture Tools project page.

I haven't tested this on later revisions, but I think it should work unless there were major changes in that source code.

Step 2. Open up src/nvimage/Filter.h and add this constructor.

Kernel2(uint width, const float * data);

Step 3. Open up src/nvimage/Filter.cpp and add this function.

Kernel2::Kernel2(uint ws, const float* data) : m_windowSize(ws)

{

m_data = new float[m_windowSize * m_windowSize];

memcpy(m_data, data, sizeof(float) * m_windowSize * m_windowSize);

}

Step 4. Open up src/nvimage/FloatImage.h and add this function prototype.

NVIMAGE_API void doConvolution(uint size, const float* data);

Step 5. Open up src/nvimage/FloatImage.cpp and add this function implementation.

void FloatImage::doConvolution(uint size, const float* data)

{

Kernel2 k(size, data);

AutoPtr tmpImage = clone();

for(uint y = 0; y < height(); y++)

{

for(uint x = 0; x < width(); x++)

{

for (uint c = 0; c < 4; ++c )

{

pixel(x, y, c) = tmpImage->applyKernel(&k, x, y, c, WrapMode_Clamp);

}

Step 6. Open up src/nvtt/nvtt.h and add this function prototype under struct TexImage.

NVTT_API void doConvolution(unsigned int size, const float* data);

Step 7. Open up src/nvtt/TexImage.cpp and add this function implementation.

void TexImage::doConvolution(unsigned int size, const float* data)

{

if (m->image == NULL) return;

detach();

m->image->doConvolution(size, data);

}

How to Use

How to use this is very straight forward. Assuming you already have a TexImage object named image, you can do this.

const int kernelSize = 3; // let's use 3 x 3 kernel

// Some random coefficients I found working great for sharpening.

const float sharpenKernel [] =

{

-1/16.0f, -2/16.0f, -1/16.0f,

-2/16.0f, 1 + 12/16.0f, -2/16.0f,

-1/16.0f, -2/16.0f, -1/16.0f,

};

image.doConvolution(kernelSize, sharpenKernel);

YAY!

p.s. I've also emailed the patch file to Ignacio, the creator/maintainer of NVTT project. Let's see if it ever makes into the codebase. :)

Theorycraft = Witchcraft? Maybe

2011-05-19T09:15:00.000-07:00

Although I can't deny that posts from a lot graphics programming blogs help us to learn new cool stuff, I'm also often worried about the quality of posts, especially when people claim something not entirely true from a pure "theorycraft" instead of actual experience. Things that make sense on theory don't necessary make sense in reality, that is.

If you are a decent graphics programmer, you should take only empirical results as truth.

Oren-Nayar Lighting in Light Prepass Renderer

2011-05-16T10:08:00.000-07:00

This is a conversation I had with another graphics programmer the other day:

A: "Using Oren-Nayar lighting is extreme hard with our rendering engine because IT is Light Pre-Pass renderer."
Me: "WTF? It's very easy."
A: "No. This blog says it's very hard."
Me: "Uh... but look at this. I've already implemented it in our engine 2 years ago, and it was very trivial."
A: "OMG." -looks puzzled-

Okay. So I explained to him how I did it. And I'm gonna write the same thing here for the people who might be interested. (I think the original blog post wanted to say supporting various lighting models is not easy in a deferred context, which is actually a valid point.)

First, if you don't know what Oren-Nayar is, look at this amazing free book. It even shows a way to optimize it with a texture lookup. My own simple explanation of Oren-Nayar is a diffuse lighting model that additionally takes account of Roughness.

Second, for those people who don't know what Light Pre-Pass renderer is, read this.

K, now real stuff. To do Oren-Nayar, you only need one additional information. Yes, roughness. Then how can we do Oren-Nayar in a Light Pre-pass renaderer? Save roughness value on the G-Buffer, duh~. There are multiple ways to save roughness on G-Buffer and probably this is where the confusion came from.

It looks like most light-prepas approaches use R16G16 for G-Buffer to store XY components of normals. So to store additional information (e.g, roughness), you will need another render target = expensive = not good.

Another approach is to use 8 bit per channel to store normal map, but you will see some bending artifacts = bad lighting = bad bad. But, thanks to Crytek guys, you can actually store normals in three 8-bit channels without quality problem. It's called best-fit normal. So once you use this normal storage method, now you have an extra 8 bit channel that you can use for roughness. Hooray! Problem solved.

But my actual implementation was a bit more than this because I needed to store specular power, too. So I thought about it. And found out we don't really need 8 bits for specular power(do you really need any specular power value over 127? Or do you really use any specular power value less than 11?) So I'm using 7 bit for specular power and 1 bit for roughness on/off flag. Then roughness is just on and off? No. It shouldn't. If you think a bit more, you will realize that roughness is just an inverse function of specular power Think this way. Rougher surface will scatter lights more evenly, so specular power should be less for those surfaces and vice versa.

With all these observations, and some hackery hack functions, this is what I really did at the end.

G-Buffer Storage

RGB: Normal
A: Roughness/Specular Power fusion

Super Simplified Lighting Pre-pass Shader Code

float4 gval = tex2D(Gbuffer, uv);

// decode normal using crytek's method texture

float3 normal = decodeNormal(gval.xyz);

float specpower = gval.a * 255.0f;

float roughness = 0;

if (specpower > 127.0f)

{

specpower -= 128.0f;

roughness = someHackeryCurveFunction(127.0f - specpower);

}

// Now use this parameters to calculate correct lighting for the pixel.

Ta da.. not that hard, eh? This approach was faster enough to ship a game on Xbox 360 and PS3 with some Oren-Nayar optimization through an approximation.

On a Windy Day

2011-05-09T10:27:00.000-07:00

Finally decided to post my music on YouTube.

Tales of Multiply Map and Gamma Correction

2011-05-03T09:57:00.000-07:00

Using a detail map, or multiply map, on top of diffuse map is a somewhat popular way to eliminate the repeating pattern on tiled textures.

I've once implemented this upon an artist's request. The actual blend(?) math I used was:

DiffuseMap * MultiplyMap * 2

The reason I added * 2 at the end was to also give a detail map the ability to brighten the diffuse map. (without this, it can only darken the base map.) So the idea was if an artist paint a detail map with half grey, or 0.5, it wouldn't change the base diffuse map at all.

It had worked fine until we decided to change our rendering engine to "gamma-aware". While we were enabling sRGB texture read on certain textures, we accidentally did it on detail maps, too. Then, a month or two passed by, and a few assets were made with this new "gamma-powered" shaders.

Then a "tech-driven" artist found out painting a detail map with the value of 0.5 darkens the texture instead of keeping the base colour. OMG. This was because our new blending formula looked like this:

{ (DiffuseMap ^ 2.2) * (MultiplyMap ^ 2.2) * 2 } ^ (1/2.2)

Because of power of 2.2, it makes 0.5 smaller than 0.25 and multiplying this by 2 gives you a value less than half intensity, 0.5. So I had to fix it by disabling sRGB read on multiply maps. And this is how the blending looks like now:

{ (DiffuseMap ^ 2.2) * MultiplyMap * 2 } ^ (1/2.2)

Better, eh?

Then, I asked artists to change detail maps authored with previous shaders to comply with our new way. To me, converting them was very straightforward.

Open a detail map in PhotoShop.
From main menu, select Image > Adjustment > Exposure.
Set gamma to 0.454545(same as 1 / 2.2).
Press OK

But this time a "visually-driven" artist wanted to change base diffuse maps instead of detail maps because gamma-ing details maps makes them too dark, so it's hard to work with. He asked me what's the easiest way to do this. Unfortunately, I couldn't find a mathematically correct way that always produces the correct conversion, so he had to manually change them while visually verifying the result.

This was probably one of the few cases where mathematical correctness can make things easier than harder, but unfortunately I was not able to find the magic formula. I just don't think it's possible here.

Or am I just stupid? Does anyone know the correct math here?

Personal Choice of Version Control System

2011-04-21T09:35:00.000-07:00

Being in the gaming industry about 10 years and playing with some open-source projects means I have dealt with different version control systems, or VCSs, from complete free, brute-force manual file copy method to very expensive commercial-grade Perforce.

So which program am I using at home? Subversion.... I know! A lot of people will argue that other programs are better, and I am not gonna say they are wrong. The reason why I'm using Subversion is because it does what I want with the least amount of annoyance. Below is the list of what I need/want from my personal VCS and how the most popular VCSs do the job:

Windows Support
Yes, I'm a MS whore. I use Windows all the time, and I, as a game programmer, personally don't see huge need for Linux for myself. Also if I can maintain only one OS at home, that's less drama for me. (Yay?).

Git(-2): I like Git a lot, especially how it handles branches, so I really wanted to use it on Windows. But, as far as I know, the only way to use Git server on Windows is through Cygwin or msysgit. Cygwin is basically doing Linux emulation in a sense, and I personally don't enjoy installing Cygwin. msysgit is a bit easier to install on Windows, but still I had to set up SSH or what not, so there's no one-button solution for Git on Windows. So big no-no to a MS whore like me.
Perforce(+1): Perforce supports Windows pretty well. It comes with easy-to-install server program/service for windows.
Subversion(+2): This was actually a big surprise to me. There is a program called VisualSVN Server, which is one-click solution for Subversion server on Windows. It just works and comes with https access and access control all in one nice and simple GUI. This was even easier than installing Perforce.

Occasional Multi-User Support
Although my VCS is mostly there to keep a history and backups of my own codes, sometimes I open it up to my friends so that I can get useful feedback from them. So having multi-user support is very useful for me.

Git(+1): Git can easily support multiple users. But setting access control for each users can be a bit of PITA on Windows. When I tried it last time, I had to make fake Windows user accounts and hook'em up with SSH.
Perforce(-1): Perforce is free for either i) 2 users and 5 client workspaces, or ii) unlimited users and up to 1000 files. I have more than 1 friend (at least I wanna believe that :P ) so first option doesn't seem to work that great. What about 1000 files and unlimited users? Well, I've already passed 1,000 files: Playing with 3rd party open-source project breaks this boundary very easily. Furthermore, I don't want to pay a few hundred dollars for the simple need of VCS.
Subversion(+2): As I said earlier in Windows Support section, VisualSVN Server comes with a nice GUI where you can simply setup users and access control. So another big thumbs up from me.

Cost
I'm cheap. I love free stuff.

Git(+1): free
Perforce(-1): free for limited use. And apparently I'm not limited?
Subversion(+1): free

GUI Client
I'm in love with Perforce's nice GUI clients. Not so much with P4V; more with P4Win. But P4Win is discontinued.... Oh well, P4V is still good enough. Sure, I still use command-line a lot for certain things GUI clients don't support, but I found 90% of time, using GUI clients are much faster and easier.

Git(-1): it doesn't have any nice free GUI client as far as I know. There are some being developed at this moment, but they don't seem to be mature or free enough to use them. TortoiseGit is good enough most of the time. But I still prefer P4Win style, real GUI clients.
Perforce(+2): P4Win is awesome. P4V is great, too.
Subversion(+1): I found a program called SmartSVN. It has limited functionalities unless you buy the pro version, but I found the basic free version is good enough for day-to-day operations. Anything that cannot be done through the free SmartSVN version, I use TortoiseSVN. Then anything that cannot be done by TortoiseSVN, I use command-line.

Branching

Who doesn't love branching? It's such a neat tool to fuck around(read it as experiment) your code without ruining your projects.

Git(+2): I love the powerful branching feature of Git. You don't need to make a copy in different directories, so it helps a lot with path referencing in the code. Say you have a program that links with library Awesome, and now you wanna branch library Awesome. With Git, you simply need to switch to different branch and build. But with other source control systems like Perforce, you will have to branch the library into a different directory and change the library path in your program code.
Perforce(-2): As I just explained in Git section above, branching into different folder sucks. Also the speed of branching a large number of files is slow because Perforce server controls everything. Network speed is slower than your HDD's spin rate.
Subversion(-1): The speed is fast enough. But still you have to branch into different directory.. uggh.. that bothers me.

Final Score

So final score for me is like this.

Git: +1
Perforce: -1
Subversion: +5. Oh there it is. Winner, winner, chicken dinner

Don't forget. This is the score for my personal need. Not for the big giant game studios. So if you ever comeback and say "but Perforce is better because it can supports 200 users easily", I'm gonna make you watch this video for 2 hours before you go to bed.

Shipping Mindset

2011-04-19T10:00:00.000-07:00

As some of you already know, I'm currently finalling a game called Space Marine. So it's obvious that everyone needs to shift to the Shipping Mindset.

The Shipping Mindset is basically about being extra careful on changes you make since everytime you touch something, there is chance that you break something else. Sure, normally it's not that bad. You can fix it sooner or later, but at this time, you wouldn't have enough time to test everything that used to work again. So what happens if a crucial bug doesn't get caught by the time the game is submitted to the first-party publishers, such as MS and Sony? You will fail at certification, and you will re-submit with the fixes. Not bad. eh? Oh, did I tell you that each submission easily cost the half of your yearly salary? Now you think it's bad? Hope so.

So, with the Shipping Mindset, this is what you MUST and MUST NOT do.

fix broken things only: As said earlier, any code you change might break other things. Please, don't risk your whole project for whatever excuses you come up with to fix things that are working fine.
do NOT beautify existing code to your taste: you introduce more bugs while you are moving around codes, changing 4 spaces to 1 tab, breaking a line into multiple lines and so on. Just make a note and fix it for your next game. Also I should say that if there's some coding style you don't like, but it's everywhere in the codebase, the chance is that most people in your company agree with that coding style. Maybe you are from the Wild West, but 21st century is not the time for a cowboy programmer to shine.
fix things that are not right to gamers(or testers), not to you: You found something that's mathematically wrong? Don't fix unless the end-users care about it. Did you know even Photoshop is mathematically wrong? Photoshop users don't care, and for the same reason gamers don't care about mathematical correctness. Instead, this math change could impact your fellow contents producers. "Hey, some math changed, so contents need to be changed too. Do you have enough time to fix all the arts you've been producing for the last 2 years? What? No? But it's mathematically correct." If you ever make this type of argument, you are being inconsiderate. Noone cares about your own satisfaction for being a math-wiz.
if you find something you think it must be fixed, talk to everyone who could be even remotely affected by this change: other people might have something more important things to fix. If that's the case and your fix adds too much burden onto other co-workers, it's better not to fix your bug.

I always thought whatever I wrote above is a common sense for any developer who shipped at least one game, especially on console. However, my belief has been proven wrong recently; for the last month, I was hit by numerous bugs produced by a self-claimed seasoned console game programmer and I had such privilege to investigate those bug to simply find out they had been caused by the missing shipping mindset of that programmer.

Programmers, please be considerate and be responsible for your code at least once when you are finalling. I seriously beg you.