Introducción a los Vertex Shader en DirectX 9 Alexis Sattler 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

Vertex Shader Vertex Shader Ubicación en el Pipeline3D Vertex Stream Vertex Shader T&L Culling, Clipping Triangle setup Rasterization Texturizado Pixel Shader Fog Alpha Test Stencil Test Depth Test Alpha Blend Render Target

Que son los shaders En que momento se ejecutan 10 3 Ejecuciones del VS ~ 50 Ejecuciones del PS

Arquitectura Lógica Vertex Shader Unit Vertex Stream SetStreamSource SetIndices Texturas SetTexture (Device, Effect) VertexShader Constants SetVertexShaderConstant Procesamiento de Primitivas Pixel Shader Unit Procesamiento de Pixels Pixel Shader Constants SetPixelShaderConstant Pixel Shader Program SetPixelShader Vertex Shader Program SetVertexShader FF SetRenderState FF SetRenderState Texturas SetTexture (Device, Effect)

VS – Registros Entrada RegDescCantidadAccesoVersion VS v#Input Vector16ROTodos r#Resultados Intermedios12-32RWTodos c#Parametros Float Ctes ROTodos a0Registro Indice.x- xyzwRWTodos b#Parámetros Bool Ctes>=2.0 aLContador IteracionesRO>=2.0 i#Parámetros Int Ctes16RO>=2.0 s#Sampler4->=3.0 p0Registro predicado1RW>=2.x

VS – Registros Salida oPosPosicion Vertice16W<3.0 oFogNiebla Por Vertice1W<3.0 oPtsTamaño Punto1W<3.0 oD#D0 : diffuse D1: spec2W<3.0 oT#Text Coord8W<3.0 o#Generico12W3.0

PS – Registros Entrada RegDescCantidadAccesoVersion VS v#Input Color2-10ROTodos r#Resultados Intermedios 2-32RWTodos c#Parametros Float Ctes8-224ROTodos t#Coordenadas Textura.x- xyzwRW<3.0 b#Parametros Bool Ctes16RO>=2.0 aLContador IteracionesRO>=3.0 i#Parametros Int Ctes16RO>=2.0 s#Sampler16->=2.0 p0Registro predicado1RW>=2.x vFaceIndicador de backfaceR>=3.0 vPosPosicion en Pantalla1R>=3.0

PS – Registros Salida RegDescCantidadAccesoVersion VS r0Color1W1.x oC#Color deSalida4W>=2.0 oDepthValor de Salida para Depto Stencil test 1W>=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.1 m4x4 r0, v0, c1 m4x4 r0, r0, c5 m4x4 oPos, r0, c9 mov 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 – Transformación vs 1.1 m4x4 r0, v0, c1 m4x4 r0, r0, c5 m4x4 oPos, r0, c9 mov oD0, c13 Fuente vs 1.1 dp4 r0.x, v0, c1 dp4 r0.y, v0, c2 dp4 r0.z, v0, c3 dp4 r0.w, v0, c4 dp4 r0.x, r0, c5 dp4 r0.y, r0, c6 dp4 r0.z, r0, c7 dp4 r0.w, r0, c8 dp4 r0.x, v0, c1 dp4 r0.y, v0, c2 dp4 r0.z, v0, c3 dp4 r0.w, v0, c4 mov oD0, c13

VS – Transformación 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

VS – Transformación 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

VS – Transformación Como establecer los parametros m11 m12 m13 m14 m21 m22 m23 m24 m31 m32 m33 m34 m41 m42 m43 m44 Filam11 m12 m13 m14m21 m22 m23 m24m31 m32 m33 m34m41 m42 m43 m44 Registro GPUC1C2C3C4 dp4 b,c = b.x * c.x + b.y * c.y + b.z * c.z + b.w * c.w SetVertexShaderConstant dp4 r0.x, v0, c1 dp4 r0.y, v0, c2 dp4 r0.z, v0, c3 dp4 r0.w, v0, c4 ERROR !!!!

VS – Transformación Como establecer los parametros m11 m12 m13 m14 m21 m22 m23 m24 m31 m32 m33 m34 m41 m42 m43 m44 SetVertexShaderConstant 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 m41 m42 m43 m44m31 m32 m33 m34m21 m22 m23 m24m11 m12 m13 m14 m21 m22 m23 m24 m31 m32 m33 m34 m41 m42 m43 m44 Transposicion via D3DXMatrixTranspose

VS – Transformación Como establecer los parametros d3dDevice->SetVertexShader(pdwShader); d3dDevice->SetVertexDeclaration(m_decl1); d3dDevice->SetStreamSource(0, pVBBuffer, offset, size ); Render

VS – Transformación Resumen de instrucciones m4x4 dp4 mov SetVertexShaderConstantF

VS – Iluminación Gouraud Fuente vs_3_0 def c6, 0, 1, 0, 0 dcl_position v0 dcl_normal v1 dcl_position o0 dcl_color o1 dcl_color1 o2 dcl_texcoord o3.xy dp4 o0.x, v0, c0 dp4 o0.y, v0, c1 dp4 o0.z, v0, c2 dp4 o0.w, v0, c3 dp4 r0.x, v1, c7 dp4 r0.y, v1, c8 dp4 r0.z, v1, c9 dp4 r0.w, v1, c10 dp4 r1.w, r0, r0 rsq r1.w, r1.w mul r0, r0, r1.w dp4 r0.w, r0, -c4 mul o1, r0.w, c5 mov o2, c6.xxxy mov o3.xy, v0.zyzw ps_3_0 dcl_color v0 dcl_color1 v1 mov r0, v0 add r0, r0, v1 add 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

