Practical Guide to Optimization for Mobiles - Rendering Optimizations

This section introduces the technicalities of rendering optimization. It shows how to bake lighting results for better performance, and how the developers of Shadowgun levered high-contrast textures, with lighting baked-in, to make their game look great. If you are looking for general information on what a mobile-optimized game looks like, check out the Graphics Methods page.

Get Artsy!

Sometimes optimizing the rendering in your game requires some dirty work. All of the structure that Unity provides makes it easy to get something working fast, but if you require top notch fidelity on limited hardware, doing things yourself and sidestepping that structure is the way to go, provided that you can introduce a key structural change that makes things a lot faster. Your tools of choice are editor scripts, simple shaders, and good old-fashioned art production.

Note for Unity Indie users: The editor scripts referenced here use RenderTextures to make production smooth, so they wont work for you right away, but the principles behind them work with screenshotting as well, so nothing is stopping you from using these techniques for a few texture bakes of your own.

How to Dive Under the Hood

First of all, check out this introduction to how shaders are written.

• Built in shaders
  • Examine the source code of the built in shaders. Often, if you want to make a new shader that does something different, you can achieve it by taking parts of two already-existing shaders and putting them together.
• Surface Shader Debugging (#pragma debug)
  • A CG Shader is generated from every surface shader, and then fully compiled from there. If you add #pragma debug to the top of your surface shader, when you open the compiled shader via the inspector, you can see the intermediate CG code. This is useful for inspecting how a specific part of a shader is actually calculated, and it can also be useful for grabbing certain aspects you want from a surface shader and applying them to a CG shader.
• Shader Include Files
  • A lot of shader helper code is included in every shader, and usually it isn't used, but this is why you will sometimes see shaders calling functions like WorldReflectionVector which don't seem to be defined anywhere. Unity has several built-in shader include files that contain these helper definitions. To find a specific function, you will need to search through all of the different includes.
  • These files are a major part of internal structure that Unity uses to make it easy to write shaders; the files provide things like real time shadows, different light types, lightmaps, and multiple platform support.
• Hardware documentation
  • Take your time to study Apple documentations on

hardware and best practices for writing shaders. Note that we would suggest to be more aggressive with floating point precision hints however.

Shadowgun in-depth

Shadowgun is a great graphical achievement considering the hardware it runs on. While the art quality seems to be the key to the puzzle, there are a couple tricks to achieving such quality that programmers can pull off to maximize their artists' potential.

In the Graphics Methods page we used the golden statue in Shadowgun as an example of a great optimization; instead of using a normal map to give their statue some solid definition, they just baked lighting detail into the texture. Here, we will show you how and why you should use a similar technique in your own game.

 // This is the pixel shader code for drawing normal-mapped
 // specular highlights on static lightmapped geometry
 
 // 5 texture reads, lots of instructions
 
 SurfaceOutput o;
 
 fixed4 tex = tex2D(_MainTex, IN.uv_MainTex);
 fixed4 c = tex * _Color;
 o.Albedo = c.rgb;
 
 o.Gloss = tex.a;
 o.Specular = _Shininess;
 
 o.Normal = UnpackNormal(tex2D(_BumpMap, IN.uv_BumpMap));
 
 float3 worldRefl = WorldReflectionVector (IN, o.Normal);
 fixed4 reflcol = texCUBE (_Cube, worldRefl);
 reflcol *= tex.a;
 o.Emission = reflcol.rgb * _ReflectColor.rgb;
 o.Alpha = reflcol.a * _ReflectColor.a;
 
 fixed atten = LIGHT_ATTENUATION(IN);
 fixed4 c = 0;
 
 half3 specColor;
 fixed4 lmtex = tex2D(unity_Lightmap, IN.lmap.xy);
 fixed4 lmIndTex = tex2D(unity_LightmapInd, IN.lmap.xy);
 
 const float3x3 unity_DirBasis = float3x3( 
 float3( 0.81649658,  0.0, 0.57735028),
 float3(-0.40824830,  0.70710679, 0.57735027),
 float3(-0.40824829, -0.70710678, 0.57735026) );
 
 half3 lm = DecodeLightmap (lmtex);
 
 half3 scalePerBasisVector = DecodeLightmap (lmIndTex);
 
 half3 normalInRnmBasis = saturate (mul (unity_DirBasis, o.Normal));
 lm *= dot (normalInRnmBasis, scalePerBasisVector);
 
 return half4(lm, 1);
 

 // This is the pixel shader code for lighting which is
 // baked into the texture
 
 // 2 texture reads, very few instructions
 
 fixed4 c = tex2D (_MainTex, i.uv.xy);	
 
 c.xyz += texCUBE(_EnvTex,i.refl) * _ReflectionColor * c.a;
 
 return c;