Home

Out with Cg, in with GLSL.

Introduction

GLSL has since long been a part of the OpenGL standard. Back when Racer started using GPU shaders, the language wasn't quite stable yet. But it has grown since then, and has some features that make it interesting now.

• Tight integration with OpenGL
• Support for UBO's (Uniform Buffer Objects) to pass multiple global variables to a multitude of shaders.

There are some drawbacks as well though.

• Parameter access to the OpenGL state seems to have been removed since OpenGL version 3.0.
• No preprocessor that supports #include

Therefore, Racer has created its own shell around the thin layer of GLSL, to be more programmer-friendly.

Racer's GLSL implementation

Racer uses GLSL but has some additions and prerequisites:

• #include has been added to be able to (recursively if needed) add other files into the mix. So this is not a feature of GLSL but is done inside Racer. A series of #line commands keeps any errors/warnings displaying the correct file and line number, even though all text is just pasted into one big source code string.
• gl_FragColor was dropped in GLSL v1.30, and has to be done explicitly. To be consistent, Racer requires the variable 'fragColor' which will do the same thing. For example:

out vec4 fragColor;
void main(void)
{
  fragColor=vec4(1.0, 0.0, 0.0, 1.0);
}

Uniform block parameters

GLSL allows 'uniform blocks'. These are GPU-located buffers where a number of parameters are set. These parameters can be shared across all programs. For example, with Cg, Racer had to set the ModelViewProject matrix (MVP) for all shaders separately each frame. With GLSL, you can set one global block of parameters that apply to all GLSL programs, and be done with it.

Racer hardcodes a uniform block that is defined in data/renderer/common/globals.glsl. This is defined as:

layout(std140) uniform WorldGlobals
{
... (parameter definitions)
} globals;

This defines a structure that should not be modified by the user, as it is reflected in Racer itself (in C++). The name 'WorldGlobals' stems from 'World', which is the internal name for the scenegraph/rendering engine that Racer uses.

Parameters are then referenced using for example globals.modelViewProj. A number of parameters that are the same for each program is listed below:

Uniform names

GLSL uses 'uniform' variables to pass parameters that don't change per vertex, but at most only once per object/shader. In principle it would be possible to create a binding from a uniform name to a uniform's contextual meaning (like 'bind mvp ModelViewMatrix') but that means that you have to learn the binding meanings anyway. Racer is taking the way that the uniform names must be specific, so they can be found and set to their intended value.

These uniforms normally vary per material (Racer shader); a lot of parameters are in the 'globals' uniform block above. However, some parameters such as diffuse/ambient colors can differ per material, so are defined locally per GLSL program.

Here is a list of the currently defined uniform names. They must be used exactly for Racer to find them, and set them to the correct value.

Attribute names

GLSL uses 'attribute' variables to pass per-vertex data. Similary to uniforms, these variables must be given explicit names to work ok. According to nVidia, a lot of these attribute indices are hardcoded, to be compatible with older software. For example, vertex data is attribute index 0, normals are attribute index 2 etc.

Here is a list of the currently defined attribute names. They must be used exactly for Racer to find them, and set them to the correct value. For example:

• in vec4 inVertex;
  
• in vec3 inNormal;
  

Convert Cg into GLSL

Racer has used Cg for a long time, so you might be familiar with it. Here is a list of things you will encounter when transitioning from Cg to GLSL:

• float2, float3 and float3 are now vec2, vec3 and vec4. These types are just syntax problems.
• float4x4 is now mat4. Same for float3x3 and float2x2.
• No explicit context definition for inputs/outputs. Things like 'float intensity: TEXCOORD5' now become separate in- and outputs in the vertex & fragment shaders.
• lerp() in Cg is mix() is GLSL.
• The mul() command has swapped parameters! (Cg: mul(matrix,vector), GLSL: mul(vector,matrix) ). An important one which can cause bugs.
• saturate() in Cg does not appear in GLSL, which may just be as well since saturate(x) does clamp(x,0,1) while you might expect a saturate command to clamp the maximum value only. The conversion is as stated: clamp(x,0.0,1.0).

(last updated November 13, 2012 )