VS – Iluminación Gouraud Fuente vs_3_0 def c6, 0, 1, 0, 0 dcl_position v0 dcl_normal v1 dcl_position o0 dcl_color o1 dcl_color1 o2 dcl_texcoord o3.xy dp4 o0.x, v0, c0 dp4 o0.y, v0, c1 dp4 o0.z, v0, c2 dp4 o0.w, v0, c3 dp4 r0.x, v1, c7 dp4 r0.y, v1, c8 dp4 r0.z, v1, c9 dp4 r0.w, v1, c10 dp4 r1.w, r0, r0 rsq r1.w, r1.w mul r0, r0, r1.w dp4 r0.w, r0, -c4 mul o1, r0.w, c5 mov o2, c6.xxxy mov o3.xy, v0.zyzw 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.x dcl_texcoord o3.yz Permiten vincular : Streams (Vertices/Indices)  VS Input VS Output  PS Input

VS – Iluminación Gouraud Fuente vs_3_0 def c6, 0, 1, 0, 0 dcl_position v0 dcl_normal v1 dcl_position o0 dcl_color o1 dcl_color1 o2 dcl_texcoord o3.xy dp4 o0.x, v0, c0 dp4 o0.y, v0, c1 dp4 o0.z, v0, c2 dp4 o0.w, v0, c3 dp4 r0.x, v1, c7 dp4 r0.y, v1, c8 dp4 r0.z, v1, c9 dp4 r0.w, v1, c10 dp4 r1.w, r0, r0 rsq r1.w, r1.w mul r0, r0, r1.w dp4 r0.w, r0, -c4 mul o1, r0.w, c5 mov o2, c6.xxxy mov o3.xy, v0.zyzw 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

VS – Iluminación Gouraud Fuente vs_3_0 def c6, 0, 1, 0, 0 dcl_position v0 dcl_normal v1 dcl_position o0 dcl_color o1 dcl_color1 o2 dcl_texcoord o3.xy dp4 o0.x, v0, c0 dp4 o0.y, v0, c1 dp4 o0.z, v0, c2 dp4 o0.w, v0, c3 dp4 r0.x, v1, c7 dp4 r0.y, v1, c8 dp4 r0.z, v1, c9 dp4 r0.w, v1, c10 dp3 r1.w, r0, r0 rsq r1.w, r1.w mul r0, r0, r1.w dp4 r0.w, r0, -c4 mul o1, r0.w, c5 mov o2, c6.xxxy mov o3.xy, v0.zyzw Obtener en r0.w el coseno del ángulo que forman los vectores Multiplica el color de la luz por el coseno obtenidos y lo aplica como diffuse

VS – Iluminación Gouraud Fuente vs_3_0 def c6, 0, 1, 0, 0 dcl_position v0 dcl_normal v1 dcl_position o0 dcl_color o1 dcl_color1 o2 dcl_texcoord o3.xy dp4 o0.x, v0, c0 dp4 o0.y, v0, c1 dp4 o0.z, v0, c2 dp4 o0.w, v0, c3 dp4 r0.x, v1, c7 dp4 r0.y, v1, c8 dp4 r0.z, v1, c9 dp4 r0.w, v1, c10 dp3 r1.w, r0, r0 rsq r1.w, r1.w mul r0, r0, r1.w dp4 r0.w, r0, -c4 mul o1, r0.w, c5 mov o2, c6.xxxy mov o3.xy, v0.zyzw ps_3_0 dcl_color v0 dcl_color1 v1 mov r0, v0 add r0, r0, v1 add oC0, r0, r0

VS – Transformación 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 HLSL Tipos 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 HLSL Tipos 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 HLSL Constructores 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 HLSL Funciones 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 HLSL Funciones Intrinsecas (un montón) degrees, lerp, radians, saturate abs, clamp, isfinite, isnan, max, min, sign acos, 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, tanh tex1Dproj, 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 simple float4x4 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 Variable SetStream Funciones Tecnicas

HLSL y Effects Ejemplo de un Effect simple float4x4 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ón LPD3DXBUFFER pError= NULL; D3DXCreateEffectFromFile(d3dDevice, _T("simple.fx"), NULL, NULL, 0, NULL, &m_pEffect, &pError); Dentro del loop de render UINT iPass=0, cPasses; m_pEffect->SetTechnique(“Simple");// Seleccionar la tecnica deseada m_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 Effects Consideraciones No utilizar los métodos Set... con los nombres de las variables en el Effect, utilizar D3DXHANDLEs // Inicialización D3DXHANDLE hParameter =m_Effect-> GetParameterByName(0,“matrix” ); // Render loop m_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 ; 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 de Creación Herramientas dentro del DirectX 9 SDK RenderMonkey (ATI) FxComposer (Nvidia) VisualStudio 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 render Texturas Fuente del Effect

Herramientas FX Composer Librería de materiales ASM de los VS o PS generados Resultado del render Texturas Fuente del Effect

Herramientas Visual Studio 2003

GPGPU

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 K1K2 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 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?