Tag Archives: opengl

Scroll Parallax y Tile Maps con Fragment Shaders (spanish)

Tiles Maps y Scroll Parallax: los métodos mas usados en el desarrollo de juegos 2d, sobre todo los retro style que buscan emular la epoca de las consolas de 8/16 bits.

Existen varias alternativas para “renderear” tile maps, generalmente se pinta un quad por cada Tile o se genera un quad por cada objeto de fondo.

Para dar el efecto de scroll parallax algunos métodos que he visto, sobre todo en algunos “engines” es colocar los quads de cada objeto a diferentes niveles de profundidad y mover la cámara para hacer el scroll, o usar texturas gigantes (lo cual limita el tamaño del mapa) y hacer offset de los UV.

Screen Shot 2015-03-31 at 4.32.36 PMnobacks

Si tomamos el ejemplo de “renderear” un Tile Map de 256×256, implica generar 256×256 quads o un mesh, eso da 65,536 quads o  65,792 vertices (si se usa un mesh) que se mandan al GPU y si suponemos que cada vértice requiere UV ( 8 bytes), Posición (12 bytes), color ( 4 bytes) y normales (12 bytes), da un total aproximado de 3MB tan solo de los puros vertices e indices y aun falta considerar el tamaño de las texturas de los tiles.

Lo anterior es aceptable incluso para un dispositivo móvil, pero si además queremos múltiples planos para scroll parallax (unos 4) ,ahí ya se van 12 MB + lo que se ocupe de texturas, eso ya no es muy optimo que digamos para un dispositivo móvil, memoria y ancho de banda (del GPU) que bien se pueden utilizar para aspectos mas importantes del juego.

Existe un método mas eficiente que utiliza solo 2 texturas y 1 quad (si, solo un quad) por cada nivel de scroll y emular algo así como lo que se hacia el SNES de soportar múltiple planos.

Primeramente ocupamos la clásica textura con los Tiles (“Tile Texture”) y el Tile Map (Tiled es una excelente herramienta para generar Tile Maps).

sp1

Cada valor dentro del TileMap contiene el TileId que representa el número de Tile (dentro del TileTexture) que se debe pintar. En el demo el TileTexture es de 1024×1024 (contiene tiles de 64×64 pixeles), y el TileMap para cada plano es 32×32 tiles.

sp2

El truco es usar el Tile Map generado por Tiled en forma de textura (“TileMap Texture”) y con esto delegar la parte de pintar los Tiles sobre un plano al Fragment Shader.

sp3

Generamos el plano (quad de 4 vértices, en el que pintaremos el Tile Map ) y se lo pasamos al GPU, debemos definir también cual es la “resolución virtual” del quad, en el demo se asume el quad tiene una resolución de 1024×768 , por lo tanto en ese quad caben 16×12 tiles (cada uno de 64×64 pixeles).

El quad además tiene las UV normalizadas con origen [0, 0] y destino [1, 1] , durante la etapa de rendering de los Fragmentos (pixeles) el Fragment Shader recibe la información intermedia de estos valores que corresponden al pixel que se esta procesando dentro del quad.

Para hacer el efecto de scroll dentro del shader ocupamos además el parámetro “Scroll Offset” , que contiene el desfasamiento X,Y a partir de cual comenzar a pintar el Tile Map.

Con esta información: el “Scroll Offset”, “UV” , “TileMap Texture”, y “Tiles Texture” podemos proceder a pintar el plano en el fragment Shader (como se solía hacer en software antes de la llegada de los GPUs, la ventaja es que este código corre en el GPU que utiliza los fragment units en paralelo):

sp4

Los parámetros UV nos indican el fragmento dentro del quad que estamos pintando, recordemos que el quad tiene una resolución virtual de 1024×768, así que lo primero que ocupamos es saber la posición virtual del pixel.

  • PosicionPIxel = UV x [1024,768] + ScrollOffset .XY

Con este valor, podemos obtener la posición dentro del TileMap en que nos encontramos, cada tile mide 64×64 y el TileMap mide 32×32, por lo tanto:

  • PosicionTile.UV = (PosicionPixel.XY / 64) / 32

Y con esta posición podemos localizar el valor del TileId en la textura TileMap:

  • TileId = TileMap( PosicionTile.UV)

