HLSL ( High Level Shader Language ) este un limbaj de nivel înalt asemănător C pentru programarea shader .
A fost creat de Microsoft și inclus în pachetul DirectX 9.0.
HLSL acceptă tipuri scalare, tipuri de vectori, matrici și structuri.
Exemplu: vector <float, 4> color;
Exemplu: float4 newcolor;
Exemplu: float oldcolor[4]
Exemplu: culoare nouă = float4 (culoare veche[0], culoare veche[1], culoare veche[2], culoare veche[3])
Exemplu: matrice <float, 4> view_matrix;
Exemplu: float 4x4 view_matrix;
struct vs_input {
float4 pos:POZIȚIE; float3 nor:NORMAL; float2uv:TEXCOORD0;}; struct ps_input {
float4 pos:POZIȚIE; float3 nor:NORMAL; float2uv:TEXCOORD0; float CustomVar; texture2D CustomTexture; //și așa mai departe... :POZIȚIA :NORMAL etc. sunt sentimatice, mai multe despre ele mai jos.};
| Operațiuni | Operatori |
|---|---|
| Aritmetic | -, +, *, /, % |
| crestere, decrementare | ++, -- |
| joc de inteligență | \|, ?: |
| Unar | !, -, + |
| Comparații | <, >, <=, >=, ==, != |
| Scop | =, -=, +=, *=, /= |
| Distribuție | (tip de) |
| Virgulă | , |
| Membru de structură | . |
| Membru al matricei | [index] |
if (expresie) <afirmație> [ else <anunț>]
Există 3 tipuri de bucle în HLSL:
| abs(x) | returnează valoarea absolută a fiecărei componente x |
| acos(x) | returnează arcul cosinus al fiecărei componente x. Fiecare componentă trebuie să fie în intervalul [-1, 1] |
| asin(x) | returnează arcsinusul fiecărei componente x. Fiecare componentă trebuie să fie în intervalul [-pi/2, pi/2] |
| atan(x) | returnează arc-tangente a fiecărei componente x. Fiecare componentă trebuie să fie în intervalul [-pi/2, pi/2] |
| plafon (x) | returnează cel mai mic număr întreg care este mai mare sau egal cu x (rotunjire în sus) |
| cos(x) | returnează cosinusul lui x |
| numerar(x) | returnează cosinusul hiperbolic al lui x |
| clemă (x, a, b) | Dacă x < a, atunci returnează a, dacă x > b, atunci returnează b, în caz contrar returnează x. |
| ddx(x) | returnează derivata parțială a lui x în raport cu coordonatele x din spațiul ecranului |
| ddy(x) | returnează derivata parțială a lui x în raport cu coordonata y-spațiu ecran |
| grade(x) | Convertiți x din radiani în grade |
| distanta (a, b) | returnează distanța dintre două puncte a și b |
| punct(a,b) | returnează produsul scalar a doi vectori a și b |
| exp(x) | returnează exponentul cu baza e sau e x |
| podea(x) | returnează cel mai mare număr întreg care este mai mic sau egal cu x (rotunjind în jos) |
| frac( x ) | returnează partea fracțională a lui x. |
| fwidth(x) | returnează abs(ddx(x))+abs(ddy(x)) |
| len(v) | Lungimea vectorului |
| lungime (v) | returnează lungimea vectorului v |
| lerp (a, b, s) | returnează a + s (b - a) |
| log(x) | returnează logaritmul lui x |
| log10(x) | returnează logaritmul zecimal al lui x |
| modf(x, out ip) | revine la părțile fracționale și întregi ale lui x, fiecare parte are același semn ca x |
| mul(a, b) | face o înmulțire matriceală între a și b |
| normaliza (v) | returnează un vector normalizat v |
| pow(x, y) | returnează x y |
| radiani(x) | convertiți x din grade în radiani |
| reflectă (i, n) | returnează vectorul de reflexie |
| refracta (i, n, eta) | returnează vectorul de refracție. |
| rotund( x ) | returnează cel mai apropiat număr întreg. |
| rsqrt(x) | returnează 1 / sqrt(x) |
| saturat(x) | La fel ca clema(x,0,1) |
| sin(x) | returnează sinusul lui x. |
| sincos(x, out s, out c) | returnează sinusul și cosinusul lui x |
| sinh(x) | returnează sinusul hiperbolic al lui x |
| sqrt(x) | returnează rădăcina pătrată a fiecărei componente |
| pasul (a, x) | returnează 1 dacă x >= a, în caz contrar returnează 0 |
| tan(x) | returnează tangenta lui x |
| tanh(x) | returnează tangenta hiperbolică a lui x |
| tex1D(s, t) | Citirea dintr-o textură unidimensională s - sampler, t - scalar. |
| tex1D(s, t, ddx, ddy) | Citirea dintr-o textură unidimensională, cu derivatele s fiind sampler, t, ddx și ddy fiind scalari. |
| tex1Dproj(s, t) | Citirea dintr-o textură proiectivă unidimensională s - sampler, t - vector 4D. t este împărțit la tw înainte ca funcția să fie executată. |
| tex1Dbias(s, t) | Citind dintr-o textură unidimensională cu un offset, s este un eșantionare, t este un vector 4-dimensional. Nivelul mip este deplasat cu tw înainte de efectuarea căutării. |
| tex2D(s, t) | Citirea dintr-o textură 2D s este un eșantionare, t este un vector 2D. |
| tex2D(s, t, ddx, ddy) | Citirea dintr-o textura 2D, cu derivate. s - sampler, t - coordonatele texturii 2D. ddx, ddy- vectori 2D. |
| tex2Dproj(s, t) | Citirea dintr-o textură proiectivă 2D. s - prelevator, t - vector 4D. t este împărțit la tw înainte ca funcția să fie executată. |
| tex2Dbias(s, t) | Citirea dintr-o textură 2D cu un offset. s este un prelevator, t este un vector cu 4 dimensiuni. Nivelul mip este deplasat cu tw înainte de efectuarea căutării. |
| tex3D(s, t) | Citirea dintr-o textura 3D. s - sampler, t - vector 3D. |
| tex3D(s, t, ddx, ddy) | Citirea dintr-o textura 3D, cu derivate. s - sampler, t - coordonatele texturii 2D, ddx, ddy - vectori 3D. |
| tex3Dproj(s, t) | Citirea dintr-o textură proiectivă 3D. s - prelevator, t - vector 4D. t este împărțit la tw înainte ca funcția să fie executată. |
| tex3Dbias(s, t) | Citirea dintr-o textură 3D cu un offset. s este un prelevator, t este un vector cu 4 dimensiuni. Nivelul mip este deplasat cu tw înainte de efectuarea căutării. |
| texCUBE(s, t) | Citirea dintr-o textură cub. s - sampler, t - coordonatele texturii 3D. |
| texCUBE(s, t, ddx, ddy) | Citirea dintr-o textură cub. s - sampler, t - coordonatele texturii 3D, ddx, ddy - vectori 3D. |
| texCUBEproj(s, t) | Citirea dintr-o textură proiectivă cubică. s - prelevator, t - vector 4D. t este împărțit la tw înainte ca funcția să fie executată. |
| texCUBEbias(s, t) | Citirea dintr-o textură cub. prelevator, t este un vector 4D. Nivelul mip este deplasat cu tw înainte de efectuarea căutării. |
Umbritoarele de vârf și fragmente au două tipuri de intrare: variabilă și uniformă .
Uniformă - date care sunt constante pentru utilizare multiplă în shader. Declararea datelor uniforme în HLSL se poate face în două moduri:
1) Declarați datele ca variabilă externă. De exemplu:
valoare float4; float4 main() : CULOARE { valoare returnată; }2) Declarați datele prin calificativul uniform. De exemplu:
float4 principal (valoare uniformă float4): CULOARE { valoare returnată; }Variabilele uniforme sunt specificate printr-un tabel de constante. Tabelul constant conține toate registrele care sunt utilizate în mod constant în shader.
Variante sunt datele care sunt unice pentru fiecare apel de shader. De exemplu: poziție, normal etc. În vertex shader, această semantică descrie diferitele date care sunt transmise din bufferul vertex, iar în fragment shader, datele interpolate primite de la vertex shader.
Principalele tipuri semantice de intrare:
| BINORMAL | Binormal |
|---|---|
| GREUTATEA AMEST | Coeficientul de greutate |
| BENDINDICES | Indicele matricei de greutate |
| CULOARE | Culoare |
| NORMAL | Normal |
| POZIŢIE | Poziţie |
| PSIZE | Dimensiunea punctului |
| TANGENTĂ | Tangentă |
| TESSFACTOR | Factor de teselație |
| TEXCOORD | Coordonatele texturii |
Utilizarea datelor variate într-un shader de fragment determină starea unui singur fragment. Principalele tipuri semantice de intrare:
| CULOARE | Culoare |
|---|---|
| TEXCOORD | Coordonatele texturii |
Date de ieșire pentru shaderul vertex:
| POZIŢIE | Poziţie |
|---|---|
| PSIZE | Dimensiunea punctului |
| CEAŢĂ | Factor nebuloasă pentru vârf |
| CULOARE | Culoare |
| TEXCOORD | Coordonatele texturii |
Date de ieșire pentru fragment shader:
| CULOARE | Culoare |
|---|---|
| ADÂNCIME | Valoarea adâncimii |
Pentru a facilita scrierea shaderelor, există o serie de programe care vă permit să compuneți shadere și să vizualizați imediat rezultatul.
Pixel shaderele sunt, de asemenea, folosite de randeri, de exemplu,
Codul din această listă funcționează în ATI Rendermonkey și compozitorul Nvidia FX. Pentru a-l utiliza într-un motor personalizat, trebuie să specificați SamplerState și tehnica.
/* ========== VERTEX SHADER ========== */ /* world_matrix, view_matrix, proj_matrix trebuie obținute din aplicație prin setarea constantelor shader. Constantele shader sunt încărcate în registre. */ float4x4 world_matrix ; // matricea lumii float4x4 view_matrix ; // matrice ca float4x4 proj_matrix ; // matricea de proiecție struct VS_OUTPUT // o instanță a acestei structuri va returna un vertex shader { float4 Pos : POSITION0 ; /* POSITION0 și TEXCOORD0 sunt semantici care denotă sloturile din care pixel shader-ul va primi mai târziu date. Semantica specificată aici trebuie să se potrivească cu semantica din intrare la pixel shader. Numele și ordinea variabilelor pot varia.*/ float2 TexCoord : TEXCOORD0 ; }; VS_OUTPUT VS_Main ( float4 InPos : POSITION0 , float2 InTexCoord : TEXCOORD0 ) /* Vertex shader este executat pentru fiecare vârf al obiectului de ieșire. InPos și InTexCoord obținute din datele de mapare a fluxului */ { VS_OUTPUT Out ; float4x4 worldViewProj_matrix = mul ( world_matrix , view_matrix ); worldViewProj_matrix = mul ( worldViewProj_matrix , proj_matrix ); afară . Pos = mul ( InPos , worldViewProj_matrix ); // transformă vârful în clip-space Out . TexCoord = InTexCoord ; // primim coordonatele texturii din exterior, nimic nu trebuie modificat întoarce afară ; } /* ========== PIXEL SHADER ========== */ sampler2D baseMap ; // sampler2D este un „slot de textură” special în care poate fi încărcată o textură. float4 PS_Main ( float2 texCoord : TEXCOORD0 ) : COLOR0 /* Pixel shader returnează întotdeauna culoarea pixelului redat cu semantica COLOR0 în format float4. Pixel shader-ul este executat pentru fiecare pixel al imaginii randate (nu pentru fiecare texel textura) */ { return tex2D ( baseMap , texCoord ); /* tex2d(sampler2D, float2) citește din eșantionrul de textură (din textură) culoarea texelului său cu coordonatele de textură date. Aceasta va fi culoarea pixelului de ieșire. */ }