introducción a los vertex shader en directx 9 alexis sattler ([email protected]) octubre 2005

Introducción a los Vertex Shader en DirectX 9

Alexis Sattler ([email protected])Octubre 2005

Objetivos de la conferencia

• Que son ?

• Introducción a los GPU

• Vertex y Pixel Shaders en DX9

• Effects / HLSL en DX9

• GPGPU

Que son los shaders

En términos generales, son programas destinados a realizar los cálculos necesarios para determinar el aspecto final de la superficie de un mesh.

VS : es un tipo de shaders que se ejecuta una vez por cada vértice del mesh que se debe procesar

PS : también conocido como fragment shader, es similar al VS pero por cada pixel

Ver

tex

Sha

der

Ver

tex

Sha

der

Ubicación en el Pipeline3D

VertexStream

Ver

tex

Sha

der

T&

L

Cul

ling,

Clip

ping

Tria

ngle

set

up

Ras

teriz

atio

n

Tex

turiz

ado

Pix

el

Sha

der

Fog

A

lpha

Tes

tS

tenc

il T

est

Dep

th T

est

Alp

ha B

lend

Ren

der

Tar

get

Que son los shaders

En que momento se ejecutan

10

10

3 Ejecuciones del VS

~ 50 Ejecuciones del PS

Arquitectura Lógica

Vertex Shader Unit

Vertex StreamSetStreamSource

SetIndices

TexturasSetTexture (Device, Effect)

VertexShader Constants

SetVertexShaderConstant

Procesamiento de Primitivas

Pixel Shader Unit

Procesamiento de Pixels

Pixel Shader Constants

SetPixelShaderConstant

Pixel Shader ProgramSetPixelShader

Vertex Shader ProgramSetVertexShader

FF SetRenderState

FF SetRenderState

TexturasSetTexture (Device, Effect)

VS – Registros Entrada

Reg Desc Cantidad Acceso Version VS

v# Input Vector 16 RO Todos

r# Resultados Intermedios 12-32 RW Todos

c# Parametros Float Ctes 96-256+ RO Todos

a0 Registro Indice .x- xyzw RW Todos

b# Parámetros Bool Ctes >=2.0

aL Contador Iteraciones RO >=2.0

i# Parámetros Int Ctes 16 RO >=2.0

s# Sampler 4 - >=3.0

p0 Registro predicado 1 RW >=2.x

VS – Registros Salida

oPos Posicion Vertice 16 W <3.0

oFog Niebla Por Vertice 1 W <3.0

oPts Tamaño Punto 1 W <3.0

oD# D0 : diffuse D1: spec 2 W <3.0

oT# Text Coord 8 W <3.0

o# Generico 12 W 3.0

PS – Registros Entrada


v# Input Color 2-10 RO Todos

r# Resultados Intermedios

2-32 RW Todos

c# Parametros Float Ctes 8-224 RO Todos

t# Coordenadas Textura .x- xyzw RW <3.0

b# Parametros Bool Ctes 16 RO >=2.0

aL Contador Iteraciones RO >=3.0

i# Parametros Int Ctes 16 RO >=2.0

s# Sampler 16 - >=2.0

p0 Registro predicado 1 RW >=2.x

vFace Indicador de backface R >=3.0

vPos Posicion en Pantalla 1 R >=3.0

PS – Registros Salida


r0 Color 1 W 1.x

oC# Color deSalida 4 W >=2.0

oDepth Valor de Salida para Depto Stencil test

1 W >=2.0 <3.0

Setup Inicial

• Crear device

• Crear o cargar los vertex e index buffers

• Crear declarators

• Crear o cargar texturas a utilizar

• Crear matrices de transformación (world, view, projection)

• Cargar, crear o compilar los Shaders o Effects

VS – Transformación

Fuente

vs 1.1m4x4 r0, v0, c1m4x4 r0, r0, c5m4x4 oPos, r0, c9mov oD0, c13

• Transformación de los vertices– c1-c4 : Matriz World : Posición del objeto en el mundo 3D– c5-c8 : Matriz View : Transformación correspondiente a la posición y orientación de la camara.– c9-c12 : Matriz Projection : Transformación para aplicar perspectiva (mas lejos mas chico) o puede ser una proyección ortogonal, aspecto de la pantalla, etc.

• Color fijo enviado en la constante c13 (0,0,1,1)


vs 1.1m4x4 r0, v0, c1m4x4 r0, r0, c5m4x4 oPos, r0, c9mov oD0, c13

Fuente vs 1.1dp4 r0.x, v0, c1dp4 r0.y, v0, c2dp4 r0.z, v0, c3dp4 r0.w, v0, c4