Ahora que tenemos el TileId podemos localizar el valor del pixel correspondiente dentro del Tile Texture:

  • TilesCoord .U = ((TileId mod 16) * 64 + PosicionPixel.X mod 64) / 1024
  • TilesCoord .V = ((TileId /   16) * 64 + PosicionPixel.Y mod 64) / 1024
  • ValorPixel = TileTexture( TilesCoord.UV)

(En el demo anexo se puede encontrar el código del Fragment shader.)

Para el efecto de Scroll Parallax, es solo cuestión de mandar al GPU tantos Planos como queramos, cada uno con su correspondiente TileTexture, TileMap y valores para el Offset .

sp5

La ventaja de este método es que es posible pintar N planos en un solo “Draw call” siempre que los planos compartan el mismo set de Tiles (Tile Texture) y se tenga una textura con los TileMaps para cada plano (una especie de TileTexture de Tile Maps).

sp6

Además se pueden programar efectos de deformación, pixeleado, ondulado, etc. , todo en el fragment shader y generar efectos al estilo Modo 7 del SNES.

Demo:

Link del demo con 8 niveles de scroll parallax: ParallaxScrollDemoWin32a.zip

Referencias:

Tilemap Tutorial: http://www.the2dgame.com/index?page=articles&ref=ART4

Fast tilemap shader: http://connorhollis.com/fast-tilemap-shader/

Tagged , , , ,

Luz y Sombra para mundos 2d. (spanish)

Los efectos de luz y sombra en tiempo real pueden causar un gran impacto en la presentación de tu juego si los sabes usar sabiamente y además se esperan formen parte de cualquier juego moderno.

sc0

En el caso de 3d, los métodos mas comunes para generar sombras en tiempo real son Shadow Mapping y Shadow Volumes (checa la documentación de tu engine favorito), cada uno con sus respectivas ventajas / desventajas y con costo de procesamiento alto si solo se esta haciendo un juego con apariencia 2d (pero con geometría 3d).

Las sombras en tiempo real no tienen por que ser algo exclusivo para mundos con geometría 3d, existen juegos 100% 2D que tienen efectos de luz y sombra en 2D .

Después de repasar varios artículos en internet que describen algunas técnicas y revisar algunas implementaciones existentes (plugins para engines como Game Maker) decidí desarrollar este tutorial que espero les sea útil, en el que describo una implementación (independiente del engine que utilices o si estas evaluando utilizar algún plugin) basada en generación de geometría y shaders simples.


(video del Demo al final del post)

¿Cómo hacemos luces y sombras 2d en tiempo real?

En el caso de 2d podemos usar algo similar a los shadow volumes, ya sea generar la geometría que cubre la luz o generar la geometría que no es cubierta por la luz, nuestro modelo de iluminación no será 100% fiel a los modelos físicos reales pero será una aproximación bastante aceptable.

¿Qué es una sombra?

sc1

La sombra es el área que esta fuera del alcance de la luz , áreas que son bloqueadas por shadow casters. Así que para generar sombras ocupamos primero una fuente de luz y los shadow casters que la bloquean.

Podemos empezar con una fuente de luz simple: una luz omnidireccional que cubre un área cuadrada finita NxN y los shadow casters serán la geometría que compone el nivel del juego.

sc2

Ya tenemos nuestra fuente de luz definida, ahora lo que sigue es generar las sombras.

¿Cómo generar las sombras?

Para esto tenemos 2 opciones:

1. Calcular la región (geometría 2d) que no es iluminada por la luz.

2. Calcular la región (geometría 2d) que es iluminada la luz.

sc3

Cualquiera de las 2 opciones es valida, yo he decidido tomar la opción 2: calcular la geometría que representa el área iluminada por la luz.

¿Cómo calcular la geometria iluminada por la luz?

Nuestro problema ahora consiste detectar los borders de los shadow casters con los cuales colisionan los rayos de luz emitidos por nuestra fuente de luz como se ve en el la siguiente imagen:

sc4

¿Cuántos rayos lanzamos, muchos?¿Que tan eficiente es eso?

Bueno en realidad no necesitamos lanzar rayos para determinar si colisionan con los shadow casters.

Lo que se puede hacer es tomar los vértices de los shadow casters y seleccionar aquellos que generen líneas que van directo al centro de la luz sin toparse con nada de por medio. También hay que tomar en cuenta los puntos de los shadow casters que se intercectan con los borders de la región de luz.

