Le langage shader HLSL | Blog de développement de jeux vidéo

Intro :

Le HLSL signifie : High Level Shading Language. C’est un langage (qui a la même syntaxe que le C) qui permet de programmer le processeur de la carte graphique afin d’effectuer des algorithmes de rendus spécifiques.

Prérequis :

– Savoir configurer DirectX 10

Explications :

Le HLSL permet de générer la diffusion de la lumière, la texture à utiliser, les réflexions et réfractions, l’ombrage, le déplacement de primitives et les effets post-traitement.

C’est un outil très puissant qui permet de créer une vaste gamme d’effets graphiques et esthétiques pour les jeux modernes.

Avant l’existence du langage HLSL il fallait écrire les instructions en langage d’assembleur pour la carte graphique.

Un programme HLSL (en DirectX 11) est constitué par 5 étapes de chaîne rendu :

– Le vertex shader
– Le compute shader
– Le geometry shader
– Le tessellation shader
– Le domain shader
– Le pixel shader

Les vertex et pixel shaders doivent être obligatoirement programmés ; les autres ne doivent pas être nécessairement être programmés.

Le vertex shader :

Le vertex shader opère les transformations de repère, le skinning (l’animation squelettale), le déplacement de vertex et le calcul d’attributs de vertex pour les materials.

Le pixel shader :

Le pixel shader opère le blending de texturage, le calcul lumineux, etc…

Exemple :

Voici quelques fonctions intrinsèques utilisables dans le HLSL :

abs(x) : valeur absolue
ceil(x) : retourne le plus petit entier qui est égale ou supérieur à x
clamp(x, min, max) : retourne x dans l’intervalle [min, max]
cos(x) : retourne le cosinus de x
clip(x) : ignore le pixel en cours si x est inférieur à 0
cross(x, y) : retourne le produit vectoriel de deux vecteurs 3D
dot(x, y) : retourne le produit scalaire de deux vecteurs
length(v) : retourne la longueur du vecteur v
lerp(x, y, s) : retourne x + s(y – x)
normalize(x) : retourne un vecteur normalisé
max(x, y) : retourne le plus grand entier entre x et y
min(x, y) : retourne le plus petit entier entre x et y
mul(x, y) : retourne la multiplication des matrices x et y
reflect(i, n) : retourne un vecteur de reflection en utilisant le rayon d’insidence et la normale à la surface
refract(i, n, η) : retourne un vecteur de refraction en utilisant un rayon d’entrée, la normale à la surface, et un index de refraction
saturate(x) : clamp entre les valeurs 0 et 1
sqrt(x) : retourne la racine carrée de x
transpose(x) : retourne la matrice transposée de x
tex2D(s, t) : retourne une texture samplée

Les variables globales se déclarent et se définissent ainsi :

static const float2 bodyTexSize = {512, 512};
static const float2 faceLowerTexSize = {256, 128};
static const float2 faceUpperTexSize = {256, 64};

static const float2 bodyTexSize = {512, 512};

static const float2 faceLowerTexSize = {256, 128};

static const float2 faceUpperTexSize = {256, 64};

Voici un petit exemple d’un programme écrit en HLSL qui créé un effet « bois » procédural en tant que texture.

matrix WorldViewProjMatrix;
matrix TextureMatrix;

struct VS_OUTPUT
{
	float4 Pos : POSITION;
	float3 Pshade : TEXCOORD0;
};

VS_OUTPUT main (float4 vPosition : POSITION)
{
	VS_OUTPUT Out = (VS_OUTPUT) 0; 

	// Transforme la position du vertex vers l'espace 2D de l'écran
	Out.Pos = mul (WorldViewProjectionMatrix, vPosition);

	// Transforme les coordonnées de la texture
	Out.Pshade = mul (texture_matrix0, vPosition);

	return Out;
}

matrix WorldViewProjMatrix;

matrix TextureMatrix;

struct VS_OUTPUT

{

float4 Pos : POSITION;

float3 Pshade : TEXCOORD0;

};

VS_OUTPUT main (float4 vPosition : POSITION)

{

VS_OUTPUT Out = (VS_OUTPUT) 0;

// Transforme la position du vertex vers l'espace 2D de l'écran

Out.Pos = mul (WorldViewProjectionMatrix, vPosition);

// Transforme les coordonnées de la texture

Out.Pshade = mul (texture_matrix0, vPosition);

return Out;

}

Comment créer un effet shader à parti d’un fichier .fx :

HRESULT D3DX10CreateEffectFromFile(
  _In_        LPCTSTR            pFileName, // Nom du fichier shader .fx
  _In_  const D3D10_SHADER_MACRO *pDefines, // Liste de macros  (peut être mis à nullptr)
  _In_        ID3D10Include      *pInclude, // Inteface d'include (peut être mis à nullptr)
  _In_        LPCSTR             pProfile, // Spécifie le profile ; ex : "fx_4_0"
  _In_        UINT               HLSLFlags, // Options du compilateur
  _In_        UINT               FXFlags, // Options de l'effet shader
  _In_        ID3D10Device       *pDevice, // Le device de DirectX 10.1
  _In_        ID3D10EffectPool   *pEffectPool,
  _In_        ID3DX10ThreadPump  *pPump,
  _Out_       ID3D10Effect       **ppEffect, // Pointeur de retour vers l'effet créé
  _Out_       ID3D10Blob         **ppErrors, // Pointeur de retour vers un objet représentant les erreurs
  _Out_       HRESULT            *pHResult
);

HRESULT D3DX10CreateEffectFromFile(

_In_ LPCTSTR pFileName, // Nom du fichier shader .fx

_In_ const D3D10_SHADER_MACRO *pDefines, // Liste de macros (peut être mis à nullptr)

_In_ ID3D10Include *pInclude, // Inteface d'include (peut être mis à nullptr)

_In_ LPCSTR pProfile, // Spécifie le profile ; ex : "fx_4_0"

_In_ UINT HLSLFlags, // Options du compilateur

_In_ UINT FXFlags, // Options de l'effet shader

_In_ ID3D10Device *pDevice, // Le device de DirectX 10.1

_In_ ID3D10EffectPool *pEffectPool,

_In_ ID3DX10ThreadPump *pPump,

_Out_ ID3D10Effect **ppEffect, // Pointeur de retour vers l'effet créé

_Out_ ID3D10Blob **ppErrors, // Pointeur de retour vers un objet représentant les erreurs

_Out_ HRESULT *pHResult

);

Résumé :

Le langage shader HLSL est un outil très puissant pour le rendu graphique des jeux vidéo.

Tous les effets graphiques dans les jeux DirectX d’aujourd’hui sont construits à partir de fichier script shader HLSL.

Références :

– http://www.neatware.com/lbstudio/web/hlsl.html

– https://msdn.microsoft.com/fr-fr/library/ms810449.aspx