The panorama shader is used for far away objects, such as mountains, or forests. These can be placed within visibility range, and then drawn using these panorama shaders. The map is used without much lighting effects; the diffuse map is multiplied with diffuse and ambient light (lightColor+lightAmbient) to convert the texture color to klux ranges (Racer's lighting unit).

In your shader (in the .shd file) you can use 'scale=...' to scale the extinction amount (atmosphere effect) up or down. Use values between 0 and 1, where 0=full sky color and 1=fully the texture color. Anything inbetween scales the regular extinction up or down a bit. In this case, you may also want to use sky=1 to set the sorting order to let panorama objects render first (no depth writing in that case). For overlapping panorama objects, you probably need sort_offset (small integer numbers normally between -10..+10) to fix the render order between groups of overlapping panorama objects.

A shader specifically for sky domes. This shader skips on normals and vertex position a bit, so it is not suitable for generic geometry. It renders the sun disc in the sky, something which other shaders don't do (to avoid sun discs showing up in regular 3D geometry). More info on skies here.

This shader uses 1 texture; a black & white image of the clouds, where alpha determines visibility. Use the console command 'clouds <x>' with x=0..1 to influence the amount of clouds. So do NOT use a blueish texture, but rather a black and white image, to avoid over-coloring the sky.

The inverse of a detail shader. This shader takes 2 textures; first, the diffuse (regular) texturemap. In the 2nd texture unit, a blur texture is expected that will lighten and darken the diffuse map. The neutral value is (0.5,0.5,0.5) (or RGB=(128,128,128)) which will keep the brightness. Any value below 0.5 will darken the diffuse map, any value above 0.5 will lighten it.

Don't forget to add mode=linear for layer1.

The default texture scaling for the blurring texture is 0.1, so it is stretched 10 times. An example screenshot of the effect for a 2-layer Racer shader that uses standard_v.cg and standard_blur_f.cg:

The following blur image was taken:

Fragment shader only (use in conjunction with standard_v.cg). This does mostly the same thing as standard_f.cg, but burns specularity through the red channel of the texture. This is used in Carlswood for example to map the road; the specularity is burned through the red channel of the road texture, so the specularity isn't a smooth white blot but rather pixely instead.

To get more control over the burning, use standard_burn_a_f.cg instead, which uses the alpha channel.

Just using standard_f.cg:

Using standard_burn_f.cg:

(v0892) As standard_burn_f, this burns the specular lighting, but using the alpha channel instead of the red channel. This allows you to finetune the specularity color through the texture's alpha channel. See below for a screenshot that is similar to what is shown in standard_burn_f above. To the right you can see the alpha channel of the road texture.

Diffuse and detail texture. Use standard_v for the vertex shader. The 2nd texture contains the detail texture and texture coordinates are scaled compared to the regular (diffuse) map. So layer0 contains the diffuse (regular) map, layer1 the detail map. (v074+) The detail map must average to 0.5 (50% gray); where darker, the end results gets darkened. Where lighter than 50% gray, the end result is lightened. Use shader_<x>.scale to determine the amount of texture coordinate scaling; the default 'scale' value is 1.0 so make sure to set it 7.5 for example! (don't use an integer value; this increase texture tiling visibility artifacts).

Don't forget to add mode=linear for layer1.

For background info, see http://blogs.msdn.com/b/shawnhar/archive/2008/11/03/detail-textures.aspx

Mixes 2 textures using a control texture (the 3rd layer (this was the first layer until Racer v0.8.22)). The control texture's alpha decides the mixing of the 2 diffuse texture: control.a=1 (white in your image editor) means take 100% diffuse1 (the 2nd layer's texture) and control.a=0 means 100% of the 2nd diffuse texture (the 3rd layer). Also, the RGB channels of the control texture are multiplied with the mixed color to enable darkening and lightening. A 50% gray is neutral, meaning no change in brightness. Darker gray darkens the mix results, and lighter gray brightens it.

Make sure to use the most important (prevailing) texture in the first layer: projective lighting uses only the first texture in a shader so that texture will be most prominent when light in dark situations.

Don't forget to add mode=linear for layer2!

Like standard_mix2_f above, only it applies world planar mapping to the 2nd diffuse texture. The 1st diffuse texture (in layer1) uses the UV coordinates as defined in the 3D model (.dof). Used to mix trackside materials (such as kerbs) with grass or gravel next to it, where the grass continues on to a large area, all world-mapped using standard_mix1w_f. See also here for a tutorial.

All in all, these mix shaders are a bit of an experiment, and it seems nicer to just do proper mapping in your 3D editor, and not use large surfaces all built out of the same texture.

Reflection shader. As standard_v/f, only adds a reflection cubemap in the 2nd texture unit. The first texture is the diffuse map, the 2nd texture a cubemap, so $trackenvmap for example.

Uses this set for static (untransformed) object such as track objects. Car objects will need dyn_standard_reflect_v/f to apply model transformation. (v074+)

(v0.8.9+) Specifically created for trees, this shader ignores the 3D model normals and uses the 'up' vector (0,1,0) directly to light the polygons. The advantage is that the objects will be more evenly lit (see the image below). The problem with trees and grass is that they are often modeled using vertical triangles, while really representing slanted/rotated polygons (such as leaves, or grass leaves). This effectively makes the normals of these triangles point in a wrong direction, giving lighting a hard time.

The solution taken here is thus to ignore the bad normals in the 3D model and acting as if the normals of the triangles all point up, giving a nicer lighting effect.

For grass, use standard_grass_v/f instead.

Wave shader for things such as waving flags. Check out the waving flag tutorial for more info. Just use standard_f.cg for the fragment shader side of things. Use a shaders 'scale' parameter to modify the amount of displacement (v0.8.15+).

Bumpmap shader set. The 2nd texture contains the bumpmap. The bumpmap's alpha value (in v0.8.24+) indicate 'reflectiveness', where 0=non-reflective, 1=full reflective. The reflectiveness affects the specular component.

Don't forget to add mode=linear for layer1.

The mix between dyn_standard_bump_v/f and dyn_standard_reflect_v/f. It uses 3 textures; diffuse map (regular texture), normal (bump) map in the 2nd texture unit and the environment map in the 3rd texture unit. Note that the reflectivity is controlled in the bumpmap texture's alpha channel (0=no reflection, 1=full reflection).

Don't forget to add mode=linear for layer1.

OBSOLETE. use dyn_standard_bump_v/f instead.

OLD DOCUMENTATION: Like dyn_standard_bump_v/f, only this one takes its specularity color from the bumpmap (2nd) texture's alpha channel (NOT the diffuse map). Useful for tires that have both smooth and rough parts, such as F1 tires. See the 'shading cars' tutorial for an example.

The 'scale' parameter (defaults to 1.0) will scale the bumpmap's texture coordinates. Sometimes useful for converted tracks.

This is a diffuse+reflection variant useful for windows. It passes the diffuse texture's alpha channel to the fragment, which results in it being used for blending.

This shader outputs purple with alpha=0 (color 1,0,1,0) for all pixels. For older tracks that you want to convert to use Cg, you can use this fragment shader to quickly colorize all Cg shaded materials. All the objects that don't have shaders yet will still be textured (drawn using regular Racer shaders) so this Cg shader can help to find the object that still need to have Cg (and/or Racer) shaders.

For example, set vertex_shader.file to standard_v.cg and fragment_shader.file to check_shader_f.cg in your track.shd's Racer shader. A full example extract from a track.shd file:

vf_standard
{
  vertex_shader 
  {
    file=standard_v.cg
  }
  fragment_shader
  {
    file=check_shader_f.cg
  }
}
shader_guardrail~vf_standard
{
  layer0
  {
    map=guardrail.tga
  }
}