HLSL programozás

Szécsi László

Render target texturesRender target textures

Input Assembler I.

input streaming

Vertex Shader

Geometry Shader

Vertex buffer

Instance buffer

Index buffer

RESOURCES PIPELINE STAGES RENDER STATES

Input layout

Input Assembler II.

primitive setupPrimitive type

Rasterizer

face culling

depth bias adjustment

clipping

homogenous division

viewport transformation

output filtering

Fragment Shader

Output merger

stencil test

depth test

blending

vertex data, instance data

processed vertex data

primitive data

primitive strip data

fragments with interpolated data

fragment color and depth

Output buffer

Render target textures

Depth-stencil texture

Depth-stencil state

Constant buffers

and textures

Constant buffers

and textures

Constant buffers

and textures

Shader program

Blending state

Viewport

Filtering

Cull mode

Depth bias

Uniform parameters

Shader program

Uniform parameters

Shader program

Uniform parameters

Fill mode

Vertex shader és környezete

Vágás: -w<X<w, -w<Y<w, -w<Z<w, 0<color<1

ÁllapotTranszformációk

FényforrásokAnyag

POSITION, NORMAL, COLOR0, TEXTCOORD0,…

pos normal color texVertex buffer

POSITION, COLOR1, COLOR0, TEXTCOORD0,… háromszögre

Homogén osztás: X=X/w, Y=Y/w, Z=Z/w

POSITION, COLOR0, COLOR1, TEXTCOORD0,…új háromszögre

*MVP

*MV *MVIT

IlluminációVertex shader

Alap vertex shaderfloat4x4 modelViewProjMatrix;

struct StandardInput {

float4 pos : POSITION;

float4 color : COLOR0;

float2 tex : TEXCOORD0;

};

struct StandardOutput {

float4 hpos : POSITION;

float3 color : COLOR0;

float2 tex : TEXCOORD0;

};

StandardOutput standardVS(StandardInput input) {

StandardOutput output = StandardOutput(0);

output.hpos = mul(input.pos, modelViewProjMatrix);

output.tex = input.tex;

output.color = input.color;

return output;

}

uniform paraméterek

Pixel shader és környezete

ÁllapotTextúra azonosító és

paraméterek

POSITION, COLOR0, TEXTCOORD0,… háromszögekre

POSITION, COLOR

Pixel műveletek blending, z-bufferelés

Háromszög kitöltés és lineáris interpoláció

Pixel shaderTextúrázás:

text2d(u,v)*color0 + color1

POSITION, COLOR0, TEXTCOORD0 pixelekre

Textúra memória

Rasztertár

Alap pixel shader

sampler2D colorSampler;

float4 standardPS(

StandardOutput input) : COLOR

{

float4 color =

tex2D(colorSampler, input.tex) * input.color;

return color;

}

formailag ugyanaz, mint ami a vertex shader outputja volt,

de 3 vertex között interpolált értékek vannak benne

uniform textúra

paraméter

Effect file szerkesztés

VS

FX composer

– syntax highlighting

– azonnali fordítás és hibajelzés

– eredmény látható

– uniform paraméterek kézzel állíthatók

fxc.exe

– megnézni a gépi kódot

Effect file

globális változók, textúra samplerek

HLSL függvények

technique definíciók

– pass definíciók

• render state

• vertex shader

• pixel shader

Shader fordítás

technique standard{

pass p0{

ZEnable = TRUE;

VertexShader =

compile vs_2_0 standardVS();

PixelShader =

compile ps_2_0 standardPS();

}

}

cél profil

Profilok

Shader Model 1: vs_1_0, ps_1_0 … ps_1_4

– pár utasítás, regisztertologatás, ...

Shader Model 2: vs_2_0, ps_2_0

– 256 utasítás, swizzle, 16 textúra

Shader Model 3 : vs_3_0, ps_3_0

– vertex texture, dynamic flow control (if)

– 512 utasítás, dependent read

Shader Model 4: vs_4_0, gs_4_0, ps_4_0

– végtelen minden, stream, texture object...

Shader Model 3

utasításból nem fogunk kifogyni

textúra vertex shaderben is: tex2Dlod

for: static flow control !

– előre kell tudni hányszor hajtjuk végre

– nem lehet benne semmilyen indexelés

– különben kigörgeti

while: dynamic flow control

if

– return feltételes ágból tilos

Vektorműveletek

minden regiszter, ALU 4 float széles

– float, float2, float3 nem gyorsabb mint float4

