Causticos, Gamasutra

[aphex]

 Bueno, como hay que promocionarse y la UPF paga por investigar (aunque sea sobre videojuegos), os paso un link al articulo que hemos posteado en Gamasutra sobre causticos en tiempo real usando Cg. Es una idea que ya enseñé en artfutura 2002, y que hemos completado con Juan Guardado, que es investigador en NVIDIA Londres. Está chulo, sobre todo si teneis una FX. También hay una version GL clásica, y de ambas esta el codigo fuente entero.

Está en la portada y, si no, en:

http://www.gamasutra.com/features/20030903...crespo_01.shtml

espero que os guste. La parte de Cg es más compleja de entender, pero si pilláis la idea básica, el resto sale con un par de páginas de mates.

ala, saludos

dnai

[HaltedMode]

 No es que el idioma sea un problema, pero si teneis por ahi alguna versioncilla en español se agradeceria (aun mas) mas que nada por comodidad.

La demo tiene una pinta esplendida.

[aphex]

 lo siento, no la tengo... se escribio directamente en inglés porque era un articulo pensado desde el comienzo para Gamasutra.

Si tienes cualquier duda, posteala y lo discutimos

[synchrnzr]

 Bueno, para los profanos en programación gráfica como yo, podrías explicar un poco por encima qué es eso de los cáusticos :lol:

sync

[Mars Attacks]

 No puedo acceder al documento sin registrarme (y no tengo el más mínimo interés en hacerlo), pero en grafismo las (luces) cáusticas son los reflejos de la luz al atravesar materiales refractarios como el cristal. No sé si se referirá a lo mismo.

[HaltedMode]

 Exacto va de eso. Sync para que te hagas una idea las luces causticas son las luces que ves "bailando" cuando miras el fondo de una piscina en un dia soleado. El efecto queda muy bonito pero, por desgracia consume bastante, por eso son interesantes las investigaciones para calcular dicho efecto en tiempo real.



En la parte de abajo de la imagen se distinguen muy bien.

[DraKKaR]

 Eso de calcular las causticas en tiempo real suena fascinante, muy bonito para meterlo en una demo. Pero me parece un desperdicio de recursos impresionante calcularlas en tiempo real pudiendo simularlas con un shader, como lo hace el UT2003 en algunos tramos de algun mapa.

De todas formas me gusta todo esto de las cosas que se pueden simular en tiempo real, vi un paper sobre como generar nubes y era una preciosidad. Pero es lo mismo, como no se use para un jeugo donde solo van a haber nubes y algun otro avion...

[MChiz]

 Tiempo al tiempo... ya llegaremos : )

[CoLSoN2]

 

Pero me parece un desperdicio de recursos impresionante calcularlas en tiempo real pudiendo simularlas con un shader

y un shader no se ejecuta en tiempo real? XD

El artículo explica como hacerlo con Cg, es decir con shaders

[BeRSeRKeR]

 Bueno, que se ejecute en un pixel shader no quiere decir que vaya a ir en tiempo real aunque en este caso en concreto sí que va en tiempo real. Por desgracia no he podido probarlo ya que no poseo una aceleradora compatible con ps 2.0. Sí he podido probar la versión OpenGL pero claro, va un poco lento.

De todas formas es de esperar que estas cosas se puedan utilizar de forma masiva en juegos en no mucho tiempo, así que es de agradecer que haya gente que vaya por delante, investigando y abriendo camino :)

Saludos.

[aphex]

 la version Cg me iba a 200 fps (en una fx 5800, con un p4 2 Ghz). La opengl tiraba mas o menos bien (10 fps o así), porque la optimización no es el shader sólo, sino que el algoritmo *tambien* es nuevo. Vamos, que es un algoritmo innovador que se adapta muy bien a los shaders. Para que me entendáis, causticos reales eran hasta ahora cosa de HORAS. Y si no, pillad el max, haced una escena de olas y meted un caustico... eso si, iros a cenar porque se tirará un rato. Mejor, iros de farra. Aquí el cáustico (sin Cg) se calcula en 0.1 segundos, que no está mal.

