Glowing Textures

A glowing texture is one that does not require another form of light to be lit up. It can create its own lightmap independent of all lighting sources and may even create light itself. This does not mean that the surface will appear pure white, just that the face will ignore any light it would receive. This is a key feature as a "glowing" black stays black and does not get brighter. The face achieves what is called fullbright, where the texture's pixels appear exactly the same color as they were saved.

There are several different ways to create this effect available in the Source engine.

For glowing textures on models or brush faces:

1. $selfillum parameter, specified in a material's VMT. - Use this for most purposes, not compatible with transparency.
2. UnlitGeneric shader, specified in a material's VMT - Does not emit light, forces face to ignore all lighting, making it fullbright.
3. $detail parameter with $detailblendmode value of 5 or 6, specified in a material's VMT - Same as $selfillum, but more rudimentary and compatible with transparency.
4. Using info_lighting to fool a model into thinking it is brightly illuminated.

For glowing textures on brush faces only:

1. Using Minimum Light Level entity keyvalue.
2. .rad file, mainly used for glowing textures on brushes. rad files are the only form of glowing textures that generate any map light. The file is processed line per line; on each line is simply the name of the texture, the RGB value of the light, and then the brightness of the light.

Common selfillum textures can be found in White.

$selfillum textures

Self Illumination determines where the surface is self-illuminated independent of environment lighting. A mask of such type, can make the pixels of the surface full-bright with the coloring from the color texture.

 Warning: Cannot be used with $translucent or $alphatest on models. Use the UnlitGeneric shader instead or the $detail workaround.

By default, $selfillum takes the alpha channel of the base texture and uses it as the $selfillummask (turns it into a map for how bright each pixel of the image should appear.)

This means partial brightness or even only small areas of brightness can exist. A partially bright face can still receive light that is added to the default light on the face. The VMT property must exist.

LightmappedGeneric
{
    $basetexture props/tvscreen005a
    $selfillum 1
}

If using a separate $selfillum texture

LightmappedGeneric
{    
    $basetexture props/tvscreen005a
    $selfillum 1
    $selfillummask <texture>
}

Additional parameters

$selfillumtint <RGB matrix>

Adjusts the color of the self-illumination effect. Default value is "[1 1 1]".

$selfillummaskscale <normal>

Scales the self-illumination effect strength. Default value is 1.0.

$selfillummask <texture>

A dedicated mask texture for the effect. Might not work in Source 2006.

 Bug: Doesn't work on brushes, use the alpha channel of the $basetexture instead. ($selfillum 1 only)

 Bug: Doesn't work on overlays in .

 Warning: Source 2007 MUST use this!

$selfillum_envmapmask_alpha <boolean>  (DX9+)

Has the material derive its self-illumination mask from the alpha channel of the $envmapmask.

 Note: $selfillum_envmapmask_alpha replaces the original $selfillum command, so they cannot be used together.

$selfillumtexture <texture>

Use a selfillum texture.

 Note: Deprecated since Source 2007.

 Note: use $emissiveblend instead

$selfIllumFresnel <boolean> (in all games since )  (DX9+)

Allows the material to use Fresnel ranges.

 Warning: Breaks $envmap if $normalmapalphaenvmapmask is enabled.

$selfIllumFresnelMinMaxExp <matrix> (in all games since )  (DX9+)

Default: 0.0 1.0 1.0. Not the same Fresnel ranges as $phongfresnelranges.

The first value is the minimum illumination, second value is the maximum illumination and the final value is the Fresnel exponent.

A selfillum texture in use

$detail

If $selfillum is not a viable option, a $detail texture can be used instead. It can bypass the sv_consistency check on some games, such as in or , to allow glowing textures where textures with $selfillum would cause you to be kicked from the server.

VMT lines required for a $detail glow:

       $detail models\weapons\pose\briefcase/briefcase_pickedup_red
       $detailscale 1        //scales the detail texture to same size as diffuse.
       $detailblendfactor 1  //lower values make the texture less visible. 0.0 - 1.0
       $detailblendmode 5    //6 also works.

The detail texture itself must be completely black with the parts that should be glowing colored. Dark colors will glow less. You can not make a black glowing texture this way.

The Team Fortress 2 briefcase detail glow texture

Using envmaps for a solid color glow

If for some reason you can't use $selfillum and can't do glow with $detail, you can still do a solid color glow on the material. As reflections are not affected by lighting, and appear to glow in the dark, specular reflections using cubemaps can be used. Unlike $selfillum, you can only make pixels glow in a color, additively, ie you can't make part of a texture glow, but add single color glow over it. Can be done using a white cubemap, and making the cubemap reflection visible only in some places per-pixel through an $envmapmask. You can also tint the cubemap glow to any color by $envmaptint

.rad files

 Warning:  This method will only work on world brushes

example\exampletexture 128 192 96 400

Unlike $selfillum or the UnlitGeneric shader, lights of the specified color and brightness are generated in front of the world brush's face during VRAD complation. The brightness of the created lights is also affected by the density of the lightmap. Higher densities will produce a greater effect. The texture itself does not become fullbright, but the lights in front often make it seem so.

If a texture is specified in multiple places, it will be overridden by the latest information, for example: If both lights.rad and <game>.rad specified the same texture but <game>.rad was brighter, the light emitted in the compiled map would be the brighter <game>.rad version.

A .rad texture in use

UnlitGeneric textures

The UnlitGeneric shader forces the entire face to be full bright. The surface does not emit light, and light has no visible effect on the surface. Mainly used when the texture should appear to be a light source without forcing any light into creation. All that is required for the effect is to specify the materials shader as unlit generic. Because UnlitGenerics are their own shader they can be applied to both models and world brushes.

UnlitGeneric
{
	$basetexture example\exampletexture
}

A common use is that of skybox textures, the sky is always bright and the face the texture will appear on has no form of lighting itself.

 Warning: You need to include the command $model 1 in your .vmt if you're using an UnlitGeneric on a model, otherwise the surface may not show up.

A unlitgeneric texture in use

Minimum Light Level values

This is not strictly a glowing texture per se, but another way that a texture can be made to appear to glow (without shedding any actual light) is by placing it on a surface that allows you to set the Minimum Light Level float value to control the minimum amount of ambient light the surface will reflect. The most common of these is func_brush. Setting the Minimum Light Level high (from 5 to 50 or more, depending on how light the texture is) will result in the textures on the brush glowing brightly.

 Warning: Increasing the Minimum Light Level can have a disproportionate effect on cubemap sampling, causing the scene to compile too brightly.

Minimum Light Level changes. From left to right: 0, 0.5, 2, 10, 25, and 50

Use of info_lighting

Models and prop_static entities can be made to glow brightly (though they do not actually emit any light) if their lighting origin key value is set to the name of an info_lighting that is placed in a lightbox isolated from the rest of the map. In the illustration below, the model to the right has been linked to an info_lighting placed in a small hollow cube with nine light entities, each set to a brightness of 5000.

One possibly useful feature of this method of manipulating lighting is that it dynamically updates in real time. That is, if the lights in the lightbox are linked to a switch or trigger, or pre-set to pulse, flicker, or so on, the lighting on the model or prop_static will reflect these changes immediately. This might be used, for instance, to slowly darken modeled terrain to simulate the coming of evening.