Pixel Shader Semantics in VS .NET

Generation QR Code in VS .NET Pixel Shader Semantics

Just like vertex shaders, pixel shader semantics identify where data comes from. Semantics are optional identifiers that identify shader inputs and outputs. Semantics appear in one of the following three places:

After a structure member After an argument in a function s input argument list After the function s input argument list

The following example uses the same structure for vertex shader outputs and pixel shader inputs. The pixel shader returns a color which uses a semantic after the function s argument list to identify it.

struct VS_OUTPUT { float4 Position : POSITION; float3 Diffuse : COLOR0; float3 Specular : COLOR1; float3 HalfVector : TEXCOORD3; float3 Fresnel : TEXCOORD2; float3 Reflection : TEXCOORD0; float3 NoiseCoord : TEXCOORD1; }; float4 PixelShader_Sparkle(VS_OUTPUT In) : COLOR { float4 Color = (float4)0; float4 Noise = tex3D(SparkleNoise, In.NoiseCoord); float3 Diffuse, Specular, Gloss, Sparkle; Diffuse = In.Diffuse * Noise.a; Specular = In.Specular; Specular *= Specular; Gloss = texCUBE(Environment, In.Reflection) * saturate(In.Fresnel); Sparkle = saturate(dot((saturate(In.HalfVector) - 0.5) * 2,

7

(Noise.rgb - 0.5) * 2)); Sparkle *= Sparkle; Sparkle *= Sparkle; Sparkle *= Sparkle * k_s; Color.rgb = Diffuse + Specular + Gloss + Sparkle; Color.w = 1; return Color; }

The members of VS_OUTPUT all contain semantics; they all contain values returned from the vertex shader and read as pixel shader inputs. Three other inputs are global (uniform) variables that are set by the application: Environment, SparkleNoise, and k_s. Environment and SparkleNoise are both textures that must be created and set by the application (or an effect), and k_s is a constant register that must be set by the application. Global variables are assigned to registers automatically by the compiler. Global variables are also called uniform parameters because the contents of the variable are the same for all pixels processed each time the shader is called. Input semantics for pixel shaders map values into specific hardware registers for transport between vertex shaders and pixel shaders. Each register type has specific properties. Because there are only two valid input semantics (TEXCOORD and COLOR), it s common for most data to be marked as TEXCOORD, even when it isn t a texture coordinate. Notice that the vertex shader output structure defined a member with a POSITION semantic, which is not used by the pixel shader. HLSL allows valid output data of a vertex shader that s not valid input data for a pixel shader, provided that it s not referenced in the pixel shader. Input arguments can also be arrays. Semantics are automatically incremented by the compiler for each element of the array. This example shows explicit semantics:

struct VS_OUTPUT { float4 Position : POSITION; float3 Diffuse : COLOR0; float3 Specular : COLOR1; float3 HalfVector : TEXCOORD3; float3 Fresnel : TEXCOORD2; float3 Reflection : TEXCOORD0; float3 NoiseCoord : TEXCOORD1; }; float4 Sparkle(VS_OUTPUT In) : COLOR

The preceding explicit declaration is equivalent to the following declaration, which will have semantics automatically incremented by the compiler:

float4 Sparkle(float4 Position : POSITION, float3 Col[2] : COLOR0, float3 Tex[4] : TEXCOORD0) : COLOR0 { // Shader statements ...

Just like input semantics, output semantics identify data usage for pixel shader output data. Many pixel shaders write to only one output, COLOR0. Pixel shaders can also write to DEPTH0 and into multiple render targets at the same time (up to four). Like vertex shaders, pixel shaders use a structure to return more than one output. This shader outputs four colors as well as depth:

struct PS_OUTPUT { float4 Color[4] : COLOR0; float Depth : DEPTH; }; PS_OUTPUT main(void) { PS_OUTPUT out = (PS_OUTPUT)0; // Shader statements ... // Write up to four pixel shader output colors out.Color[0] = ... out.Color[1] = ... out.Color[2] = ... out.Color[3] = ... // Write pixel depth out.Depth = ... return out; }

Pixel shader output colors must be of type float4. When writing multiple colors, all output colors must be used contiguously. In other words, COLOR1 can t be an output unless COLOR0 has already been written. Pixel shader depth output must be of type float1. See Appendix C for a complete list of pixel shader input and output semantics.