Tema 6. Gráficos 3D con DirectX

Introducción a la
Programación Lúdica
Tema 6. Gráficos 3D con DirectX

Esquema
• Comenzando con Direct3D
• Proceso de renderizado
• Representación de escenas 3D con D3D
• Realismo de escenas
• Shaders

Esquema
• Comenzando con Direct3D
–Descripción
– Inicialización
– Bucle del juego
– Función de renderización
– Programa principal
• Proceso de renderizado
• Representación de escenas 3D con D3D
• Realismo de escenas
• Shaders

Comenzando con Direct3D
• Descripción:
– DirectX es un conjunto de interfaces de programación (APIs) para el desarrollo
de aplicaciones multimedia sobre la plataforma Windows.
– Creada y distribuida por Microsoft.
– Consta de dos partes: SDK, Runtime.
– Basado en COM (Component Object Model).
– Desde la versión 9, puede utilizarse desde programas en lenguajes CRL: C++,
C#, Visual Basic, etc.
– Componentes (versión 9):
• Direct3D (gráficos)
• DirectSound (efectos)
• DirectMusic (música)
• DirectInput (entrada)
• DirectPlay (comunicaciones)
• DirectShow (reproducción de vídeo)
• DirectSetup (instalación)
– Ejemplos: http://www.moon-labs.com/samples/BookPart2Code.zip (Introduction
to 3D Game Programming with DirectX 9, Frank D. Luna. Wordware, 2003)

Comenzando con Direct3D
• Inicialización:
1. Obtener un puntero a una interfaz
IDirect3D9.
2. Comprobar las características del
dispositivo (D3DCAPS9) para determinar si la
tarjeta gráfica principal soporta
procesamiento de vértices por hardware.
3. Inicializar una instancia de la estructura
D3DPRESENT_PARAMETERS.
4. Crear el objeto IDirect3DDevice9.

Comenzando con Direct3D
• Inicialización (1, 2):
// Obtener puntero a IDirect3D9
IDirect3D9* d3d9;
d3d9 = Direct3DCreate9(D3D_SDK_VERSION);
// Comprobar características del dispositivo
D3DCAPS9 caps;
d3d9->GetDeviceCaps(
D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
&caps);
int vp = 0;
if( caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT ) {
vp = D3DCREATE_HARDWARE_VERTEXPROCESSING;
} else {
vp = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
}

Comenzando con Direct3D
• Inicialización (3):
// Crear estructura D3DPRESENT_PARAMETERS
D3DPRESENT_PARAMETERS d3dpp;
d3dpp.BackBufferWidth = 800;
d3dpp.BackBufferHeight = 600;
d3dpp.BackBufferFormat = D3DFMT_A8R8G8B8; //pixel format
d3dpp.BackBufferCount = 1;
d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;
d3dpp.MultiSampleQuality = 0;
d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
d3dpp.hDeviceWindow = hwnd;
d3dpp.Windowed = false; // fullscreen
d3dpp.EnableAutoDepthStencil = true;
d3dpp.AutoDepthStencilFormat = D3DFMT_D24S8; // depth format
d3dpp.Flags = 0;
d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

Comenzando con Direct3D
• Inicialización (4):
// Crear el objeto IDirect3DDevice9
IDirect3DDevice9* device = 0;
hr = d3d9->CreateDevice(
D3DADAPTER_DEFAULT, // primary adapter
D3DDEVTYPE_HAL, // device type
hwnd, // window associated with device
D3DCREATE_HARDWARE_VERTEXPROCESSING, // vertex processing type
&d3dpp, // present parameters
&device); // returned created device
if( FAILED(hr) ) {
::MessageBox(0, "CreateDevice() - FAILED", 0, 0);
return 0;
}

