MSDN Documentation

HLSL Basics

High-Level Shading Language (HLSL) is a proprietary shading language developed by Microsoft for Microsoft Windows. It is used to write shaders for DirectX. Shaders are small programs that run on the graphics processing unit (GPU) and control how graphics are rendered.

Introduction to HLSL

HLSL offers a C-like syntax, making it relatively easy to learn for developers familiar with C, C++, or C#. It allows for a higher level of abstraction compared to older shader languages like Assembly, enabling more complex and sophisticated visual effects.

Key Concepts

Data Types

HLSL supports a variety of data types, including:

• Scalars: float, int, bool, double
• Vectors: float2, float3, float4 (and similarly for int, bool, etc.)
• Matrices: float2x2, float3x3, float4x4
• Structures (Structs): User-defined types for grouping data.

Variables and Semantics

Variables in HLSL are declared with a type and a name. Often, variables are associated with semantics, which define their purpose within the graphics pipeline.

Common semantics include:

• POSITION: Vertex position.
• COLOR: Vertex color.
• NORMAL: Vertex normal vector.
• TEXCOORD: Texture coordinates.
• SV_POSITION: The final clip-space position of a vertex (used in the vertex shader's return value).
• SV_TARGET: The output color for a pixel (used in the pixel shader's return value).

Example variable declaration:

float4 Position : POSITION;
float2 TexCoord : TEXCOORD0;

Functions

HLSL functions are similar to C functions, taking parameters and returning a value. The entry point for shaders is typically a function marked with a specific semantic.

A simple vertex shader function signature:

struct VS_OUTPUT {
    float4 Pos : SV_POSITION;
    float2 Tex : TEXCOORD0;
};

VS_OUTPUT vs_main(float4 Pos : POSITION, float2 Tex : TEXCOORD) {
    VS_OUTPUT output;
    output.Pos = mul(WorldViewProjectionMatrix, Pos); // Apply transformations
    output.Tex = Tex;
    return output;
}

Built-in Functions

HLSL provides a rich set of built-in functions for mathematical operations, texture sampling, and other common graphics tasks:

• sin(), cos(), pow(), sqrt()
• dot(), cross()
• normalize()
• tex2D() (for sampling 2D textures)
• mul() (for matrix-vector and matrix-matrix multiplication)

Control Flow

HLSL supports standard control flow statements:

• if-else statements
• for, while loops
• break, continue

Shader Stages

HLSL programs are compiled for specific shader stages within the DirectX graphics pipeline. The most common stages are:

• Vertex Shader: Processes individual vertices, transforming them and preparing data for later stages.
• Pixel Shader (Fragment Shader): Processes individual pixels (or fragments) and determines their final color.
• Geometry Shader: Can generate or discard primitives.
• Compute Shader: Used for general-purpose computation on the GPU, not necessarily tied to rendering.

Example: A Simple Pixel Shader

This pixel shader simply outputs a solid color.

float4 ps_main(float4 Pos : SV_POSITION) : SV_TARGET {
    return float4(1.0f, 0.0f, 0.0f, 1.0f); // Red color
}

Resources

Shaders can access various resources:

• Constant Buffers: Used to pass uniform data (e.g., transformation matrices, light parameters) to shaders.
• Shader Resource Views (SRVs): Used to read from textures and buffers.
• Unordered Access Views (UAVs): Used for read-write access to buffers and textures, primarily in compute shaders.
• Samplers: Control how texture coordinates are sampled.

HLSL provides syntaxes for declaring these resources:

cbuffer cbPerObject : register(b0) {
    matrix WorldViewProjection;
};

Texture2D myTexture : register(t0);
SamplerState mySampler : register(s0);

This section provides a foundational understanding of HLSL. Further topics include advanced shading techniques, shader model versions, and specific API interactions.