változó definíció, mint C++-ban

inicializálás értékadás numerikus konstruktorral

float4 colorcsak float van

float4 color = float4(1, 1, 0.3, 1);

color = float4(0.1, 0, 0.3, 1);

Swizzle

float4 color = float4(1, 1, 0.3, 1);

color.x = 0.5;

float2 twochannels = color.rg;

float4 pos;

pos.xyz = float3(1, 0, 0);

pos.w = 1;

Műveletek az összes elemre vonatkoznak

float3 v1 = float3(1, 5, 0.3);

float3 v2 = float3(0, 0, -0.3);

bool3 b1 = v1 < v2;

if( all(b1) )

v1 = v2;

v1 *= 2; //összes elem * 2

v1 *= v2; //elemenként

float scalarProd = dot(v1, v2);

float3 crossProd = cross(v1, v2);

crossProd = normalize(crossProd);

HLSL intrinsic

Vektorok különbsége

e

x

e-x

szempozíció

árnyalt felületi pont

pozíciója

nézeti irány

(nem normalizált)

e-x = [ex-xx ey-xy ez-xz]

Vektorok hossza

v

|v| = √ (vx*vx + vy*vy + vz*vz)

|v|

Normalizált nézeti irány

e

x

szempozíció

árnyalt felületi pont

pozíciója

V: nézeti irány

(normalizált)

e-x = [ex-xx ey-xy ez-xz]

V= (e-x)/|e-x|

Két vektor skalárszorzata

(dot product)

a

b

a·b = axbx + ayby + azbz

skalár

(egy szám)

a·b = |a||b| cos θ

θ

Mire jó a skalárszorzat? 1.

v-nek n irányú része

v

θ

n n egységnyi hosszú kell legyen

vtöbbi

vn

|vn| = |v| cos Θ = |v| |n| cos Θ = v·n

vn = n |vn|

derékszögű

háromszög|n| = 1

skalárszorzat

Például: falról visszapattanó labda,

tökéletes visszaverődés iránya

V

NVmerőleges

Vpárhuzamos

V: bejövő sebesség

kimenő sebesség

Vout

V = Vpárhuzamos + Vmerőleges

Vout = Vpárhuzamos - Vmerőleges

Fal

N: fal normálvektora

Vmerőleges = -N(V·(-N))

Vpárhuzamos = V - Vmerőleges

Vout = V - 2N(V·N)

Mire jó a skalárszorzat? 2.

a és b közötti szög cosinusa

aθ

b a és b egységnyi hosszú kell legyen

cos Θ = |a| |b| cos Θ = a·b

|a| = |b| = 1

Például: diffúz felület árnyalása

Lθ

N

L: fényirány (normalizált)

kimenő radiancia

(nem függ a nézeti iránytól, mert diffúz)

Iout

Fal

N: árnyalt felület

normálvektora

(normalizált)

Iout = Iin kd cosΘ

Iin: bejövő radiancia

kd: diffúz BRDF paraméter

Θ: fény beesési szöge

Iout = Iin kd L·N

Két vektor vektoriális szorzata

(keresztszorzat, cross product)

a

b

a×b = [aybz-azby azbx-axbz axby-aybx]

θ

a×b

|a×b| = |a||b|sinΘ

a·|a×b| = 0 b·|a×b| = 0

merőleges a-ra és b-re

Mire jó a keresztszorzat?

Ha valami vektorra kell egy merőleges

– keresztszorozzuk pl. a felfele vektorral

• (pl. [0, 0, 1])

Két vektorra is merőleges

– a két vektor keresztszorzata

– ha nem 1 hosszúak vagy nem derékszögben

állnak ne felejtsünk el normalizálni

Példa: paraméteres felület normálvektora egy pontban

Példa: felület normálvektora

z(u,v) = sin(2u + 3v )

x(u,v) = u

y(u,v) = v

felület paraméteres egyenlete legyen:

Mi a normálvektora a u=v=0 pontban?

∂z(u,v) / ∂u = cos(2u + 3v) 2 = 2

∂x(u,v) / ∂u = 1

∂y(u,v) / ∂u = 0

∂z(u,v) / ∂v = cos(2u + 3v) 3 = 3

∂x(u,v) / ∂v = 0

∂y(u,v) / ∂v = 1

T érintő (tangens)

B érintő (binormál)

N = B×T = [0-2 0-3 1-0] = [-2 -3 1] normalizálás: / sqrt(14)