Comenzando con Direct3D
• Bucle del juego:
– Por defecto, cualquier aplicación en Windows se
ejecuta en un bucle (MessageLoop) donde se
atienden los mensajes o eventos que se han
producido sobre la interfaz gráfica.
– Para ello, se utiliza un método GetMessage(…), que
suspende la ejecución hasta que se realiza una
entrada.
– En programación de videojuegos no puede detenerse
la ejecución porque es necesario actualizar la
pantalla: uso de método PeekMessage(…).

Comenzando con Direct3D
• MessageLoop:
// Estructura del bucle del juego en DirectX
int d3d::EnterMsgLoop( bool (*ptr_display)(float timeDelta) ) {
MSG msg;
::ZeroMemory(&msg, sizeof(MSG));
static float lastTime = (float)timeGetTime();
}
while(msg.message != WM_QUIT) {
if(::PeekMessage(&msg, 0, 0, 0, PM_REMOVE)) {
::TranslateMessage(&msg);
::DispatchMessage(&msg);
} else {
float currTime = (float)timeGetTime();
float timeDelta = (currTime - lastTime)*0.001f;
ptr_display(timeDelta); // Render function
lastTime = currTime;
}
}
return msg.wParam;

Comenzando con Direct3D
• Render function:
// Ejemplo de funcion de renderizado
bool Display(float timeDelta) {
if( Device ) {
Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
0x00000000, 1.0f, 0);
Device->Present(0, 0, 0, 0); // present backbuffer
}
return true;
}

Comenzando con Direct3D
• Programa principal:
// Ejemplo de programa principal (utiliza d3dUtility.h)
int WINAPI WinMain(HINSTANCE hinstance,
HINSTANCE prevInstance,
PSTR cmdLine,
int showCmd) {
}
if(!d3d::InitD3D(hinstance,
800, 600, true, D3DDEVTYPE_HAL, &Device)) {
::MessageBox(0, "InitD3D() - FAILED", 0, 0);
return 0;
}
if(!Setup()) {
::MessageBox(0, "Setup() - FAILED", 0, 0);
return 0;
}
d3d::EnterMsgLoop( Display );
Cleanup();
Device->Release();
return 0;

