Vertex y Pixel Shaders

1
Vertex y Pixel Shaders

• Francisco Javier Tirado Sarti
• fjtirado_at_lucent.com

2
Introducción

• Hasta ahora hemos visto el fixed pipeline, que en
  cierta forma limitaba el numero de acciones que
  podíamos realizar con los objetos de la escena
• Con la aparición de los procesadores gráficos
  (GPU) surge la posibilidad de programar dicho
  hardware como si fuera una CPU, mediante pequeñas
  rutinas en ensamblador que se denominan shaders.
• Igual que sucediera con las CPUs, el lenguaje
  ensamblador se va sustituyendo por sus
  equivalentes de alto nivel que encapsulan
  adecuadamente el hardware subyacente, como Nvidia
  CG o HLSL.
• Por lo tanto, un shader consiste en un pequeño
  programa escrito en HLSL que se compila en tiempo
  real por nuestra aplicación durante la fase de
  inicialiacizacion y que se activa durante la fase
  de render para sustituir al fixed pipeline

3
Vertex Shader

• Un Vextex Shader reemplaza las fases de
  iluminación y transformación
• Una vez activado el shader, se ignoran los
  estados del dispositivo relativos a la geometría
  (las matrices de mundo, vista y proyección) y se
  deshabilita la iluminación
• Un vextex shader consta de una función principal
  que dado un vértice no transformado devuelve un
  vértice transformado.
• El shader puede alterar la posición, las
  coordenadas de textura y el color del vertice a
  voluntad del programador

4
Pixel Shader

• Un Pixel Shader se ejecuta durante la fase de
  rasterizacion, reemplazando el paso de
  Multitexturing
• Hasta ahora solo hemos usado una textura activa
  (sampler igual a 0) y el FVF D3DFVF_TEX1, que
  indicaba que nuestros vértices tenían coordenadas
  solamente para una textura, pero se pueden
  definir hasta 8 coordenadas de textura para un
  vértice dado (D3DFVF_TEX8) y tener hasta 8
  texturas activas en los samplers 0-7.
• El Multitexturing es, en esencia, la ejecución
  del blending entre las diferentes texturas
  activas en función de una serie de estados del
  dispositivo.
• El Pixel Shader consta de una función principal
  que recibe como entrada la coordenadas de textura
  y el color difuso asignados al píxel a partir de
  la interpolación de los valores de los vértices y
  que devuelve el color final para ese píxel.
• Usos extendido del Multitexturing son los
  llamados lightMaps (luces precalculadas para
  texturas sobre objetos estáticos) y BumpMapping
  (para simulación de rugosidad en superficies
  planas)

5
Soporte Hardware

• El mundo de los shaders (introducidos en DirectX
  8) esta en constante evolución. De manera que
  aunque el hardware más actual soporta la versión
  3_0 de Vertex y Pixel Shader, existen gran
  cantidad de tarjetas que solo soportan versiones
  inferiores.
• Para el caso de tarjetas que no soporten Vertex
  Shaders en absoluto, dicha funcionalidad puede
  emularse usando el device REF en lugar del HAL.
  En cambio, los pixel shaders no puede emularse.
• La versión del shader soportada por nuestra
  tarjeta puede obtenerse a partir de los campos
  VertexShaderVersion y PixelShaderVersion de la
  estructura D3DCAPS9 (miembro m_d3dCaps de la
  clase CD3DApplication). Dicha versión es útil a
  la hora de calcular uno de los parámetros
  necesarios para compilar el shader escrito en HLSL

6
Compilar el Shader

• Como hemos visto, un shader es un programa que
  necesita ser compilado por nuestra aplicación
• El programa estará escrito en fichero de texto
  aparte.
• Para compilar el programa utilizamos la función
  D3DXCompileShaderFromFile( LPCSTR pSrcFile, CONST
  D3DXMACRO pDefines, LPD3DXINCLUDE pInclude,
  LPCSTR pFunctionName, LPCSTR pProfile, DWORD
  Flags, LPD3DXBUFFER ppShader, LPD3DXBUFFER
  ppErrorMsgs, LPD3DXCONSTANTTABLE
  ppConstantTable ) donde
• pSrcFile es el nombre del fichero que contiene el
  shader
• pDefines y pInclude son null
• pFunctionName es el nombre de la funcion
  principal, normalmente Main
