HLSL Shaders

At a very high level, data enters the graphics pipeline as per-vertex data, is processed by each of the three stages, and generates pixel colors. Briefly, each stage of the pipeline performs a series of steps:

• Vertex processing. This includes vertex transforms, per-vertex fog, per-vertex material attributes, and per-vertex lighting.
• Primitive processing. This is comprised of clipping, back-face culling, and per-primitive attribute evaluation in preparation for rasterizing.
• Pixel processing. This is broken into two parts:

  Part 1 blends texture samples with per-pixel colors, completely replacing the fixed function multi-texture blender. This processing includes: iterating colors and texture coordinates, sampling textures, and blending texture samples with lighting and material colors.

  Part 2 includes all the operations that determine what is written out to the frame buffer. This includes: alpha testing, depth testing, stencil testing, calculating per-pixel fog, alpha blending, dithering, and making gamma adjustments.

By making vertex processing and the first part of pixel processing programmable, the user can now dramatically extend the functionality of the pipeline by implementing custom functionality in each of these stages.

• Vertex Shader Basics
• Pixel Shader Basics
• HLSL Language Basics
• Writing HLSL Shaders
• Using HLSL Shaders
• HLSL Tutorials
• Getting Started Debugging Shaders
• Shader Model 3

Programmable high-level shader language (HLSL) shaders use the HLSL compiler to generate asm shader code from HLSL source code.

A Simple HLSL Shader

To program this enormous variability, a shader language called HLSL was created to design these programmable shaders. Simply design and build shaders in HLSL and compile each shader into an Asm shader.

Here is an example of a vertex shader that implements the minimum vertex processing. This shader transforms vertex position from object space to projection space and assigns per-vertex color from the vertex input.

float4x4 mWorldViewProj;  // World * View * Projection transformation

struct VS_OUTPUT
{
    float4 Position   : POSITION;  // vertex position 
    float4 Diffuse    : COLOR0;    // vertex diffuse color
};

VS_OUTPUT Vertex_Shader_Transform( 
    in float4 vPosition : POSITION,
	in float4 vColor : COLOR0
 )
{
    VS_OUTPUT Output;
	
    // Transform the vertex into projection space. 
    Output.Position = mul( vPosition, mWorldViewProj );
    
    // Output the diffuse color.
    Output.Diffuse = vColor;
    
    return Output;
}

Here is an example of a simple pixel shader. This shader simply copies the interpolated per-vertex color data, and outputs a pixel color.

float4 Pixel_Shader( VS_OUTPUT in ) : COLOR0
{
    float4 color = in.Color;
	
    return color;
}

These shaders looks very much like C code and contain one global variable, one data structure, and two functions. By browsing these shaders you can see that:

• The shaders are readable.
• The shaders use standard HLSL math functions like mul - HLSL, which does a matrix multiply.
• In addition to standard C syntax, HLSL introduces a few new data types like float4 and float4x4 that make it easier to map the shader to hardware shaders.
• HLSL defines semantics like POSITION And COLOR0 for inputs that are streamed into the shader from a vertex buffer.