sc5

Para hacer mas eficiente el proceso podemos usar AABB queries para detectar intersecciones con el AABB de la region del luz, y de esta forma reducir la selección de vertices cercanos a la luz.

sc6

Listo, ya tenemos los puntos q conforman el area iluminada por la luz, ahora solo conectamos los puntos para generar el polígono y pintarlo sobre el piso . La ventaja de este polígono es que se puede renderear fácilmente con un triangle strip y reducir la información de vértices que se envía al GPU.

Los siguientes screenshots (tomados del demo anexo) muestran como quedaría con lo que llevamos de momento.

sc7

Ya tenemos luz pero no luce muy bien que digamos pues estamos rendereando el área de la luz con un color constante.Podemos usar una textura con degradado circular para hacer el efecto de desvanecimiento, listo :D.

sc8 sc9

Ahora un poco de color : para esto simplemente pintamos un quad con degradado circular del color de nuestra fuente de luz.

sc10 sc11

Y el truco para que luzca como se ve en el screenshot es el siguiente: al pintar este quad usamos una función de blending que sea equivalente a una multiplicación RGB1 x RGB2. (pixel por pixel). Esto lo que hace es multiplicar el valor de la luz que estamos pintando por el valor del pixel que se encuentra debajo.

En opengl esto se logra usando la funcion glBlendFunc( GL_ZERO, GL_SRC_COLOR).

Se puede experimentar con varios efectos (yo uso por ejemplo GIMP para diseñar y modelar el rendering por capas y posteriormente programar el shader).

Y ahora, ¿cómo hacer muchas luces?

Para pintar multiples luces, solo es cuestión de usar FBOs ( “Frame Buffer Object” o “Render to Texture” o “Post processing” o como quieras llamarlo).

1. Pintamos los colores de las luces en un FBO1 y dejamos que se mezclen los colores usando operaciones de color blending (ADD).

sc12

2. Pintamos la geometría de luz generada por cada una de las luces en un FBO2 y dejamos que se acumulen las intensidades usando alpha blending (ADD).

sc13

3. Procedemos a pintar el suelo (o fondo) del mundo 2d.

4. Pintamos encima el FBO2 (que contiene las regiones de luz en escala de gris / alpha).

5. Pintamos la geometría de nuestro mundo 2d (shadow casters).

6. Finalmente pintamos el FBO1: colores mezclados de cada luz. (usando blending MULTIPLY).

sc14

sc15

Listo! Ya tenemos un implementación de luces y sombras para geometría 2d, simple y de bajo uso de recursos y que funciona además en Openg GL ES 2.0 (que es lo que soportan la mayoría de los dispositivos mobiles actuales).

Screenshot final del demo (3 luces simultáneas).

sc16

Esta técnica es útil si estamos desarrollando un juego2d y queremos evitar generar geometría 3d para cálculos de luz y sombra. si usas box2d puedes reutilizar la geometría de los fixtures y utilizarla como shadow caster, y además se pueden “eficientizar” los cálculos usando AABB queries para solo procesar la geometría dentro del área de luz.

¿Qué mas falta?

+ Las penumbras (soft shadows): ocupamos generar mas geometría para degradar los bordes de las sombras, no es tan complicado, solo un poco de geometría analítica y listo. La otra opción es hacer una especie de blur shader durante el rendering de las sombras.

+ Per-pixel lighting : el piso se ve muy plano no estaría mal agregarle bump mapping.

+ Modelar otros tipos de luz (direccional , lámpara): para esto es solo cambiar la forma de la región de luz (en vez de un cuadro, usar un triángulo), hacer algunas adecuaciones en los cálculos (origen y ángulo de la luz) y usar texturas acordes.

Demo:

Link del demo para win32 : Demo 2d Shadows

(este demo fue desarrollado usando librerías open source multiplataforma irrlicht / sdl 2.0, mismas que he utilizado para varios juegos que he publicado en iOS , Android y Windows phone).

En próximos posts, publicaré otra técnica útil para engines 2d (o quizas continuar una 2ª parte de este articulo con los temas de soft-shadows y per-pixel lighting 2d).

Referencias:

http://archive.gamedev.net/archive/reference/programming/features/2dsoftshadow/

http://www.redblobgames.com/articles/visibility/

Tagged , , , ,