• pProfile es la version del Shader a calcular a
  partir de lo devuelto por D3DCap9 con la ayuda de
  las macros D3DVS_VERSION y D3DPS_VERSION. Por
  ejemplo, si se trata de un vertex shader y
  nuestra tarjeta soporta shaders 1_1 el string a
  pasar es vs_1_1
• Flags es una de las constantes del tipo
  D3DXSHADER. Usaremos D3DXSHADER_DEBUG
• ppShader contiene el resultado de compilar el
  shader
• ppErrorMsgs contiene el mensaje de error al
  compilar el shader, si procede.
• ppConstantTable devuleve el puntero al interface
  que se utiliza para comunicar la aplicación con
  el shader.

7
ID3DXConstantTable

• Un shader contiene un conjunto de variables
  globales cuyo valor puede establecerse desde la
  aplicación (El otro punto de comunicación entra
  la aplicación y el shader son los parametros de
  entrada y salida de la función principal del
  shader)
• Para ello se utiliza este interface que contiene
  un conjunto de métodos setXXX (IDirect3DDevice9,D
  3DXHANDLE handle,XXX value)
• El handle de la variable se obtiene usando el
  método ID3DXConstantTableGetConstantByName(
  D3DXHANDLE hConstant, LPCSTR pName )
• hConstant es 0 para variables globales
• pName es el nombre de la variable tal y como la
  declaramos en el shader.

8
Crear y activar el Shader

• El ID3DXBuffer ppShader obtenido al compilar el
  shader se utiliza para crear la referencia al
  interface.
• Si es un VertexBuffer utilizamos el método
  IDirect3DDevice9CreateVertexShader( CONST DWORD
  pFunction, IDirect3DVertexShader9 ppShader )
  
• pFuntion es el puntero contenido en el buffer
• ppShader es la referencia al shader
• Si es un pixel shader utilizamos
  IDirect3DDevice9 CreatePixelShader( CONST DWORD
  pFunction, IDirect3DPixelShader9 ppShader )
• Una vez tenemos la referencia al shader, podemos
  activarlo durante la fase de render usando
  IDirect3DDevice9SetVertexShader(
  IDirect3DVertexShader9 pShader ) o
  IDirect3DDevice9SetPixelShader(
  IDirect3DPixelShader9 pShader )

9
HLSL

• Por ultimo hay que escribir el shader en HLSL.
• HLSL es un lenguaje muy parecido a C cuyas
  características mas relevantes son
• Soporte nativo para los tipos matrix y vector,
  que representan respectivamente matrices de 4x4 y
  vectores de 4 elementos
• Posibilidad de declarar vectores de diferentes
  tamaños usando los tipos primitivos seguidos de
  la dimensión del vector. Por ejemplo, float2 para
  las coordenadas u y v de una textura.
• Las variables globales son accesibles desde la
  aplicación
• Definición de estructuras usando la palabra clave
  struct
• La función principal (normalmente Main) admite
  como parámetros de entrada y salida sendas
  estructuras que, además de la definición habitual
  de los campos, incluye anotaciones indicando el
  propósito de cada uno de ellos. Estas son
  utilizadas por el shader para hacer corresponder
  la información del vértice o pixel generada por
  la aplicación con los campos de la estructura.
  Las anotaciones más habituales son
• POSITION. El campo representa una posición
• COLOR. El campo representa un color.
• NORMAL El campo representa un vector normal
• TEXCOORD. El campo representa coordenadas de
  textura
• Si una anotación del mismo tipo aparece más de
  una vez en una misma estructura, se le añade un
  índice numérico. NORMAL0, NORMAL1, NORMAL N
• Por ejemplo, si nuestro vértice consta de
  coordenadas x,y,z, un vector normal y coordenadas
  u y v para las texturas, la estructura de entrada
  de la función principal de un vertex shader será
  struct VS_INPUT vector position POSITION
  vector normal NORMAL float2d tex TEXCOORD

10
Vértices flexibles

• Aunque no vayamos a usarlo, es menester indicar
  que las posibles definiciones del formato de un
  vértice no están limitadas a los flags que
  componen el FVF, sino que la estructura de un
  vértice también puede definirse a partir un array
  de estructuras D3DVERTEXELEMENT9
• Una vez construido el array puede obtenerse un
  puntero al Interface IDirect3DVertexDeclaration
  usando el metodo CreateVertexDeclaration y
  fijarse (en sustitución del método setFVF) con el
  método SetVertexDeclaration
• Podemos seguir usando FVF porque internamente
  estos se convierten automáticamente a
  VertexDeclaration