Comenzando con Direct3D
• Ejemplo completo:
– Chapter 1/D3D9 Init/*

Esquema
• Comenzando con Direct3D
• Proceso de renderizado
– Modelos
– Cámara
– Fases
• Coordenadas locales
• Coordenadas de mundo
• Coordenadas de vista
• Eliminación de caras ocultas
• Iluminación
• Recorte
• Proyección
• Coordenadas de viewport
• Rasterización
• Representación de escenas 3D con D3D
• Realismo de escenas
• Shaders

Proceso de renderizado
• Modelos:
– Vértices: Punto donde se unen dos aristas.
• Definen la forma de los objetos.
• Propiedades: Posición, Color, Normal, Textura.
• Pueden crearse a medida (FVF: Flexible Vertex Flags).
– Triángulos: Elemento básico.
– Mallas: Conjunto de triángulos que determina la
forma de un modelo.
– Índices: Referencias a los vértices que forman una
malla.
• Evitan duplicar las definiciones de vértices de un objeto.

Proceso de renderizado
• Modelos:
–Vértices:
struct NormalTexVertex {
float _x, _y, _z; // position
float _nx, _ny, _nz; // normal vector
float _u, _v; // texture coordinates
}
#define FVF_NORMAL_TEX (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1)
–Malla:
Vertex rectangle[6] = { v0, v1, v2, // triangle0
– Índices:
v0, v2, v3}; // triangle1
Vertex vertexList[4] = {v0, v1, v2, v3};
WORD indexList[6] = { 0, 1, 2, // triangle0
0, 2, 3}; // triangle1

Proceso de renderizado
• Cámara:
– Definición de frustrum, que determina qué objetos
son visibles y los parámetros de la proyección.
Ángulo de Campo de
Visión Horizontal
Centro de proyección
Ventana de Proyección
Ángulo de Campo de Visión Vertical
Plano Lejano
Plano Cercano

Proceso de renderizado
• Fases del Proceso de Renderización:
– Renderizado: Procedimiento por el cual se crea una imagen 2D
que representa un mundo 3D, dada una descripción de la
geometría del escenario y una cámara virtual que determina la
posición y la orientación del observador.
– Etapas:

Proceso de renderizado
• Coordenadas locales:
– Para simplificar, los
modelos se definen en
su propio sistema de
coordenadas.
– Para posicionarlos
dentro del espacio de
coordenadas del
mundo es necesario
aplicarles una
transformación
geométrica.

Proceso de renderizado
• Coordenadas de mundo:
– Sistema de coordenadas
de referencia para los
objetos del escenario que
se pretende representar.
– Transformada de mundo:
transformación geométrica
de las coordenadas locales
a las coordenadas de
mundo.
– D3D: Transformada
D3DTS_WORLD

Proceso de renderizado
• Coordenadas de mundo:
// Ejemplo de transformada de mundo
// Build the cube world matrix that only consists of a translation.
D3DXMATRIX cubeWorldMatrix;
D3DXMatrixTranslation(&cubeWorldMatrix, -3.0f, 2.0f, 6.0f);
// Build the sphere world matrix that only consists of a translation.
D3DXMATRIX sphereWorldMatrix;
D3DXMatrixTranslation(&sphereWorldMatrix, 5.0f, 0.0f, -2.0f);
// Set the cube’s transformation
Device->SetTransform(D3DTS_WORLD, &cubeWorldMatrix);
drawCube(); // draw the cube
// Now since the sphere uses a different world transformation, we
// must change the world transformation to the sphere’s. If we
// don’t change this, the sphere would be drawn using the previously
// set world matrix – the cube’s.
Device->SetTransform(D3DTS_WORLD, &sphereWorldMatrix);
drawSphere(); // draw the sphere

Proceso de renderizado
• Coordenadas de vista:
– La cámara debe situarse utilizando el sistema de
coordenadas de mundo.
– Es interesante posicionar arbitrariamente la cámara,
pero difícil de implementar.
– Solución: transformar los objetos del mundo respecto
de la cámara, de forma que ésta siempre esté situada
en el origen de coordenadas mirando hacia Z+.
– D3D calcula automáticamente la transformada de
vista (D3DTS_VIEW) con D3DXMatrixLookAtLH.

Proceso de renderizado
• Coordenadas de vista:
// Ejemplo de transformada de vista
D3DXVECTOR3 position(5.0f, 3.0f, –10.0f); // posicion
D3DXVECTOR3 targetPoint(0.0f, 0.0f, 0.0f); // direccion
D3DXVECTOR3 worldUp(0.0f, 1.0f, 0.0f); // vertical
D3DXMATRIX V;
D3DXMatrixLookAtLH(&V, &position, &targetPoint, &worldUp);
Device->SetTransform(D3DTS_VIEW, &V);

Proceso de renderizado
• Eliminación de caras ocultas:
– Cada polígono delimita dos caras, una visible y otra
que no debe mostrarse.
– D3D no muestra las caras ocultas de un modelo.
– Por defecto, D3D considera visibles los triángulos
cuyos vértices han sido enumerados en el sentido de
las agujas del reloj (en coordenadas de vista).
– Este comportamiento puede modificarse con el
método:
Device->SetRenderState(D3DRS_CULLMODE,
Value).

Proceso de renderizado
• Iluminación:
– Modifica el aspecto de un objeto según la luz
que incida sobre él.
– D3D permite definir fuentes de iluminación en
coordenadas de mundo.

Proceso de renderizado
• Recorte:
– Procedimiento por el cual se segmentan los
objetos que no caben completamente en el
espacio visible, eliminando las partes que
quedan fuera y presentando las que quedan
dentro.
– D3D se encarga automáticamente de realizar
el recorte de los objetos de la escena.

Proceso de renderizado
• Proyección:
– Transformación por la cual
se obtiene una
representación 2D de la
escena 3D.
– En este caso, interesa una
proyección de perspectiva.
– Para obtener la
transformada de
proyección
(D3DTS_PROJECTION) se
utiliza
D3DXMatrixPerspectiv
eFovLH.

Proceso de renderizado
• Proyección:
// Ejemplo de transformada de proyección
D3DXMATRIX proj;
D3DXMatrixPerspectiveFovLH(
&proj, // Matriz resultado
PI * 0.5f, // Ángulo de apertura
(float)width / (float)height, // Ratio anchura/altura
1.0, // Distancia plano delantero
1000.0f); // Distancia plano trasero
Device->SetTransform(D3DTS_PROJECTION, &proj);

Proceso de renderizado
• Transformada de viewport:
– Transformación que traslada la ventana 2D de proyección a una
sección rectangular de la pantalla.
– D3D utiliza una estructura D3DVIEWPORT9 con los parámetros
del viewport y el método Device->SetViewPort para asignarlo.
⎡ width
⎤
⎢
0 0 0
2
⎥
⎢ ⎥
⎢ height
0 −
0 0⎥
⎢ 2
⎥
⎢ 0 0 max Z − min Z 0⎥
⎢ ⎥
⎢ width height
⎥
⎢x + y +
min Z 1
⎣ 2 2
⎥⎦

Proceso de renderizado
• Transformada de viewport:
// Ejemplo de transformada de viewport
D3DVIEWPORT9 vp {
0, // Posicion X del vp respecto de la ventana de dibujo
0, // Posicion Y del vp respecto de la ventana de dibujo
640, // Anchura del vp
480, // Altura del vp
0, // Valor minimo del Z-buffer
1 }; // Valor maximo del Z-buffer
Device->SetViewport(&vp);

Proceso de renderizado
• Rasterización:
– Una vez realizada la transformada de viewport se
obtiene una lista de vértices de triángulos
posicionados en pantalla.
– La fase de rasterización calcula el color con el que
debe dibujarse cada uno de los píxeles del triángulo.
– Esta fase tiene un coste computacional alto y debe
realizarse, en la medida de lo posible, en la tarjeta
gráfica.
– El resultado final se envía al monitor, que presenta
los resultados.

Esquema
• Comenzando con Direct3D
• Proceso de renderizado
• Representación de escenas 3D con D3D
– Vertex / Index Buffers
– Estados de renderización
– Preparación para el dibujo
– Dibujado de Vertex / Index Buffers
– Objetos geométricos en D3D
• Realismo de escenas
• Shaders

Representación de escenas 3D
• Vertex / Index Buffers
– Vertex Buffer
• Zona de memoria contigua que almacena información sobre
vértices.
• Interfaz: IDirect3DVertexBuffer9.
• Creación: IDirect3DDevice9::CreateVertexBuffer
– Index Buffer
• Zona de memoria contigua que almacena información sobre índices
a vértices.
• Interfaz: IDirect3DIndexBuffer9.
• Creación: IDirect3DDevice9::CreateIndexBuffer
– Se utilizan estas interfaces en lugar de arrays.
– Se trata de memoria compartida.
– Pueden almacenarse en memoria de vídeo (static) o en
memoria interna (dynamic).

Representación de escenas 3D
• Vertex / Index Buffers:
// Creacion de buffers
IDirect3DVertexBuffer9* vb;
Device->CreateVertexBuffer(
8 * sizeof( Vertex ), // Tamaño reservado (8 vertices)
0, // Uso (no asignado)
D3DFVF_XYZ, // Formato de la estructura Vertex
D3DPOOL_MANAGED, // Pool de memoria donde se ubicará
&vb, // Estructura resultado
0); // Identificador compartido
IDirect3DIndexBuffer9* ib;
Device->CreateIndexBuffer(
36 * sizeof( WORD ), // Tamaño (36 indices de 16 bits)
D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, // Uso
D3DFMT_INDEX16, // Tamaño de los índices
D3DPOOL_MANAGED, // Pool de memoria donde se ubicará
&ib, // Estructura resultado
0); // Identificador compartido

Representación de escenas 3D
• Vertex / Index Buffers
– Acceso:
• Necesario obtener un puntero a la memoria del
búfer.
• Métodos Lock() / Unlock(…).
– Recuperación de información:
• Estructura D3DVERTEXBUFFER.
• Método GetDesc().

Representación de escenas 3D
• Vertex / Index Buffers:
// Acceso a buffers
// Bloquear buffer completo
Vertex* vertices;
vb->Lock(
0, // Offset (comienzo)
0, // Longitud
(void**)&vertices, // Vector resultado
0); // Modo de acceso
// Asignar valores al buffer
vertices[0] = Vertex(-1.0f, 0.0f, 2.0f);
vertices[1] = Vertex( 0.0f, 1.0f, 2.0f);
vertices[2] = Vertex( 1.0f, 0.0f, 2.0f);
// Desbloquear buffer
vb->Unlock();

Representación de escenas 3D
• Estados de renderización:
– Direct3D permite renderizar una escena de diferentes
formas.
– El renderizado por defecto suele ser el apropiado.
– Metodo IDirect3DDevice9::SetRenderState
– Ejemplo: Renderización en modo “alambres”
device->SetRenderState(
D3DRS_FILLMODE, // Propiedad a cambiar
D3DFILL_WIREFRAME); // Nuevo valor

Representación de escenas 3D
• Preparación para el dibujo:
– Asignar flujo de datos
(IDirect3DDevice9::SetStreamSource):
Asocia al dispositivo un vertex buffer, que contendrá
la geometría de las figuras que se van a renderizar.
– Asignar formato de vértices
(IDirect3DDevice9::SetFVF): Especifica el
formato de los vértices que se utilizarán en las
siguientes llamadas.
– Asignar índices de datos
(IDirect3DDevice9::SetIndices): Asocia al
dispositivo un conjunto de índices.

Representación de escenas 3D
• Dibujo de Index / Vertex Buffers:
– IDirect3DDevice9::BeginScene: Comenzar a
dibujar escena.
– IDirect3DDevice9::DrawPrimitive: Dibuja
primitivas (D3DPRIMITIVETYPE) sin utilizar índices.
– IDirect3DDevice9::DrawIndexedPrimitive:
Dibuja primitivas (D3DPRIMITIVETYPE) utilizando un
buffer de índices.
– IDirect3DDevice9::EndScene: Finalizar dibujo
de escena.

Representación de escenas 3D
• Preparación y dibujo de buffers:
// Preparacion
// Asociar vertex buffer completo como fuente de informacion
Device->SetStreamSource( 0, vb, 0, sizeof( Vertex ) );
// Asignar formato de vertices según estructura Vertex definida
Device->SetFVF( D3DFVF_XYZ | D3DFVF_DIFFUSE | D3DFVF_TEX1 );
// Asociar index buffer
Device->SetIndices( ib );
// Dibujar
Device->BeginScene();
// Dibujar 4 triángulos
Device->DrawPrimitive( D3DPT_TRIANGLELIST, 0, 4);
// Dibujar 12 triángulos usando buffer de indices
Device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 8, 0, 12);
Device->EndScene();

Representación de escenas 3D
• Dibujo de objetos geométricos:
– Definir figuras completas utilizando sólo triángulos
puede ser complicado.
– D3D ofrece primitivas para la creación de mallas de
triángulos (ID3DXMesh) que componen objetos
geométricos más complicados: prisma, esfera,
cilindro, polígono, toro, teterea.
– Estas primitivas asocian directamente la malla al
dispositivo Direct3D.
– Las mallas se dibujan con
ID3DXMesh::DrawSubset.

Representación de escenas 3D
• Dibujo de objetos geométricos:
// Crear malla tetera
ID3DXMesh* mesh = 0;
D3DXCreateTeapot(Device, &mesh, 0);
// Dibujar tetera
Device->BeginScene();
mesh->DrawSubset(0);
Device->EndScene();
// Liberar malla
mesh->Release();
mesh = 0;

Representación de escenas 3D
• Ejemplo completo: Dibujo de una tetera
– Chapter 3\Teapot

Esquema
• Comenzando con Direct3D
• Proceso de renderizado
• Representación de escenas 3D con D3D
• Realismo de escenas:
– Color
–Texturas
– Iluminación
– Blending
– Stenciling
• Shaders

Realismo de escenas
• Color:
– Modelo Alfa-RGB : D3DCOLOR (32 bits, [0, 255]);
D3DCOLORVALUE, D3DXCOLOR (128 bits, [0, 1]).
– La información de color puede incluirse en la
estructura de vértices definida por el programador.
– Shading: Cálculo del color de los píxeles de una
primitiva durante el proceso de renderizado.
• El color determinado por los colores asignados a sus vértices
(D3DCOLOR).
• Dos tipos: plano (color del primer vértice) y Gouraud
(suavizado).
• Puede modificarse con
IDirect3DDevice9::SetRenderState.

Realismo de escenas
• Color:
// Vertice con color
struct ColorVertex {
float _x, _y, _z;
D3DCOLOR _color;
static const DWORD FVF;
}
const DWORD ColorVertex::FVF = D3DFVF_XYZ | D3DFVF_DIFFUSE;
…
// Asignación de colores a un vertice (rojo, verde, azul)
ColorVertex t[3];
t[0]._color = D3DCOLOR_XRGB(255, 0, 0);
t[1]._color = D3DCOLOR_XRGB(0, 255, 0);
t[2]._color = D3DCOLOR_XRGB(0, 0, 255);

Realismo de escenas
• Ejemplo completo: Coloreado de
triángulos
– Chapter 4\Colore Triangle

Realismo de escenas
• Iluminación:
– Cuando se define una iluminación, D3D calcula
automáticamente el color de un objeto basándose en:
• Material de que está constituido
• Posición y orientación de las caras
• Fuentes de luz
– No se utiliza el valor de color de los vértices.
– La luz emitida por un objeto tiene tres componentes:
• Ambiental: Luz reflejada por otros objetos, no directa, que
ilumina un objeto aunque no esté iluminado.
• Difundida: Haz de luz direccional que se refleja en todas
direcciones sobre los objetos. Independiente del observador.
• Especular: Haz de luz direccional que se refleja en una sola
dirección. Depende del observador.

Realismo de escenas
• Iluminación:
– Materiales:
• Modelan la forma en que la luz se refleja en un objeto y, en
consecuencia, su color.
• Estructura D3DMATERIAL9. Componentes:
– Valoración para cada tipo de reflexión (Ambiental, Difundida,
Especular).
– Brillo propio.
– Potencia del reflejo especular.
• La información de material no se codifica con la información
geométrica de vértice, debe asignarse antes de dibujar con
IDirect3DDevice9::SetMaterial.

Realismo de escenas
• Iluminación:
– Normales de los vértices:
• Se utilizan para determinar el ángulo de incidencia
de la luz sobre una superficie.
• Se calculan como la media de las normales de las
caras a las que pertenece un vértice.
• La normal sí se incorpora a la estructura Vértice
definida por el programador (y se elimina la
información de color).

Realismo de escenas
• Iluminación:
– Fuentes de luz:
• Estructura D3DLIGHT9.
• Tres tipos: Puntual (todas direcciones), Direccional
(una dirección, rayos paralelos), Orientada (una
dirección, rayos en forma de cono).
• Asignar fuentes de luz de la escena:
IDirect3DDevice9::SetLight,
IDirect3DDevice9::EnableLight.

Realismo de escenas
• Ejemplo completo: Iluminación
– Chapter 5\directional light

Realismo de escenas
• Texturas:
– Imagen 2D que se proyecta sobre un triángulo para
definir el aspecto de una cara.
– Texel: Posición (u, v) dentro del espacio de
coordenadas de una textura ([0, 1]).
– Cada vértice de un triángulo 3D se asocia a un texel,
estableciéndose una correspondencia que mapea la
textura sobre el triángulo.
– La posición del espacio de texturas asociada al
vértice se añade a la estructura Vértice definida por el
programador.

Realismo de escenas

Realismo de escenas
• Texturas:
– Gestión de texturas:
• Estructura IDirect3Dtexture9.
• Crear textura: D3DXCreateTextureFromFile.
• Asignar textura: IDirect3DDevice9::SetTexture.
– Filtros: Mejoran la apariencia de las texturas cuando
se produce distorsión (punto más cercano, lineal,
anisotrópico).
– Mipmaps: Uso de varias texturas de diferente tamaño
para reducir la distorsión.
– Direccionamiento: Comportamiento cuando los
valores en el espacio de texturas salen del rango [0,
1] (wrap, clamp, border color, mirror).

Realismo de escenas
• Ejemplo completo: Texturas
– Chapter 6\TexCube

Realismo de escenas
• Blending:
– Combinar píxeles que se están rasterizando
en este momento con otros que se han
rasterizado previamente.
• Stenciling:
– Uso de un buffer adicional para realizar
efectos de iluminación que requieren
renderizar selectivamente ciertos objetos
(espejos, proyección de sombras, etc.)

Esquema
• Comenzando con Direct3D
• Proceso de renderizado
• Representación de escenas 3D con D3D
• Realismo de escenas
• Shaders
–Descripción
– Programación
– Vertex shaders
– Pixel shaders

Shaders
• Los shaders son piezas de código que permiten
modificar la forma en que se realiza alguna de
las fases del proceso de renderizado.
• Se ejecutan directamente sobre el hardware de
la GPU (Graphics Processing Unit).
• Aumentan la flexibilidad y la eficiencia en el
proceso de generación de gráficos 3D.
• Lenguajes:
– Ensamblador de bajo nivel específico de la GPU.
– Lenguajes de alto nivel para shaders: Cg, GLSL,
DirectX HLSL.

Shaders
• Programación de shaders:
– Crear fichero de texto con código shader.
– Compilar shader:
• Estática (en tiempo de compilación)
• Dinámica (en tiempo de ejecución)
– Cargar shader
– Activar shader
– Ejecutar shader

Shaders
• Vertex shaders:
– Reemplazan las fases de transformación e iluminación en el proceso de
renderización.
– Suelen ejecutarse en la GPU de la tarjeta gráfica, aunque puede
emularse por software.
– Permiten implementar nuevos algoritmos de iluminación y modificar la
posición de los vértices (sistemas de partículas, morphing, etc.).
Espacio de
Coordenadas
Locales
Espacio de
Coordenadas de
Mundo
Recorte Proyección
Espacio de
Coordenadas de
Vista
Espacio de
Coordenadas de
Viewport
Eliminación de
Caras Ocultas
Rasterización
Vertex Shader
Iluminación

Shaders
• Pixel Shaders:
– Reemplazan la fase de rasterización durante el proceso de
renderización.
– No se emulan por software.
– Permiten acceder directamente a píxeles y texturas (multi-texturing,
iluminación píxel a píxel, simulación de nubes, sombreado, etc.).
Espacio de
Coordenadas
Locales
Espacio de
Coordenadas de
Mundo
Recorte Proyección
Espacio de
Coordenadas de
Vista
Espacio de
Coordenadas de
Viewport
Eliminación de
Caras Ocultas
Rasterización
Pixel Shader
Iluminación

Recursos
• Introduction to 3D Game Programming
with DirectX 9. F. D. Luna. Wordware,
2003.
• Beginning DirectX 9. W. Jones. Premier
Press, 2004.
• Computer Graphics: Principles and
Practice. J. D. Foley et. al. Addison-
Wesley Professional, 1990.