La syntaxe de base du
type
scalaire HLSL 1 de type 1.1
1. booléen: vrai ou faux. Notez que le HLSL fournit les mots-clés vrai et faux comme en C ++.
2. int: entier signé 32 bits.
3. moitié: nombre à virgule flottante de 16 bits.
4. float: nombre à virgule flottante de 32 bits.
5. double: nombre à virgule flottante de 64 bits.
1.2 Types de vecteurs
1.2.1 Types de vecteurs
1. float2: vecteur 2D, où les composants sont de type float.
2. float3: vecteur 3D, où les composants sont de type float.
3. float4: vecteur 4D, où les composants sont de type float.
En plus de float, nous pouvons également utiliser d'autres types de base pour définir des vecteurs, tels que bool2, int 3. En bref, le type d'expression des vecteurs est TypeN, où N appartient à (2,4).
1.2.2 Initialisation du vecteur
float3 v = {1.0f, 2.0f, 3.0f};
float2 w = float2 (x, y);
float4 u = float4 (w, 3.0f, 4.0f); // u = (wx, wy, 3.0f, 4.0f)
1.2.3 Accès aux vecteurs
Utilisez la syntaxe de tableau:
Tels que: vec [i] = 2.0f;
Utilisez la syntaxe alphabétique, xyzw, rgba.
Tel que:
vec.x = vec.r = 1.0f;
vec.y = vec.g = 2.0f;
vec.z = vec.b = 3.0f;
vec.w = vec.a = 4.0f;
1.2.4 Remplacement et déploiement des vecteurs (swizzles)
Afin d'éviter la complexité de l'attribution vectorielle, HLSL adopte la méthode de Swizzles, comme suit:
float4 u = {1.0f, 2.0f, 3.0f, 4.0f};
float4 v = {0.0f, 0.0f, 5.0f, 6.0f};
v = u.wyyx; // v = {4.0f, 2.0f, 2.0f, 1.0f}
v = u.wzyx; // v = {4.0f, 3.0f, 2.0f, 1.0f}
v.xy = u; // v = {1.0f, 2.0f, 5.0f, 6.0f}
1.3 Type de matrice
1.3.1 Syntaxe de la définition de la matrice
Typem × n xxx; tels que:
1. float2x2: matrice 2 × 2, où les entrées sont de type float.
2. half3x3: matrice 3 × 3, où les entrées sont de type half.
3. int4x4: matrice 4 × 4, où les entrées sont de type int.
4. bool3x4: matrice 3 × 4, où les entrées sont de type bool.
1.3.2 Accès à la matrice
Utilisez la syntaxe de tableau:
M [i] [j] = valeur;
Utilisez la syntaxe des variables membres:
M._11 = M._12 = M._13 = M._14 = 0.0f;
M._21 = M._22 = M._23 = M._24 = 0.0f;
M._31 = M._32 = M._33 = M._34 = 0.0f;
M._41 = M._42 = M._43 = M._44 = 0.0f;
ou
M._m00 = M._m01 = M._m02 = M._m03 = 0.0f;
M._m10 = M._m11 = M._m12 = M._m13 = 0.0f;
M._m20 = M._m21 = M._m22 = M._m23 = 0.0f;
M._m30 = M._m31 = M._m32 = M._m33 = 0.0f;
Toute la gamme de visites:
float3 N = normaliser (pIn.normalW);
float3 T = normaliser (pIn.tangentW -dot (pIn.tangentW, N) * N);
float3 B = croix (N, T);
float3x3 TBN;
TBN [0] = T; // définit la ligne 1
TBN [1] = B; // définit la ligne 2
TBN [2] = N; // définit la ligne 3
1.3.3 Initialisation de la matrice
float2x2 fxx = float2x2 (1.0f, 2.0f, 3.0f, 4.0f);
int2x2 ixx = {1,2,3,4};
1.3.4 Définition alternative du vecteur de matrice
vecteur u = {1.0f, 2.0f, 3.0f, 4.0f};
matrice M; // matrice 4x4
1.4 Baie
flotteur M [4] [4];
demi p [4];
float3 v [12]; // 12 vecteurs 3D
1.5 Structure
La structure en HLSL est similaire à la structure en C. Elle ne peut pas contenir de membres de fonction et les membres d'accès doivent uniquement être basés sur des indices.
struct SurfaceInfo
{ float3 pos; float3 normal; float4 diffus; float4 spec; }; SurfaceInfo v; litColor + = v.diffuse; point (lightVec, v.normal); float specPower = max (v.spec.a, 1.0f);
1.6 Mots clés liés aux variables
typedef ， statique ， uniforme ， extern ， const
L'utilisation est similaire à celle du C ++. Lorsqu'une variable est déclarée statique, cela signifie que la variable est une variable interne et n'est pas visible en dehors du programme shader. Les variables globales non statiques sont externes par défaut, c'est-à-dire qu'elles sont accessibles par des programmes en dehors du programme shader.
1.7 Conversion de type forcée
La conversion de type dans HLSL est très flexible, comme indiqué ci-dessous:
float f = 5,0f;
float4x4 m = (float4x4) f; // copie finto chaque entrée de m.
float3 n = float3 (...);
float3 v = 2.0f * n - 1.0f;
Le 1.0f ici est en fait converti en (1.0f, 1.0f, 1.0f);
2 Syntaxe et fonctions
2.1 Syntaxe
2.1.1 retour
retour (expression);
2.1.2 Instruction if-else
si (condition)
{}
……………………………………
si (condition)
{}
autre
{}
2.1.3 pour la boucle
pour (initial; condition; incrément)
{}
2.14 pendant
tandis que (condition)
{}
2.1.5 en temps réel
faire
{} while (condition);
2.2 Fonction
2.2.1 Caractéristiques de la fonction HLSL
Similaire au C ++, les paramètres sont passés par valeur (les références et les pointeurs ne sont pas pris en charge), la récursivité n'est pas prise en charge et les fonctions sont toujours en ligne
2.2.2 Exemples de fonctions
bool foo(in const bool b, out int r1,inout float r2)
{
if(b)// test input value
{
r1= 5; // output a value through r1
}
else
{
r1 = 1; // output a value through r1
}
//sincer2 is inout we can use it as an input value and also output a value through it
r2= r2 * r2 * r2;
returntrue;
}Ce qui doit être expliqué ici, ce sont les mots-clés in, out, inout
in: La valeur par défaut, vous n'avez pas besoin de l'ajouter. Indique que la valeur du paramètre doit être transmise
out: indique que le paramètre est une valeur de retour de la fonction, qui est uniquement utilisée comme sortie et ne peut pas être utilisée comme entrée
inout: à la fois entrée et sortie
3 La sémantique
en HLSL utilise souvent une forme telle que xxx: POSITION lors de la définition de HLSL, que ce soit une variable de paramètre entrée dans une fonction ou une variable renvoyée. Voici un endroit qui distingue les variables dans HLSL. Le ":" suivant est appelé sémantique. Il est utilisé pour décrire certaines informations des variables. En ce qui concerne la sémantique, l'essentiel est de spécifier la relation entre les variables de shader et le matériel. Par exemple, POSITION spécifie que cette variable est utilisée dans un registre lié à la position.
3.1 La sémantique des vertex shaders
La sémantique comprend des parties d'entrée et de sortie. Reportez-vous à la section suivante concernant l'entrée et la sortie du sommet:
Saisir
La description
Taper
BINORMAL [n]
Binormal
float4
BLENDINDICES [n]
Index de fusion
uint
BLENDWEIGHT [n]
Mélanger les poids
flotter
COULEUR [n]
Couleur diffuse et spéculaire
float4
NORMAL [n]
Vecteur normal
float4
POSITION [n]
Position du sommet dans l'espace objet.
float4
POSITION
Position du sommet transformée.
float4
PSIZE [n]
Taille du point
flotter
TANGENT [n]
Tangente
float4
TEXCOORD [n]
Coordonnées de texture
float4
Sortir
La description
Taper
COULEUR [n]
Couleur diffuse ou spéculaire
float4
BROUILLARD
Brouillard Vertex
flotter
POSITION [n]
Position d'un sommet dans l'espace homogène. Calculez la position dans l'espace écran en divisant (x, y, z) par w. Chaque vertex shader doit écrire un paramètre avec cette sémantique.
float4
PSIZE
Taille du point
flotter
TESSFACTOR [n]
Facteur de tessellation
flotter
TEXCOORD [n]
Coordonnées de texture
float4
On peut voir d'après ce qui précède que la sémantique derrière la variable n'est pas ajoutée au hasard. Premièrement, elle indique l'utilisation de la variable, et deuxièmement, il existe des restrictions spéciales sur la sémantique d'entrée et de sortie. Nous ne pouvons pas utiliser une sémantique utilisée comme une entrée comme sortie.
n est la valeur d'index du registre et la valeur maximale dépend de la prise en charge du matériel. Tels que POSITION1.
3.2 La sémantique des pixel shaders
Saisir
La description
Taper
COULEUR [n]
Couleur diffuse ou spéculaire.
float4
TEXCOORD [n]
Coordonnées de texture
float4
VFACE
Scalaire à virgule flottante qui indique une primitive orientée vers l'arrière. Une valeur négative est tournée vers l'arrière, tandis qu'une valeur positive fait face à la caméra.
flotter
VPOS
L'emplacement du pixel (x, y) dans l'espace d'écran. Pour convertir un shader Direct3D 9 (qui utilise cette sémantique) en un shader Direct3D 10, voir Direct3D 9 VPOS et Direct3D 10 SV_Position)
float2
Sortir
La description
Taper
COULEUR [n]
Couleur de sortie
float4
PROFONDEUR [n]
Profondeur de sortie
flotter
3.3 Exemples
void SkyVS (float3posL: POSITION0, out float4 oPosH: POSITION0, out float3 oEnvTex: TEXCOORD0)
{ oPosH = mul (float4 (posL, 1.0f), g_matWVP) .xyww; oEnvTex = posL; }
/
struct OutputVS
{ float4 posH: POSITION0; float2 tex0: TEXCOORD0; // D3D remplit les sprites ponctuels. taille du flotteur: PSIZE; // En pixels. }; OutputVSSnowVS (float3 posL: POSITION0, float3 vel: TEXCOORD0, float size: TEXCOORD1, float initialT: TEXCOORD2, float lifeT: TEXCOORD3) { OutputVS outVS = (OutputVS) 0; float t = g_Time - initialT; posL = posL + vel * t + 0.5f * g_Acc * t * t; outVS.posH = mul (float4 (posL, 1.0f), g_matWVP);
outVS.size = 0,0035f * g_ViewportHeight * taille;
return outVS;
}
float4 SnowPS (float2tex0: TEXCOORD0): COLOR
{ return tex2D (TexS, tex0); }
Références
[1] Introduction à la programmation de jeux 3D avec DirectX11
[2] Sémantique (DirectX HLSL) dans l'échantillonneur Microsoft DirectX