Archive for February, 2008
According to PS3fanboy:
The top 10 PSN purchases since the system’s launch.
* flOw
* Mortal Kombat II
* Tekken 5 Dark Resurrection
* PAIN
* Warhawk
* High Velocity Bowling
* Super Stardust HD
* Calling All Cars
* Aquatopia
* Everyday Shooter
The top downloaded demos also include:
* Gran Turismo HD Concept
* Uncharted
* Ninja Gaiden Sigma
* Heavenly Sword
* The Simpsons Game
* Need for Speed ProStreet
* Ratchet and Clank
* Burnout Paradise
* Motorstorm
* Turok
Finally, the top PSN downloads from Europe include:
* Tekken 5: Dark Resurrection
* Warhawk
* flOw
* LocoRoco Cocoreccho!
* Mortal Kombat II
* Super Rub a Dub
* Calling All Cars
* Gripshift
* Lemmings
* Super Stardust HD
A couple of things I know and are generally somewhat public.
- flOw’s sales exceeed 150,000 units.
- PixelJunk Racers has at least broken even and PixelJunk Monsters has well surpassed even and nearly outselling Racers… yet neither are listed above.
- PAIN was a very expensive title to develop. It had to sell in large numbers and so far has seem to.
February 28th, 2008
I doubt many people know that Portal was designed/created by a woman. It’s a fantastic game that has a “girl’s touch” – how many men would put a companion cube in a first person shooter? Zero.
And after reading the Post-Mortem in the January edition of Game Developer Magazine, I realized that Valve was taking a huge risk in funding Portal but mitigated it by bundling Portal with Half-Life / Team Fortress. Portal was a “bonus” game of sorts, but has surpassed it’s bigger brethren. Much like Geometry Wars has become it’s own franchise after starting life as a mini-game inside Project Gotham Racing.
I suspect more smaller games will be bundled in major console releases to “test out” the market.
February 28th, 2008
Using the H1B database:
http://www.flcdatacenter.com/CaseH1B.aspx
H1Bs are visas granted to foreigners (outside the NAFTA countries). They usually take 3 months to acquire and thus employers are not hiring juniors nor low-balling potential employees.
Interesting fact: Game development pays about $20-40K less than film for similar roles.
February 27th, 2008
While shaders have increased visual quality (per-pixel lighting) and performance (hardware accelerated skinning/physics/particles).. the tragic flaw with them is the process of combining shaders which is necessary because only one vertex and one fragment shader can be applied to a polygon… (ignoring full screen effects)
Let’s say we have three separate shaders – in reality it’s six(vertex + fragment shader for each of the three)
- Normal map
- BRDF lighting
- Hardware skinning
To combine these, we take the vertex shaders of the Normal map, BRDF, Hardware skinner and merge them into one. The hardware skinner deforms the vertex and normal first… this normal is perturbed by the Normal map shader and finally passed to the BRDF for some pre-lighting step.
Next, the pixel shader (we are performing per-pixel lighting)… requires us to perform fragment lighting using the new normal, the existing light direction, the existing eye/camera direction, etc. with a blended Normal map + BDRF pixel shader.
All of this requires us to copy and paste code from shader to shader then tweak some variables. It’s easy work and yet it’s not at all easy due to the complexity of mixing shaders together and required amount of testing afterwards. There isn’t an easy way of “layering” shaders together and have them work seamlessly.
What shader writers do is try to modularize their code into separate functions that can be called within a large shader (i.e lambert light function). This is half a solution. Themain vertex and pixel shaders that call these functions need to be tweaked heavily in order to accommodate the additional parameters needed by these functions. i.e Specular lighting requires eye/camera direction… so that has to be passed into the shader if it wasn’t already done so.
The two problems are:
- The number of Cg shader parameters vary greatly shader to shader
- Communication between vertex and pixel shader requires additional texture co-ordinates which adds to the first
February 4th, 2008
The major problem with Canadian business is not the lack of actual production talent: programmers, artists, fill-in scrubs… but the lack of competent management. Albert Lai summarizes the problem in a few paragraphs.
“Despite the technical talent that we have in Toronto, do we have a disproportion amount of tech-innovation and tech-wealth because of (a) economic factors (i.e. lack of capital, tax structure); (b) cultural factors (i.e. lack of ambitions or role models to inspire success); or (c) talent/experiential factors (i.e. lack of serial entrepreneurs, lack of mentors, lack of deep tech-marketing and tech-sales talent).”
(c) is the most important one. I’ve worked for many companies in varying stages of maturity and I’ve personally found US/British management far superior to Canadian ones. The lack of experience and talent at the management level in Canada is appalling. It’s beyond awful. And I’m part of the problem being a first time entrepreneur. Thankfully, I’ve received some mentorship courtesy of Telefilm, but it’s a huge learning process that could have been short-circuited with some hands-on management experience in the game business first.
Funny thing is… the best Canadian companies I’ve worked for have American managers. Still, Lai overrates Waterloo and UofT graduates. Those two Canadian universities are good, but not the same calibre as Harvard, Stanford, MIT, Princeton, CalTech… maybe Berkeley, UCLA, etc.
February 4th, 2008
Being a huge fan of Mitch Resnick’s research work, I follow his new projects occasionally (i.e programmable bricks) and his new project is a modern day “Logo”:
February 3rd, 2008
Lack of standards.
You have the following shading languages:
- Cg/HLSL
- GLSL
- MetaSL
- Sh
But those are NOT useful on their own – you need a shader wrapper to describe passes + render settings which adds to the complexity to using shaders. Shaders need certain parameters passed from the graphics engine like the model-view-projection matrix and custom values (shininess, diffuse colour, specular colour, etc.)
- CgFX
- HLSL FX
- COLLADA FX
- OGRE .materials
- Unreal/Source materials
- etc.
It’s getting ridiculous. In the offline world it was RenderMan SL and RIB files… you had some random spin offs like VEX + Houdini and Mental Ray, but nothing as important as RenderMan.
February 3rd, 2008
Cg/HLSL shaders are somewhat similar to their grandfather – RenderMan – but lack a couple of basic architectural things that require the shader writer to understand the real-time rendering pipeline.
An example: Fully transparent renders in off line 3D packages (like Maya) are pretty easy to do. Just tweak the alpha value in the material/shader and render!
The problem is that in real-time it’s not that easy. Real-time systems do not have accumulation/coverage buffers. Offline renders at EVERY PIXEL have a bucket of all fragments … ordered by distance. Essentially, this is equivalent to rendering “back to front.”
However, in real-time 3D, rendering back to front is expensive. Polygons in an object/model are typically rendered in random order. Sorting back to front at every frame would be expensive and kill the frame rate. Moving to the accumulation buffer method would also be hugely expensive.
The way to solve this is to use multiple passes:
1) Pass 1 – Render all back-faces, check Z, don’t write Z, blend with alpha
2) Pass 2 – Render all fronts-faces, check Z, Z write on or off (doesn’t matter), blend with alpha
So in terms of HLSL .fx files (similar to CgFX) we have to do this:
technique T0
{
pass P0
{
ZEnable = true;
ZWriteEnable = false;
CullMode = CCW;
AlphaBlendEnable = true;
SrcBlend = SrcAlpha;
DestBlend = InvSrcAlpha;
VertexShader = compile vs_3_0 vertex_main();
PixelShader = compile ps_3_0 fragment_main();
}
pass P1
{
ZEnable = true;
ZWriteEnable = false;
CullMode = CW;
AlphaBlendEnable = true;
SrcBlend = SrcAlpha;
DestBlend = InvSrcAlpha;
VertexShader = compile vs_3_0 vertex_main();
PixelShader = compile ps_3_0 fragment_main();
}
}
The default HLSL behavior is something like this (single pass):
technique T0
{
pass P0
{
ZEnable = true;
ZWriteEnable = true;
CullMode = none;
VertexShader = compile vs_3_0 vertex_main();
PixelShader = compile ps_3_0 fragment_main();
}
}
As a test case, you can try using a vertex and pixel shader that displays normals as rgb triplet (will look purplish).
void displaynormal_vp(
float4 position : POSITION,
float3 normal : NORMAL,
out float4 oPosition : POSITION,
out float3 oNormal : TEXCOORD0,
uniform float4x4 worldViewProj)
{
oPosition = mul(worldViewProj, position);
oNormal = normal;
}
void displaynormal_fp(
float4 position : TEXCOORD0,
float3 normal : TEXCOORD1,
out float4 oColor : COLOR)
{
oColor = float4(normal.xyz, 1.0);
}
February 1st, 2008
