Infected (shader)

From Valve Developer Community
Revision as of 07:55, 11 October 2020 by Breakin' Benny (talk | contribs) (Breakin' Benny moved page Infected to Infected (shader): There's a point entity called simply "infected")
Jump to: navigation, search

The Infected shader is used in <Left 4 Dead 2> Left 4 Dead 2 to dynamically render wounded zombies and body parts.

Instead of relying on gibbed variations of all models, this shader is used on the models to remove whichever body part was shot at to look more realistic, and allows for adding different types of slashes and dynamic gore and flesh effects.

The model will simply render hollow, however. So the programmer or artist would need to place skeleton and flesh models inside of the holes that were created, in order to create a convincing effect. To do: Add some images from the game or the presentation here.

To do: How does this shader relate to $shinyblood of VertexLitGeneric?

Note.png Note: This shader only works on models.

How the Shader Constructs the actual Base Texture

This shader is quite complex and no texture supplied to this shader is actually a base texture (despite the name of $basetexture).

Here is how the actual base texture is constructed.

All of this layer's color is sampled from the $gradienttexture. Two samples are taken from the $gradienttexture:

PalletRowSelector_A = RandomInteger{from 0 to 7}
PalletRowSelector_B = RandomInteger{from 0 to 7}
Sample_A.color = $gradienttexture.sample($basetexture.alphaChannel.sample(u,v), 1/32 + PalletRowSelector_A*1/16) • Generally used for Clothing
Sample_B.color = $gradienttexture.sample($basetexture.alphaChannel.sample(u,v), 1/32 + PalletRowSelector_B*1/16 + 0.5) • Generally used for Skin

Notice Sample_B is always sampled 0.5 above Sample_A. The blue channel from $basetexture is then used to linearly interpolate between these 2 colors.

  • A blue value of 0.00 will return the color of Sample_A.
  • A blue value of 1.00 will return the color of Sample_B.
  • A blue value of 0.35 will return 65% of Sample_A and 35% of Sample_B mixed together.

Each of these samples are always taken from the same row of pixels. From row 0 to 7 for Sample_A and from row 8 to 15 for Sample_B. This allows for variation of color between otherwise duplicate models.

Note.png Note: Currently I did not figure out if the row could be set. Right now it seems that the game chooses during runtime.

Shader Parameters

Note.png Note: Due to the fact that the source code is inaccessible, many shader parameters and features are not further explained and require further testing.

Check out left4dead2/materials/models/infected/common/l4d2/ci_body_include.vmt for a sample material that uses the shader.

General

$basetexture <texture>
Unlike other shaders, this parameter serves a completely different role. The $basetexture acts as an assembly texture, where each channel supplies the information needed to construct one complex texture. It is quite complicated.
Each channel's purpose is as follows:
Red: 2 Functions
◘ ??? [000-127] Does something but I can't quite figure it out.
◘ Detail blend mask. [128-255] Less than 128 does nothing. 255 fully blends detail.
Green: 2 Functions
◘ Eye Glow. [000-127] Glows on contact with flashlight. 0 is full glowyness. Greater than 127 does nothing.
◘ Blood. [128-255] Less than 128 does nothing. 255 fully blends blood using the color $bloodcolor. It seems to blend similar to the "color burn" method.
Blue: Blends between 2 samples from the $gradienttexture. If your textures are well planned, you might find it useful to blend with this channel. Otherwise it is really only useful to use values 0 and 255 (nothing between). If you really know how to use an image editor like a magician, you could technically have 256 gradients to work with.
Alpha: U-Coordinate of Gradient Texture Sampler. Think of this as an indexed image. This channel provides values from 0-255. These values point to the gradient texture which always has a width of 256 (0-255 inclusive).
◘ Functions marked with a '◘' are split up into quadrants similar to a sprite sheet. This allows for more variations without using animation frames. A random quadrant per model will be chosen during runtime (when the models spawns in game).
When creating this $basetexture be VERY sure that you "save color values for transparent pixels". If you don't do this, you will get seemingly random artifacts. With out this setting: All pixels with alpha=0 will also have red, green, and blue values set to 0.
$nocull <bool>
Determines whether the backsides of faces can be seen. If a model is sliced open, you will see the insides of the model as well.
$translucent <bool>
Disables dynamic shadows on the model.
$cheapdiffuse <bool>
According to a VMT comment: "test stuff, doesn’t do anything right now".
$rttshadowbuild <bool>
Unknown. May be related to RTT shadow rendering. Default value is 0, setting to 1 changes shader combination and renders the model as white.
$translucent_material <string>
Unknown. Possibly allows for a translucent render pass.
$gradienttexture <texture>
Less of a gradient, more of a color palette. This is the texture that will be sampled to give the "true basetexture" its color.
IF you are creating your own $gradienttexture textures THEN I highly recommend choosing lossless VTF formats such as <"Normal Format = "BGR888" OR "BGRA8888"> and <"Alpha Format" = "BGRA8888">. Also; For $basetexture and $gradienttexture, you may want to set the VTF's flag "Point Sample" to true. This does turn your texture pixelated but any other interpolation methods may create rainbows. Rainbows occur when the $gradienttexture is not very gradienty. For example: In your $basetexture: If you have two pixels the are next to each other and one has value 15 and the other has a value of 100... well, linear interpolation will grab all the colors of the $gradienttexture that are from 15 to 100. Most likey you don't want that.}}
$sheetindex <int>
$colortintgradient <int>
Unknown. Possibly controlled during runtime. (It would make sense to me if this set PalletRowSelector_A as I stated above. Allowing 8 different variations of color.)
$ambientocclusion <bool>
Enables ambient occlusion on the model (for example in Source Filmmaker).
Note.png Note: While this shader supports many of VertexLitGeneric's shader parameters, it does not support $bumpmap due to the complexity of the shader. From Shading a Bigger, Better Sequel - Techniques in Left 4 Dead 2 and GDC Vault

