Best Practices for Shaders

Compile and Link Shaders During Initialization

Creating a shader program is an expensive operation compared to other OpenGL ES state changes. Listing 11-1 presents a typical strategy to load, compile, and verify a shader program.

Listing 11-1  Loading a Shader

/** Initialization-time for shader **/
            GLuint shader, prog;
            GLchar *shaderText = "... shader text ...";

            // Create ID for shader
           shader = glCreateShader(GL_VERTEX_SHADER);

           // Define shader text
           glShaderSource(shaderText);

           // Compile shader
           glCompileShader(shader);

           // Associate shader with program
           glAttachShader(prog, shader);

          // Link program
           glLinkProgram(prog);
    
           // Validate program
           glValidateProgram(prog);

           // Check the status of the compile/link
           glGetProgramiv(prog, GL_INFO_LOG_LENGTH, &logLen);
           if(logLen > 0)
           {
               // Show any errors as appropriate
               glGetProgramInfoLog(prog, logLen, &logLen, log);
               fprintf(stderr, "Prog Info Log: %s\n", log);
       }

     // Retrieve all uniform locations that are determined during link phase
           for(i = 0; i < uniformCt; i++)
           {
               uniformLoc[i] = glGetUniformLocation(prog, uniformName);
           }

           // Retrieve all attrib locations that are determined during link phase
           for(i = 0; i < attribCt; i++)
           {
               attribLoc[i] = glGetAttribLocation(prog, attribName);
           }

    /** Render stage for shaders **/
    glUseProgram(prog);

Compile, link, and validate your programs when your application is initialized. Once you’ve created all your shaders, your application can efficiently switch between them by calling glUseProgram.

Respect the Hardware Limits on Shaders

OpenGL ES places limitations on the number of each variable type you can use in a vertex or fragment shader. OpenGL ES implementations are not required to implement a software fallback when these limits are exceeded; instead, the shader simply fails to compile or link. Your application must validate all shaders to ensure that no errors occurred during compilation, as shown above in Listing 11-1.

Use Precision Hints

Precision hints were added to the GLSL ES language specification to address the need for compact shader variables that match the smaller hardware limits of embedded devices. Each shader must specify a default precision; individual shader variables may override this precision to provide hints to the compiler on how that variable is used in your application. An OpenGL ES implementation is not required to use the hint information, but may do so to generate more efficient shaders. The GLSL ES specification lists the range and precision for each hint.

For iOS applications, follow these guidelines:

• When in doubt, default to high precision.

• Colors in the 0.0 to 1.0 range can usually be represented using low precision variables.

• Position data should usually be stored as high precision.

• Normals and vectors used in lighting calculations can usually be stored as medium precision.

• After reducing precision, retest your application to ensure that the results are what you expect.

Listing 11-2 defaults to high precision variables, but calculates the color output using low precision variables because higher precision is not necessary.

Listing 11-2  Low precision is acceptable for fragment color

default precision highp; // Default precision declaration is required in fragment shaders.

uniform lowp sampler2D sampler; // Texture2D() result is lowp.

varying lowp vec4 color;

varying vec2 texCoord;   // Uses default highp precision.

void main()

{

    gl_FragColor = color * texture2D(sampler, texCoord);

}

Perform Vector Calculations Lazily

Not all graphics processors include vector processors; they may perform vector calculations on a scalar processor. When performing calculations in your shader, consider the order of operations to ensure that the calculations are performed efficiently even if they are performed on a scalar processor.

If the code in Listing 11-3 were executed on a vector processor, each multiplication would be executed in parallel across all four of the vector’s components. However, because of the location of the parenthesis, the same operation on a scalar processor would take eight multiplications, even though two of the three parameters are scalar values.

Listing 11-3  Poor use of vector operators

highp float f0, f1;

highp vec4 v0, v1;

v0 = (v1 * f0) * f1;

The same calculation can be performed more efficiently by shifting the parentheses as shown in Listing 11-4. In this example, the scalar values are multiplied together first, and the result multiplied against the vector parameter; the entire operation can be calculated with five multiplications.

Listing 11-4  Proper use of vector operations

highp float f0, f1;

highp vec4 v0, v1;

v0 = v1 * (f0 * f1);

Similarly, your application should always specify a write mask for a vector operation if it does not use all of the components of the result. On a scalar processor, calculations for components not specified in the mask can be skipped. Listing 11-5 runs twice as fast on a scalar processor because it specifies that only two components are needed.

Listing 11-5  Specifying a write mask

highp vec4 v0;

highp vec4 v1;

highp vec4 v2;

v2.xz = v0 * v1;

Use Uniform or Constants Instead of Computation Within a Shader

Whenever a value can be calculated outside the shader, pass it into the shader as a uniform or a constant. Recalculating dynamic values can potentially be very expensive in a shader.

// Loop

    int i;

    float f;

    vec4 v;

    for(i = 0; i < 4; i++)

        v[i] += f;

    float f;

    vec4 v;

    v += f;

varying vec2 vTexCoord;

uniform sampler textureSampler;

void main()

{

    vec2 modifiedTexCoord = vec2(1.0 - vTexCoord.x, 1.0 - vTexCoord.y);

    gl_FragColor = texture2D(textureSampler, modifiedTexCoord);

}