Shading Language Support

Unsupported Features

The following features of the shading language are not yet supported in Mesa:

• Dereferencing arrays with non-constant indexes
• User-defined structs
• Linking of multiple shaders is not supported
• Integer operations are not fully implemented (most are implemented as floating point).

All other major features of the shading language should function.

Implementation Notes

• Shading language programs are compiled into low-level programs very similar to those of GL_ARB_vertex/fragment_program.
• All vector types (vec2, vec3, vec4, bvec2, etc) currently occupy full float[4] registers.
• Float constants and variables are packed so that up to four floats can occupy one program parameter/register.
• All function calls are inlined.
• Shaders which use too many registers will not compile.
• The quality of generated code is pretty good, register usage is fair.
• Shader error detection and reporting of errors (InfoLog) is not very good yet.
• There are massive memory leaks in the compiler.

These issues will be addressed/resolved in the future.

Programming Hints

• Declare in function parameters as const whenever possible. This improves the efficiency of function inlining.


• To reduce register usage, declare variables within smaller scopes. For example, the following code:

      void main()
      {
         vec4 a1, a2, b1, b2;
         gl_Position = expression using a1, a2.
         gl_Color = expression using b1, b2;
      }
  

  Can be rewritten as follows to use half as many registers:

      void main()
      {
         {
            vec4 a1, a2;
            gl_Position = expression using a1, a2.
         }
         {
            vec4 b1, b2;
            gl_Color = expression using b1, b2;
         }
      }
  

  Alternately, rather than using several float variables, use a vec4 instead. Use swizzling and writemasks to access the components of the vec4 as floats.


• Use the built-in library functions whenever possible. For example, instead of writing this:

          float x = 1.0 / sqrt(y);
  

  Write this:

          float x = inversesqrt(y);
  

Stand-alone Compiler

A unique stand-alone GLSL compiler driver has been added to Mesa.

The stand-alone compiler (like a conventional command-line compiler) is a tool that accepts Shading Language programs and emits low-level GPU programs.

This tool is useful for:

• Inspecting GPU code to gain insight into compilation
• Generating initial GPU code for subsequent hand-tuning
• Debugging the GLSL compiler itself

(compiler build instructions TBD)

Here's an example of using the compiler to compile a vertex shader and emit GL_ARB_vertex_program-style instructions:

    glslcompiler --arb --linenumbers --vs vertshader.txt

The output may look similar to this:

!!ARBvp1.0
  0: MOV result.texcoord[0], vertex.texcoord[0];
  1: DP4 temp0.x, state.matrix.mvp.row[0], vertex.position;
  2: DP4 temp0.y, state.matrix.mvp.row[1], vertex.position;
  3: DP4 temp0.z, state.matrix.mvp.row[2], vertex.position;
  4: DP4 temp0.w, state.matrix.mvp.row[3], vertex.position;
  5: MOV result.position, temp0;
  6: END

Note that some shading language constructs (such as uniform and varying variables) aren't expressible in ARB or NV-style programs. Therefore, the resulting output is not always legal by definition of those program languages.

Also note that this compiler driver is still under development. Over time, the correctness of the GPU programs, with respect to the ARB and NV languagues, should improve.