View source for Glowing textures (Source)

{{LanguageBar}}
{{tabs|Glowing textures|goldsrc=1|source=1|source2=1}} {{src topicon}}
[[Category:Lighting]][[Category:Material System]][[Category:VMT Lighting]]
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''':
* <code>$selfillum</code> parameter, specified in a [[material]]'s [[VMT]]. - Use this for most purposes, not compatible with transparency.
* {{ent|$detail}} parameter with <code>$detailblendmode</code> value of 5 or 6, specified in a [[material]]'s [[VMT]] - Same as <code>$selfillum</code>, but more rudimentary and compatible with transparency.
* {{ent|UnlitGeneric}} shader, specified in a [[material]]'s [[VMT]] - Does not emit light, forces face to ignore all lighting, making it [[fullbright]].
For glowing textures on '''brush faces''' only:
* Using the {{code|_minlight}} [[entity]] keyvalue.
* [[RAD file]], mainly used for glowing textures on brushes ("[[texlight]]s"). '''RAD files are the only form of glowing textures that generate any map light.''' The file is processed line-by-line; each line is simply the name of the texture, the RGB value of the light, and then the brightness of the light. Common generic texlights can be found in [[White]].
* {{cmd|%CompileNoLight}} [[material map compile flag]] - Disables generating lightmaps for a face even if using a lightmapped shader, making it fullbright. Not compatible with other compile flags without modifying VBSP.
For glowing textures on '''models''' only:
* {{ent|$emissiveblend}} parameter, specified in a [[material]]'s [[VMT]]. - Also compatible with Transparency, can be animated via flowtexture like [[Water_(shader)|water]].
* Using {{ent|info_lighting}} to "fool" a model into "thinking" it is brightly illuminated.

[[File:Source glow comparision.png|400px|thumb|An image showing the differences between Selfillum, Emissiveblend and Detail glows.<br> (Click to Enlarge)]]



==<code>$selfillum</code>==
Self illumination applies "fake" light to a surface, regardless of the true light that the surface receives from the environment. This is useful for parts of a model that emit their own visible light, like the filament in a light bulb or a glowing LED on a control panel. The self illumination effect can be masked with a texture.

{{warning|<code>$selfillum</code> cannot be used with <code>$translucent</code> or <code>$alphatest</code> on [[model]]s. Use the <code>UnlitGeneric</code> shader instead or the <code>$detail</code> workaround.}}
{{warning|Selfillum does not work with [[$phong]]. Selfillum only works with [[$normalmap]], but [[$phong]] only works with [[$bumpmap]], therefore making Phong and Selfillum mutually exclusive by proxy. This can be worked around by using <code>$selfillummask</code> and <code>$basemapalphaphongmask</code>
: {{ModernConfirm|Check for which platforms this is true. <code>$selfillum</code> doesn't require <code>$normalmap</code> at all and seems to work completely fine with <code>$phong</code> in at least {{hl2}} {{hl2ep1}} {{hl2ep2}} {{src07}} {{src13sp}} {{tf2}}.}}}}
{{modernImportant|Requires {{cmd|sv_pure}} to be set to {{code|-1}} in some games; see [[#$detail|$detail method]] for a workaround.}}

 [[LightmappedGeneric]]
 {
     [[$basetexture]] props/tvscreen005a
     '''$selfillum 1'''
 }

By default, <code>$selfillum</code> uses the [[alpha channel]] of the base texture as a mask. If the alpha channel of your base texture is used for something else, you can specify a separate <code>$selfillummask</code> texture.

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

With an opaque mask, <code>$selfillum</code> effectively works like <code>UnlitGeneric</code>. The surface will ignore all light from the environment and appear fullbright.

Mask values below 1.0 apply a minimum brightness effect to the surface, while still allowing it to receive light from the environment. This threshold effect is useful for objects like computer screens, which should be visible in darkness but become overwhelmed in bright sunlight.

===Additional Parameters===
{{MatParam|$selfillumtint|RGB matrix|Adjusts the color of the self-illumination effect. Default value is "[1 1 1]".}}
{{MatParam|$selfillummaskscale|normal|Scales the self-illumination effect strength. Default value is 1.0.
{{Note| Does not exist on {{src13}}, does exist on {{ent|VertexLitGeneric}} in {{as|2 }}}}
{{todo| In what other branches does this parameter exist?}}}}
{{MatParam|$selfillummask|texture|A dedicated mask texture for the effect. Might not work in {{src06|2}}.
: {{Note|Works like a color map.}}
: {{bug|Doesn't work on overlays in {{csgo|4}}.}}
: {{todo|How does this feature react to $phong in other branches than {{as}}? }}
: {{warning|Not on {{ent|LightmappedGeneric}}, must use Alpha Channel of the <code>$basetexture</code> instead. (<code>$selfillum 1</code> only)}}
: {{warning|Doesn't work on {{ent|VertexLitGeneric}} when {{ent|$bumpmap}} is present, except in {{as|2}} when {{ent|$phong}} is present.}}
: {{warning|{{src07|4}} MUST use this!}}}}
{{MatParam|$selfillum_envmapmask_alpha|bool|dx9=1|Has the material derive its self-illumination mask from the alpha channel of the {{ent|$envmapmask}}.
: {{Note|<code>$selfillum_envmapmask_alpha</code> replaces the original <code>$selfillum</code> command, so they cannot be used together.}}
: {{Note|this mask is multiplied by 8. So to archive same results as other mask methods remember to divide <code>$selfillumtint</code> by 8}}
: {{warning|Only on {{ent|VertexLitGeneric}} - Note that <code>$envmapmask</code> does not work '''with''' {{ent|$bumpmap}} or {{ent|$phong}} on VertexLitGeneric.}}
}}
{{MatParam|$selfillumtexture|texture|Use a selfillum texture.
: {{Note|Deprecated since {{src07|4}}.}}
: {{Note|use {{ent|$emissiveblend}} instead}}}}
{{MatParam|$selfIllumfresnel|bool|shaders=VertexLitGeneric|Allows the material to use Fresnel ranges.
: {{warning|Disables <code>$normalmapalphaenvmapmask</code> if enabled.
: {{warning|Doesn't work with {{ent|$detail}} or {{ent|$lightwarptexture}}, unless using {{ent|$phong}}.}}
: {{warning|Requires {{ent|$bumpmap}}.}}
}}|since={{src07}}|dx9=1}}
{{MatParam|$selfIllumFresnelMinMaxExp|matrix|Default: 0.0 1.0 1.0. Not the same Fresnel ranges as <code>[[Phong materials#Phong Fresnel ranges|$phongfresnelranges]].</code>
: The first value is the minimum illumination, second value is the maximum illumination and the final value is the Fresnel exponent.|since={{src07}}|dx9=1}}
[[File:glow_selfillum.jpg|thumb|256px|left|A selfillum mask texture.]]{{clr}}

==<code>$detail</code>==
If <code>$selfillum</code> is not a viable option, a {{ent|$detail}} texture can be used instead. It can bypass the {{cmd|sv_consistency}} check on some games (on modern branches, {{cmd|sv_pure}} set to anything other than {{code|-1}}), such as in {{css|4}} or {{l4d2|4}}, to allow glowing textures where textures with <code>$selfillum</code> would cause you to be kicked from the server. 

VMT lines required for a <code>$detail</code> glow:
<source lang=php>
$detail   "models/weapons/pose/briefcase/briefcase_pickedup_red"
        
$detailscale 1        // scales the detail texture to same size as diffuse texture.
  
$detailblendmode 5    // 6 also works. 1 can be used if both are unavailable 
                      // (such as on LightmappedGeneric), although it will still 
                      // be affected by lighting.
</source>
{{mono|$detailblendfactor}} can additionally be used to make the texture less bright.

The detail texture itself must be completely black with the parts that should be glowing colored. Dark colors will glow less. You cannot make a black glowing texture this way.
[[File:Detail glow briefcase.png|thumb|223px|left|The [[TF2|Team Fortress 2]] briefcase detail glow texture]]{{clr}}

==$emissiveblend==
[[$emissiveblend|$Emissiveblend]] is another alternative if $selfillum and $detail can not be used.<br>
As an example, melee weapons in {{l4d2}} [[Left 4 Dead 2]] that use $phong can not use $selfillum because $selfillum breaks when $bumpmap is used, which $phong requires. They also can't use $detail for glow, because the blood overlay already uses $detail. So the only option is $emissiveblend<br>
Originally, $emissiveblend is supposed to be used for glowing and flowing textures, specifically the Vortigaunts blue shimmer in {{ep2}} [[Half-Life 2: Episode Two]] where Alyx is being healed. However, it can also function as a basic selfillum alternative.

=== Static===
This is an example of a static $emissiveblend texture. It will appear just like [[$selfillum]] does.
<source>
$EmissiveBlendEnabled 		1					// Enable EmissiveBlend. Like $selfillum 1	
$EmissiveBlendStrength 		1 					// how strong the entire glow effect is.
$EmissiveBlendTexture 		vgui/white			// This will be useless, but is required.
$EmissiveBlendBaseTexture 	Glow_texture_color	// this is the glowing texture.vtf
$EmissiveBlendFlowTexture 	vgui/white	 		// EmmisiveBlend can "flow" or move. But ours is static, so a white texture is used.
$EmissiveBlendTint 			" [ 1 1 1 ] "		// RGB glow intensity. Leave at 1 1 1. This can be used to change how strong each color should glow. So instead of using a darker red color, you may use [.5 1 1] to have red glow half as strong.
$EmissiveBlendScrollVector 	" [ 0 0 ] " 		// makes the EmmissiveBlend flow in either direction if a proper EmissiveBlendFlowTexture were set. But ours is static, so leave at 0 0
</source>
{{l4d2|4}} Should you want a material that allows Envmaps with masks, Phong with mask, Detail and EmissiveBlend glows together, you may use this premade material:
{{ExpandBox|<source>
VertexLitGeneric
{
	//Textures
	$baseTexture 				baseTexture_with_envmap_mask	//alpha mask is the envmap mask
	$bumpmap 					bumpmap_with_phong_mask			//alpha mask contains mask for phong.

	//Envmap Stuff
	$basealphaenvmapmask 		1					
	$envmap 					env_cubemap

	//Phong Stuff
	$phong 						1
	$phongboost 				10
	$phongexponent 				1
	$phongfresnelranges 		"[.1 .4 2]"	
	
	//Glow Stuff
	$EmissiveBlendEnabled 		1					
	$EmissiveBlendStrength 		1 					
	$EmissiveBlendTexture 		vgui/white			
	$EmissiveBlendBaseTexture 	Glow_texture_color	//change this to your desired static glow.
	$EmissiveBlendFlowTexture 	vgui/white	 		
	$EmissiveBlendTint 			" [ 1 1 1 ] "		
	$EmissiveBlendScrollVector 	" [ 0 0 ] " 		

	//Detail Stuffs
	$detail 					"models/infected/hunter/hunter_01_detail.vtf"
	$detailscale 				"1.75"
	$detailblendfactor 			1 
	$detailblendmode 			0
	$detailAmount 				0
}
</source>}}

=== Flowing ===
This is an example of a flowing $emissiveblend texture. It will appear like as if water is flowing across a model.
<source>
$EmissiveBlendEnabled 		1						// Enable EmissiveBlend. Like $selfillum 1	
$EmissiveBlendStrength 		1 						// how strong the entire glow effect is.
$EmissiveBlendTexture 		Glow_texture_color		// this is the glowing texture.vtf
$EmissiveBlendBaseTexture 	Glow_texture_mask		// This is the glowing texture's mask, like $selfillummask.  SHOULD BE VTF i8 FORMAT, NOT DXT5!!!
$EmissiveBlendFlowTexture 	Glow_texture_mask_flow	// EmmisiveBlend can "flow" or move. This here is the flowmap used, just like water.
$EmissiveBlendTint 			" [ 1 1 1 ] "			// RGB glow intensity. Leave at 1 1 1. This can be used to change how strong each color should glow. So instead of using a darker red color, you may use [.5 1 1] to have red glow half as strong.
$EmissiveBlendScrollVector 	" [ 0 0 ] " 			// makes the EmmissiveBlend flow in either direction if a proper EmissiveBlendFlowTexture were set. But ours is static, so leave at 0 0
</source>

==Using <code>envmap</code>s for a Solid-Color Glow==
If for some reason you can't use <code>$selfillum</code> and can't do glow with <code>$detail</code>, 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 <code>$selfillum</code>, you can only make pixels glow in a color additively, i.e., you can't make part of a texture glow, only add a 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 {{ent|$envmapmask}}. You can also tint the cubemap glow to any color by {{ent|$envmaptint}}.

==<code>.rad</code> files==
{{main|RAD file}}
 example\exampletexture 128 192 96 400

Unlike <code>$selfillum</code> or the <code>UnlitGeneric</code> 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. If both {{ent|lights.rad}} and <code><mapname>.rad</code> specified the same texture, but <code><mapname>.rad</code> was brighter, the light emitted in the compiled map would be the brighter <code><mapname>.rad</code> version.
[[File:glow_rad.jpg|thumb|256px|left|A .rad texture in use]]{{clr}}

More info on how this light system works can be found [[Lightmap|here]].

=={{ent|UnlitGeneric}} Textures==
The <code>UnlitGeneric</code> [[shader]] forces the entire face to be fullbright. 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 <code>UnlitGeneric</code>. Because <code>UnlitGeneric</code>s 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 {{ent|$model|1}} in your <code>.vmt</code> if you're using an <code>UnlitGeneric</code> on a model, otherwise the surface may not show up.}}

[[File:glow_unlit.jpg|thumb|256px|left|A unlitgeneric texture in use]]{{clr}}

== <tt>_minlight</tt> ==
[[File:minimum_light_level_manipulation.jpg|thumb|256px|right|{{mono|_minlight}} changes. From left to right: 0 (default), 0.5, 2, 10, 25, and 50]]
All [[lightmap]]ped [[brush entities]], as well as [[worldspawn]], support the {{code|_minlight}} [[KV]] ("Minimum Light Level" in some [[FGD]] entries), which controls the minimum amount of of ambient light to add to the contained lightmaps. 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). Setting  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 {{code|_minlight}} can have a disproportionate effect on cubemap sampling, causing the scene to compile too brightly.}}

{{note|Psuedo-entities which collapse to {{ent|worldspawn}}, such as {{ent|func_detail}} and (in games before {{l4d}}) {{ent|func_ladder}}, use {{code|worldspawn}}'s {{code|_minlight}} value in stock compilers, as they are part of worldspawn by the time VRAD runs.
{{code fix|Custom compilers could circumvent this limitation by having the custom VBSP write additional metadata next to the BSP, which is read by the custom VRAD. This is what {{idtech2}}{{goldsrc}}[[ericw-tools]] does. It would also make it easy to add minlight support to [[vhv|per-vertex-lit]] and [[ppl|lightmapped]] [[prop_static]] entities, without making compatibility-breaking changes to the static prop lump in the BSP.}} }} {{clr}}

== <tt>[[info_lighting]]</tt> ==
[[File:lightsource_manipulation.jpg|right|Effect of linking a model to an info_lighting in a lightbox]]
Models 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 <code>info_lighting</code> that is placed in a lightbox isolated from the rest of the map. In the illustration to the right, the model to the right has been linked to an <code>info_lighting</code> placed in a small hollow cube with nine {{ent|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 will reflect these changes immediately. This might be used, for instance, to slowly darken modeled terrain to simulate the coming of evening.

{{note|Use info_lighting for static props only. For dynamic props, use an active [[edict]] entity (info_target if necessary).}}{{clr}}