Wounds

The most interesting part of this shader is the wound calculation. Set $wounded 1 to enable it.

To debug the wounds, you can use following shader parameters:

$debugellipsoids <bool>
Enables debugging ellipsoids. These can be positioned using other shader parameters to mess with the effect.
There are two debugging ellipsoids with different functionality. Only the second one is currently known to work: it bursts a hole into the model where it intersects.
Leaving out the 2 from the next four shader parameters controls the ellipsoid 1, but no effects could be seen.
$ellipsoidcenter2 <vector>
Center of the ellipsoid 2, in local space (0 0 0 should be the entity's origin).
$ellipsoidup2 <vector>
The up axis of ellipsoid 2. Z-up (0 0 1) by default.
$ellipsoidlookat2 <vector>
The direction that the ellipsoid 2 faces.
$ellipsoidscale2 <vector>
The size of the ellipsoid 2, in local coordinates.
$ellipsoid2culltype <int>
Unknown. 0 seems to be regular culling of ellipsoid 2, other values disable the ellipsoid. (This parameter does not exist for ellipsoid 1.)


The following shader parameters are unknown in function, but seem to be related to the wound rendering. They do not seem to influence the debugging ellipsoid culling at all.

$woundcutouttexture <texture>
Texture containing masks for blood and shapes of the wounds.
$cutouttexturebias <float>
When the cutout texture should mask the wound. Values below 0.5 hide the entire model when using debugging ellipsoids.
$cutoutdecalfalloff <float>
Unknown.
$cutoutdecalmappingscale <float>
Unknown.

Phong

$phong <bool>
$phongboost <float>
$phongtint <vector>
$phongfresnelranges <vector>
$halflambert <bool>
See the relevant articles for these commands. They function identically to VertexLitGeneric's counterparts. However, $phongexponent related options do not work. See below for replacement options.
$defaultphongexponent <float>
Equivalent to $phongexponent, except for any unmasked parts of the texture.

Detail

The detail pass is controlled by the top half of the red channel of the $basetexture.

&detail <texture>
The texture to use to add some detail to the model. Blended onto the model using the top half of the red channel of the &basetexture.
Unlike other textures in Source, this texture is actually transformed differently.
In order to convert a regular $basetexture to the equivalent $detail texture (with same UV mapping), you will need to:
# Mirror it horizontally
# Rotate it by 90° counter-clockwise
# Use a $detailscale of 1
&detailscale
Scales the &detail texture AND the $burndetailtexture.
$detailframe
Not sure. My guess is setting an integer value (from 0 to 3) OR (from 1 to 4) set the quandrant to use for detail. (as described by $basetexture)
$detailblendfactor
 ??

Skin

There is not really a skin pass as it is part of the Actual Base Texture. Although the original images from the game L4D2 seem to use it on the skin, eyes, and teeth; I don't believe this is entirely necessary. The only time it would be a problem to not follow this rule is: if you really need different phongexponents for skin and non-skin. I'm sure it was so they could use a palette for the clothes and a separate palette for the skin. (see "How the Shader Constructs the actual Base Texture" above)

$skintintgradient <int>
Unknown. Possibly controlled during runtime. (It would make sense to me if this set PalletRowSelector_B as I stated above. Allowing 8 different variations of color.)
$skinphongexponent <float>
Equivalent to $phongexponent, except for skin parts of the texture (blue channel).

Blood

The blood pass is controlled by the green channel of the $basetexture.

$bloodcolor <color>
Color of the blood pass.
$bloodphongexponent <float>
Equivalent to $phongexponent, except for blood parts of the texture (green channel).
$bloodspecboost <float>
Equivalent to $phongboost, except for blood parts of the texture (green channel).
$bloodmaskrange <vector2>
Unknown. Seems to modify the phong shape on blood.

To do: Something seems wrong! A fully red basetexture is affected by the values of $bloodspecboost and $bloodphongexponent, and $phongboost and $phongexponent do nothing! ???

Burning

$burning <bool>
Controls whether the material should appear burning. It needs to be in a different VMT with a "_burning" prefix. The game will switch to this other VMT on frame 0 after detecting that the model has caught fire. Opacity starts with 0 and it slowly increases based on $burnstrength.
$burnstrength <float>
Opacity of the burning effect. Defaults to 0.
$burndetailtexture <texture>
The texture to apply to the model when the model has been burned. This textures scale is controlled by &detailscale

Eyeglow

The eyeglow pass is controlled by the bottom half of the red channel of the $basetexture.

$eyeglow <bool>
Set to 1 to enable the effect. Causes an additive color overlay, as well as different phong settings.
$eyeglowcolor <color>
Color of the effect.
$eyeglowflashlightboost <float>
Phong boost for the effect, in case the model is hit by projected texture lighting such as the flashlight.

SFM integration

Since Source Filmmaker version 0.9.8.9 (released 27 Aug, 2014), the Infected shader is supported and integrated into the program.

Creating an animation set with the shader will automatically generate the following attributes as part of the DmeGameModel:

infectedSkinTint <int>
infectedClothesTint <int>
Unknown. May be related to the gradient texture controls.
infectedTextureIndex <int>
Controls which of the four quarters of the $basetexture get selected for display (see above for detailed information).
0 is top left, 1 is top right, 2 is bottom left, 3 is bottom right.

See also

Rendering Wounds in Left 4 Dead 2

L4D2 CI Texture Guide