$emissiveblend

$emissiveblend on the Vortigaunt model in Episode Two. $detail has been disabled for better effect visibility.

$emissiveblend is a material shader parameter for the VertexLitGeneric shader available in all Source games since Source 2007. It provides advanced self-illumination that can be flowed using a flowmap. It is used for the Vortigaunts in Half-Life 2: Episode Two and succeeds the VortWarp shader from Half-Life 2: Episode One. All parameters must be specified except for $emissiveblendstrength in order for the effect to work properly.

Confirm:EyeRefract appears to include it as well. Verify if it properly works on it.

Note:

• $emissiveblend is additive, and does not read from the material's diffuse color.
• $emissiveblend parameters are X+ and Y-, for both flowmap and scroll. (e.g. Giving X a positive scroll vector will have it go left and giving Y a positive scroll vector will have it go up)
• This effect does not need to use a flowmap, and can instead be used as a simple emissive map. Use dummy textures (dev/null or a pure white texture with a pure black alpha channel) for $emissiveblendtexture and $emissiveblendflowtexture, and use a value of "[0 0]" for $emissiveblendscrollvector. In this instance, illumination is solely provided by the $emissiveblendbasetexture, and the time proxy is not required.

Tip:While it is normally used only on VertexLitGeneric, $emissiveblend can be plugged into custom shaders as well (or the SDK counterparts of the standard shaders), as it renders in a separate pass on top of things.

An instruction on how to do it is included in the Source 2007's source code, as well as the Alien Swarm SDK, in materialsystem/stdshaders/emissive_scroll_blended_pass_helper.cpp (although it may require minor tweaks to make it fully compatible with your platform).

Because these files aren't shipped with Source SDK 2013, you will need to copy the related .cpp, .h and .fxc files for it from either 2007 or ASW SDK.

Confirm: Check which shaders can be supplemented with it. So far had it work with SDK_LightmappedGeneric, SDK_WorldVertexTransition and SDK_Refract.

Confirm:Compatibility or lack thereof with per-vertex lighting.

Parameters

$emissiveblendenabled <boolean>

Enables the effect.

$emissiveblendtexture <texture>

The texture that scrolls by based on the flowmap and the scrolling speed parameter. Not mapped to a UV.

This is the texture that is the glow itself, overlaying the underlying base material.

$emissiveblendbasetexture <texture>

The texture used for the self-illumination. Can be colored or grayscale. Does not adopt the $basetexture's color.

You can think of it as the overall mask for the effect. It is mapped to the model's UV and stays in one place. The glowiness of $emissiveblendtexture is 'contained' within this texture based on its brightness (as in, the black pixels of $emissiveblendbasetexture won't be contributing to the glow, as the effect is additive.

The alpha channel of $emissiveblendbasetexture isn't used by the shader, so it's advised to use an alpha-less VTF format (DXT1 or BGR888) to save on file size.

$emissiveblendflowtexture <texture>

Flowmap used for the $emissiveblendtexture.

This texture controls the way $emissiveblendtexture moves. Flowmaps generate motion based on their red and green values and composition, and can be quite confusing to visualise mentally.

Tip:A flowmap that is a single color (regardless of what it is) won't contribute extra movement, and the $emissiveblendbasetexture will simply move based on the $emissiveblendscrollvector.

$emissiveblendtint <RGB matrix>

Color tint of the effect. Default "[1 1 1]".

Tints the $emissiveblendtexture. The values can go above 1 for a stronger effect.

$emissiveblendstrength <normal>

Controls the opacity of the effect. Ranges from 0 to 1; at 0, the effect is invisible, at 1, it is at full strength. Default: 1.

$emissiveblendscrollvector <vector2>

A matrix that controls the direction and speed the $emissiveblendtexture scrolls in. X (horizontal) and Y (vertical) respectively. A setting of 1 results in the texture tiling every 1 second, 0.1 every 10 seconds. 0 is no scroll. Default is "[1 1]".

Time Proxy

For any reason, you may want to modulate time by scale it. The below material proxy is a simple sample to work properly.

Note: you don't need to declare "CurrentTime" Proxie in cases where you don't need to relative modify time scale.

	"$time" "0.0"
	"$CurrentTime" "0.0" // declare a custom VMT Parameter to "CurrentTime" Proxie output
	"$timeMult" "0.5"    // declare a custom VMT Parameter to use at "Multiply" Proxie

	"Proxies"
	{
		"CurrentTime"
		{
			// It pass CurrentTime Proxie to "$CurrentTime" variable to scale materials effects such $emissiveblendscrollvector.
			"resultVar" "$CurrentTime" 
		}
		"Multiply"
		{
			"srcVar1" "$CurrentTime" // get $CurrentTime VMT parameter to multiply with srcVar2
			"srcVar2" "$timeMult"    // get $timeMult VMT parameter to multiply with srcVar1
			"resultVar" "$time"      // writes multiplication product into $time, scaling "CurrentTime" 
		}
	}

Example

Static

This is an example of a static $emissiveblend texture. It will appear just like $selfillum does.

Tip:Because $emissiveblend effectively doubles the draw calls of a model it is applied to, using it for static glow can be unnecessarily expensive, especially on meshes with high polygon count. Consider either using $selfillum if you can, or $detail with $detailblendmode 5 (if you're not already using $detail for something else).

$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

Flowing

This is an example of a flowing $emissiveblend texture. It will appear like as if water is flowing across a model.

Confirm: Why the VTF i8 requirement?

$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

The only known material using this shader parameter, found in Half-Life 2: Episode Two, materials/models/vortigaunt/vortigaunt_blue.vmt

"VertexLitGeneric"
{
	"$surfaceprop" "default"
	"$basetexture" "Models/vortigaunt/vortigaunt_base"
	"$bumpmap" "Models/vortigaunt/vortigaunt_normal"
	"$phong" "1"
	"$phongboost" "10"
	"$phongexponenttexture" "Models/vortigaunt/vortigaunt_exponent"
	"$phongalbedotint" "1"
	"$phongfresnelranges" "[.18 .4 1]"
	"$halflambert" "1"
	"$nodecal" "1"

	// Rim lighting parameters
	"$rimlight" "1"												// To enable rim lighting (requires phong)
	"$rimlightexponent" "10"										// Exponent for phong component of rim lighting	
	"$rimlightboost" "3"										// Boost for ambient cube component of rim lighting


	// Blend between color textures
	"$detail" "Models/Vortigaunt/vortigaunt_blue"
	"$detailblendmode" "3"
	"$detailblendfactor" "0.0"
	"$detailScale" "1.0"

	// Emissive Scroll Pass
	"$emissiveBlendEnabled"     "1" // Enables effect
	"$emissiveBlendTexture"     "models/vortigaunt/vortigaunt_illum"
	"$emissiveBlendBaseTexture" "Models/Vortigaunt/vortigaunt_blue"
	"$emissiveBlendFlowTexture" "models/vortigaunt/vortigaunt_flow"
	"$emissiveBlendTint"        "[1 1 1]"
	"$emissiveBlendScrollVector" "[0.11 0.124]"
	"$time" "0"
	"Proxies"
	{
		"VortEmissive"
		{
		}
		"MaterialModify"
		{
		}
		"CurrentTime"
		{
			"resultVar" "$time"
		}
	}
}

Gallery

• 

  The makeup of the $emissiveblend effect on the Vortigaunt model. $detail has been disabled for better visibility.

• 

  The effect in action. (open)

See also

• $selfillum
• VortWarp