Sobre lo del desperdicio, piensa que esto es investigación y, por tanto, nos importa relativamente poco *esta* generación de juegos. A 5 años vista, los shaders serán gratis, igual que hace 5 años el filtrado bilineal de texturas era costosísimo y hoy ni te lo preguntas. Y de aquí 5 años este tipo de tecnicas valdrán la pena pero, claro, la gracia es publicarlo ahora, no creeis?

Hoy por hoy, esto es una salvajada: chupa muchisima potencia de calculo, pero pensad con un poco de perspectiva a largo plazo... esa es la clave.

Coño, hoy en bump mapping sale casi gratis... por qué no causticos y iluminación global de aqui un tiempo?
;-P

[Tei]

Mis 2 centimos:

En mi motor las causticas las genera este codigo:

Código [Seleccionar] Expand


//Codigo original de DrLabMan
void EmitUnderwaterPolys (msurface_t *fa)
{
glpoly_t *p;
float  *v;
int   i;
float  s, t, os, ot;
// int tn;

//GL_Bind (underwatertexture);
//tn = (int)(host_time * 20)%31;
//glBindTexture (GL_TEXTURE_2D, causticstexture[tn]);
glBindTexture (GL_TEXTURE_2D, shinytexture);

//glEnable (GL_BLEND);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);//GL_DECAL);
glColor4f (1,1,1,0.01f);
glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);

for (p=fa->polys; p; p=p->next)
{
 glBegin (GL_POLYGON);
 for (i=0,v=p->verts[0]; i<p->numverts; i++, v+=VERTEXSIZE)
 {
  os = v[3];
  ot = v[4];

  s = os + turbsin[(int)((ot*0.5+(realtime*0.5)) * TURBSCALE) & 255];
  s *= ((0.5/64)*(-1))*3;

  t = ot + turbsin[(int)((os*0.5+(realtime*0.5)) * TURBSCALE) & 255];
  t *= ((0.5/64)*(-1))*3;

  glTexCoord2f (s, t);
  glVertex3fv (v);
 }
 glEnd();
}
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glDisable (GL_BLEND);
glColor4f (1,1,1,1);
}
//QMB!


El codigo es originalmente DrLabMan. No mio.  

Usa una textura de causticas reales y las mueve por los poligonos con algo de turbulencia de los vertices. El efecto es suficientemente realista. A menos que alguien tenga un monitor al lado con causticas reales, o viva en una piscina.


Update:

Se me olvidaba, tambien utilizo un codigo semejante para añadir esta caustica, pero muy ampliada sobre enormes poligonos con una textura simple teselada. El resultado es que no parece una textura sencilla sino algo intermedio entre texturas tiles y generadas al azar. Yo a esto lo llamo "negar la condicion de tile de un wall"

[BeRSeRKeR]

 Yo también utilizaba este método. Una textura con los "cáusticos" y entonces modificaba las coordenadas de textura para simular las tubulencias y aplicaba la textura con additive blending. Pero es evidente que el método que expone aphex está más acorde con la física real de los cáusticos que lo que tú y yo hablamos, es decir, un fake. Eso sí, es un fake que en estos momentos da su resultado y es mucho menos costoso...

Saludos

[synchrnzr]

 Gracias por la explicación gente :lol:

sync

[aphex]

 el metodo ese esta bien, pero tiene algunos problemas, a saber:

- turbsin no es gratis... si la calculas en tiempo real el shader es mas rapido. Si la precalculas, el caustico loopeara y queda mal.

- consumes mas geometria... las texcoords para el caustico requieren una malla fina. el metodo de gama, al ser un pixel shader, es un solo quad.

- el metodo de gama permite interactuar con el agua y ver como afecta al caustico...

vamos, que el metodo que proponeis esta bien, pero el otro es mas avanzado, y logicamente puede simular mas cosas.

Por cierto, a nivel CPU el algo de gama es mas ligero que el vuestro, y a nivel de GPU el de gama consume mucho shader (pero nada de geometria), mientras que el vuestro consume mucha geometria y nada de shader. a X años vista, es previsible que el overhead de calculo del pixel shader se vuelva despreciable, y por tanto prefieras una soluciona basada en ellos