Post on 13-Feb-2015
Introducción a los Vertex Shader en DirectX 9
Alexis Sattler (alexiss@gmail.com)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
Reg Desc Cantidad Acceso Version VS
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
Reg Desc Cantidad Acceso Version VS
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 – Transformación
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
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 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
SetVertexShaderConstant
dp4 r0.x, v0, c1dp4 r0.y, v0, c2dp4 r0.z, v0, c3dp4 r0.w, v0, c4 ERROR !!!!
VS – Transformación
Como establecer los parametros
m11 m12 m13 m14m21 m22 m23 m24m31 m32 m33 m34m41 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
m11 m12 m13 m14m21 m22 m23 m24m31 m32 m33 m34m41 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
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
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
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
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
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
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 dp3 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
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
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 dp3 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
||V
VVn
ps_3_0dcl_color v0dcl_color1 v1mov r0, v0add r0, r0, v1add 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 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
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?