dp4 r0.x, r0, c5dp4 r0.y, r0, c6dp4 r0.z, r0, c7dp4 r0.w, r0, c8

dp4 r0.x, v0, c1dp4 r0.y, v0, c2dp4 r0.z, v0, c3dp4 r0.w, v0, c4

mov oD0, c13


Inicialización especifica (una vez)

LPDIRECT3DVERTEXDECLARATION9 decl;D3DVERTEXELEMENT9 elem[] = {{0,0,D3DDECLTYPE_FLOAT4,D3DDECLMETHOD_DEFAULT,D3DDECLUSAGE_POSITION,0},{0xFF,0,D3DDECLTYPE_UNUSED,0,0,0} // D3DDECL_END()};d3dDevice->CreateVertexDeclaration(&elem[0], &decl);

Creación del Declarador

HANDLE hFile=CreateFile(pFilename, GENERIC_READ,0,NULL, OPEN_EXISTING,0, NULL);

DWORD dwFileSize = GetFileSize(hFile, NULL);const DWORD* pShader=(DWORD*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,

dwFileSize);ReadFile(hFile, (void*)pShader, dwFileSize, &dwFileSize, NULL);CloseHandle(hFile);HRESULT hr = D3DApp->GetDevice()->CreateVertexShader(pShader, pdwShader);HeapFree(GetProcessHeap(), 0, (void*)pShader);

Carga de un Vshader Compilado


Estableciendo los parámetros(Render Loop)

D3DXMATRIX matTemp;D3DXMatrixIdentity (&matTemp);D3DXMatrixTranspose(&matTemp , &matTemp );d3dDevice->SetVertexShaderConstantF(1, &matTemp(0, 0), 4);

D3DXMatrixLookAtLH(&m_matLookAt, &v3from, &v3At, &v3Up);D3DXMatrixTranspose(&matTemp , &matTemp );d3dDevice->SetVertexShaderConstantF(5, &matTemp(0, 0), 4);

Posición

View o Camara

D3DXMatrixPerspectiveFovLH(&matTemp, PI/2, 800/600, 1.0, 200.0);D3DXMatrixTranspose(&matTemp , &matTemp );d3dDevice->SetVertexShaderConstantF(9, &matTemp(0, 0), 4);

Proyección

D3DXCOLOR color = D3DCOLOR_RGBA(0,0,1,1);d3dDevice->SetVertexShaderConstantF(13, &color, 4);

Color


Como establecer los parametros

m11 m12 m13 m14m21 m22 m23 m24m31 m32 m33 m34m41 m42 m43 m44

Fila m11 m12 m13 m14 m21 m22 m23 m24 m31 m32 m33 m34 m41 m42 m43 m44

Registro GPU C1 C2 C3 C4

dp4 b,c = b.x * c.x + b.y * c.y + b.z * c.z + b.w * c.w


dp4 r0.x, v0, c1dp4 r0.y, v0, c2dp4 r0.z, v0, c3dp4 r0.w, v0, c4 ERROR !!!!





dp4 r0.x, v0, c1 OK !dp4 r0.y, v0, c2 OK !dp4 r0.z, v0, c3 OK !dp4 r0.w, v0, c4 OK !

C4C3C2C1



Transposicion via D3DXMatrixTranspose



d3dDevice->SetVertexShader(pdwShader);d3dDevice->SetVertexDeclaration(m_decl1);d3dDevice->SetStreamSource(0, pVBBuffer, offset, size );

Render


Resumen de instrucciones • m4x4• dp4• mov• SetVertexShaderConstantF

VS – Iluminación Gouraud

Fuentevs_3_0def c6, 0, 1, 0, 0dcl_position v0dcl_normal v1dcl_position o0dcl_color o1dcl_color1 o2dcl_texcoord o3.xydp4 o0.x, v0, c0dp4 o0.y, v0, c1 dp4 o0.z, v0, c2dp4 o0.w, v0, c3dp4 r0.x, v1, c7dp4 r0.y, v1, c8dp4 r0.z, v1, c9dp4 r0.w, v1, c10 dp4 r1.w, r0, r0rsq r1.w, r1.wmul r0, r0, r1.wdp4 r0.w, r0, -c4mul o1, r0.w, c5mov o2, c6.xxxymov o3.xy, v0.zyzw

ps_3_0dcl_color v0dcl_color1 v1mov r0, v0add r0, r0, v1add oC0, r0, r0

• Transformación de los vertices• Transformación de la normal• Normalizacion• Calculo de la luz incidente • Pixel Shader• Parametros utilizados

– c1-c4 : WorldViewProj – c7-c10 : Transpuesta

de la inversa de World– c4 : direccion de la luz– c5 : Color de la luz



def: asigna un valor a la constante c# sin necesidad de especificarlo via Set*ConstantShader

dcl: indican el tipo de uso o significado que tendrán los registros indicados.Se puede aplicar parcialmente

dcl_color o3.xdcl_texcoord o3.yz

Permiten vincular :Streams (Vertices/Indices) VS InputVS Output PS Input



Transformación de la normal

Existen 2 Mecanismos :

• “Seguro“: consiste en multiplicar la normal del vértice por la transpuesta de la inversa de la matriz World (sin incluir View y Projection)

• “No tan seguro” : multiplicar por la matriz World. Valido solo para transformaciones de cuerpos rígidos

• Traslación

• Rotación

• Escala uniforme



Obtener en r0.w el coseno del ángulo que forman los vectores

||V

VVn

Multiplica el color de la luz por el coseno obtenidos y lo aplica como diffuse



||V

VVn

ps_3_0dcl_color v0dcl_color1 v1mov r0, v0add r0, r0, v1add oC0, r0, r0


Resumen de instrucciones • dcl• def• rsq

HLSL & Effects

HLSL y Effects

Que es el HLSL

• HLSL es un lenguaje de alto nivel para la creación de shaders (VS y PS)

• Sintaxis muy similar a la de C

• Soporta tipos de datos mas flexibles

• Permite generar codigo reusable y la creación de funciones

HLSL y Effects

Principales caracteristicas del HLSLTipos de datos

• Tipos básicos– BOOL, int , half, float, double

• Vector– Los tipos basicos mas un numero de 1 a 4 que indica la cantidad de componentes (Ej float4)

• Matriz– Son los tipos basicos mas 2 numeros que indican la cantidad de filas y columnas que posee (Ej float4x4, int2x2)

HLSL y Effects

Principales caracteristicas del HLSLTipos de datos• ShaderType

– Pueden ser vertexshader o pixelshader (ej vertexshader vs=compile vs_3_0 vs_transforma();• Sampler : no son accedido directamente sino a través de funciones de lookup sobre las texturas• Tipos de datos definidos por el usuario (typedef)• Soporte para arrays ( ej. float3 v3[2] )• Soporte para estructuras

struct {float3 v3_pos;float2 v2_normal;

}

HLSL y Effects

Principales caracteristicas del HLSLConstructores• float3 v3Pos = float3 (0.0, 0.0, 0.0);

Control del flujo de ejecución• if (cond) then … else ….

Loops• while / do-while• for

El loop esta Soportado para todos los modelos de shader !!!

HLSL y Effects

Principales caracteristicas del HLSLFunciones• Sintaxis C Style • Soporte de prototipos y forward declaration• Los argumentos se pasan por valor• Los parámetros soportan valores por defecto.• NO soportan llamadas recursivas

float4 getProm ( in float value1, in float value2){

return (value1 + value2) / 2;

}

HLSL y Effects

Principales caracteristicas del HLSLFunciones Intrinsecas (un montón)

• degrees, lerp, radians, saturateabs, clamp, isfinite, isnan, max, min, signacos, asin, atan, atan2, ceil, cos, cosh, exp, exp2, floor, fmod, frac, frexp, isinf, ldexp, log, log2, log10, modf, pow, round, rsqrt, sin, sincos, sinh, smoothstep, sqrt, step, tan, tanhtex1Dproj, tex2Dproj, tex3Dproj, texCUBEproj, tex1Dbias, tex2Dbias, tex3Dbias, texCUBEbias …

• Algunas estan mapeadas directamente sobre instrucciones de GPU, otras actuan como macro instrucciones.• Pueden tener problemas cuando se compila bajo ciertas versiones de VS o PS.

HLSL y Effects

Que son los Effects

Agrupación de Tecnicas de renderizado que permite la programación de vertex y pixel shaders y el control de FF pipeline.

Un effect, esta compuesto por multiples técnicas y a su vez cada técnica esta formada por varias pasadas.

HLSL y Effects

Ventajas de usar Effects

• Desacoplan el engine de los algoritmos de renderizado, con lo cual no queda código hardcoded y disminuye la necesidad de parametrizar en el código.

• Este desacoplamiento, permite mas trabajo en paralelo y especialización en las tareas.

• Permiten implementar varias técnicas, cada una con su propia version de VS,PS y RS, haciendo posible crear un unico effect que contemple varias configuraciones de hardware

HLSL y Effects

Estructura de los Effects• Declaración de Variables Globales

• Mapean directamente con la tabla de constantes de los shaders

• Son compartidas por todo el effect • Funciones

• Escritas generalmente en HLSL• Utilizan las variables globales y pueden declarar sus

propias variables locales• Son invocadas por las Techniques y Pass

• Definición de Tecnicas (Techniques)• Contienen 1 o mas Iteraciones (Pass) • Cada Pass permiten setear los valores de los pipeline• Cada Pass tiene una variable del tipo Ver

HLSL y Effects

Estructura de un archivo Effect

technique Tecnica_VS11{ pass P0{

// vs, ps y render states de la pasada 0} pass P1 {

// vs, ps y render states de la pasada 1 }}

technique Tecnica_VS3{ pass P0 {

// vs, ps y render states de la pasada 0 }

}

HLSL y Effects

Ejemplo de un Effect simplefloat4x4 worldViewProj struct vertexInput { float4 position : POSITION; float4 normal : NORMAL; };struct vertexOutput { float4 hPosition : POSITION;};vertexOutput VS_Transform(vertexInput IN){ vertexOutput OUT; OUT.hPosition = mul (IN.position, worldViewProj);

return OUT;}float4 PS_Simple( vertexOutput IN): COLOR { float4 res = (IN.diffAmbColor + IN.specCol) * 2.0; return res; }technique textured{ pass p0 {

ZEnable = true;VertexShader = compile vs_3_0 VS_Transform

();PixelShader = compile ps_3_0 PS_Simple();

}}

Informacion Uniforme Set*ShaderConstant

Informacion VariableSetStream

Funciones

Tecnicas

HLSL y Effects

Ejemplo de un Effect simplefloat4x4 worldViewProj struct vertexInput { float4 position : POSITION; float4 normal : NORMAL; };struct vertexOutput { float4 hPosition : POSITION;};vertexOutput VS_Transform(vertexInput IN){ vertexOutput OUT; OUT.hPosition = mul (IN.position, worldViewProj);

return OUT;}float4 PS_Simple( vertexOutput IN): COLOR { float4 res = (IN.diffAmbColor + IN.specCol) * 2.0; return res; }technique textured{ pass p0 {

ZEnable = true;VertexShader = compile vs_3_0 VS_Transform

();PixelShader = compile ps_3_0 PS_Simple();

}}

technique textured{ pass p0 {

Lighting= true; Ambient = float4 (1,0,0,1);MaterialDiffuse = float4 (1,1,1,1);LightDiffuse[0] = float4 (1,1,1,1);LightType[0] = Directional;LightEnable[0] = true; LightDirection[0]= float3 (0,-1,0);ColorWriteEnable = RED|GREEN|BLUE|ALPHA;ZEnable= true; ZWriteEnable= true;

}}

HLSL y Effects

Ejemplo de un Effect mas simple

En este caso el Effect no tiene código de VS o PS , simplemente altera el estado del FF pipeline.

InicializaciónLPD3DXBUFFER pError= NULL;D3DXCreateEffectFromFile(d3dDevice, _T("simple.fx"), NULL, NULL, 0, NULL,

&m_pEffect, &pError);

Dentro del loop de renderUINT iPass=0, cPasses;m_pEffect->SetTechnique(“Simple"); // Seleccionar la tecnica deseadam_pEffect->Begin(&cPasses, 0); // Comienza a ejecutar cada una de las m_Effect->SetMatrix(hParameter, pMatrix );for(iPass= 0; iPass< cPasses; iPass++){ // PASS que están definidas para la técnica

m_Effect->BeginPass(iPass);m_Mesh->DrawSubset( 0 );...m_Effect->EndPass();

}pEffect->End();

HLSL y Effects

Invocación desde el programa

HLSL y EffectsConsideraciones • No utilizar los métodos Set... con los nombres de las variables en el Effect, utilizar D3DXHANDLEs

// InicializaciónD3DXHANDLE hParameter =m_Effect->

GetParameterByName(0,“matrix” );

// Render loopm_Effect->Begin(&iPasses, D3DXFX_DONOTSAVESTATE);m_Effect->BeginPass(iPass);m_Effect->SetMatrix(hParameter, pMatrix );m_Effect->CommitChanges();m_Mesh->DrawSubset( 0 );...m_Effect->EndPass(); m_Effect->End();

HLSL y Effects

Consideraciones• La utilización del metodo FindNextValidTechnique

permite que Direct3D seleccione la tecnica mas adecuada para la configuración actual. Sin embargo, la selección de las técnicas validas para una determinada configuración de hardware depende en gran medida de los flags de creación del device y no exactamente del hardware en si.

• La utilizacion de HLSL, puede generar inconvenientes en algunas versiones de shaders y se recomienda la utilizacion de herramientas especificas como RenderMonkey , FX Composer y VisualStudio para la depuración y control.

HLSL y Effects

Annotations y Semantics• Las annotations son metadatos asociados a un parámetro

dentro del shader que pueden ser facilmente leídos por distintas herramientas DCC– float3 UpNormal : Normal

< string SasUiControl = “Numeric"; string SasUiDescription = “Vector Camara Up "; string SasUiVisible = false; >;

• Las semantics son indican como el dato en particular será tratado por el shader.

• Proveen una forma estandarizada de comunicar los shaders y variables con herramientas de desarrollo, engines y otras aplicaciones.

• Microsoft provee un set predefinido pero las anotaciones no están restringidas a este set, cada aplicación puede utilizar su propio conjunto de annotations.

HLSL y Effects

Annotations y Semantics• Algunas formas de acceder a los parametros de un Effect

– GetParameter (parentHandle, indice)

– GetParameterBySemantic (parentHandle, “diffuse”)

• Para acceder a las Annotations– GetAnnotation( paramHandle, indice)

– GetAnnotationByName( paramHandle, “UIWidget”);

Herramientas

Herramientas

Herramientas de Creación

• Herramientas dentro del DirectX 9 SDK• RenderMonkey (ATI)• FxComposer (Nvidia)• VisualStudio 2003 + DirectX Extensions (Microsoft)

Herramientas

Herramientas de DirectX 9

• EffectEdit : Editor de Efectos y HLSL

• Fxc.exe : Compilador de Efectos por linea de comandos.– Puede generar el codigo equivalente en VS y PS ASM

• Pix : Herramienta de Benchmarking para D3D

• Psa.exe : Compilador de Pixelshaders

• Vsa.exe : Compilador de VertexShaders

• DxTex : Conversor de texturas

Herramientas

FX Composer

Librería de materiales

Propiedades

Extraidas via Annotations y Semantics

Resultado del renderTexturas

Fuente del Effect

Herramientas

FX Composer

Librería de materiales

ASM de los VS o PS generados

Resultado del renderTexturas

Fuente del Effect

Herramientas

Visual Studio 2003

GPGPU : General Purpose GPU

Es la aplicación del modelo de programación por streams sobre el GPU

Que es el modelo de programación por streams?

Es un modelo donde la información a procesar ingresa a través de un stream o flujo constituido por un set de datos donde cada item es del mismo tipo (floats, vertices, indices).

Esta información es procesada por unidades de transformación llamadas kernels.

GPGPU

S Input K1 K2 S Output

Caracteristicas de los kernels

• Actuan sobre el stream completo• Los resultados de procesar un elemento del stream no dependen

del resultado del procesamiento de otro elemento• Las aplicaciones basadas en streams y kernels se construyen

concatenando varios kernels distintos , constituyendo la salida del primero la entrada del segundo y asi sucesivamente. (un ejemplo de esto es una planta de montaje o el mismo pipeline de las placas 3D)

GPGPU

El GPU como un stream processor

• Las texturas son los streams de ingreso y salida de cada kernel• Los pixelshader constituyen los kernels• Los vertexshaders no tienen una utilización critica en este modelo• Las placas con GPU actuales permite procesar varios items de

stream en paralelo gracias a la implementación de multiples Pipelines, que benefician el paralelismo inherente a un stream processor.

• La aparición de HLSL, GLSL, Cg y otros lenguajes facilita el desarrollo de estas aplicaciónes, y surgen lenguajes especificos e independientes de la plataforma como Sh o Brook

GPGPU

Algoritmo Basico basado en Effect/HLSL• Pass 0

1. Establecer una textura de entrada (ej = 256x256 )

2. Establecer una textura como rendertarget (256x256)

3. Generar una camara ortogonal (sin perspectiva, y los puntos se corresponden)

4. Cargar un VS, con un cuad texturizado de 256x 256

5. Cargar un PS con la logica de transformacion y procesar el fragmento escribiendolo al rendertarget.

• Pass 2 1. Establecer el rendertarget como textura de entrada

2. Establecer un nuevo rendertarget

3. Continuar con la misma logica del paso 3 de la Pass 1 pero con un PS distinto (Kernel 2)

Agregar tantas Pass como Kernels sean necesarios.

GPGPU

Sistema de particulas GPGPU

GPGPU

Gracias a todos.

Dudas, Preguntas?

introducción a los vertex shader en directx 9 alexis sattler ([email protected]) octubre 2005

Documents