Está en la página 1de 74

Universidad Central de Venezuela Facultad de Ciencias Escuela de Computacin Centro de Computacin Grfica

Generacin y Visualizacin de Terrenos a Escala Planetaria y Mundos Virtuales en Tiempo Real

Seminario en la Lic. de Computacin Autor: Luis Enrique Pulido Miranda Tutor: Rhadams Carmona

Caracas, Julio de 2013

ndice
INTRODUCCIN ........................................................................................................................................... 4 CAPTULO 1 CONCEPTOS BSICOS ............................................................................................................... 5 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 1.10 1.11 1.12 1.13 1.14 1.15 1.16 1.17 1.18 1.19 1.20 1.21 1.22 1.23 MODELO DIGITAL DE ELEVACIN (MDE) ................................................................................................... 5 MAPA DE ALTURAS O HEIGHTMAP ............................................................................................................ 5 PARCHE O CHUNK .................................................................................................................................. 6 RBOL BINARIO O BINTREE ...................................................................................................................... 6 QUADTREE ........................................................................................................................................... 6 TIN ..................................................................................................................................................... 7 RTIN ................................................................................................................................................... 7 NIVEL DE DETALLE O LOD ....................................................................................................................... 7 NIVEL DE DETALLE CONTINUO O CLOD ...................................................................................................... 7 PIXEL ERROR ......................................................................................................................................... 8 VIEW-FRUSTUM CULLING ........................................................................................................................ 8 NMEROS PSEUDO-ALEATORIOS ............................................................................................................... 9 ALGORITMOS DE RUIDO .......................................................................................................................... 9 FRACTIONAL BROWNIAN MOTION............................................................................................................. 9 FRACTALES ......................................................................................................................................... 10 MULTIFRACTALES ................................................................................................................................. 10 MIPMAPPING ...................................................................................................................................... 10 CLIPMAPPING ...................................................................................................................................... 10 ALGORITMOS DE FUERZA BRUTA ............................................................................................................. 10 ALGORITMOS OUT-OF-CORE O FUERA DE NCLEO...................................................................................... 11 SHADER ............................................................................................................................................. 11 ENFOQUE BOTTOM-UP ......................................................................................................................... 11 ENFOQUE TOP-DOWN .......................................................................................................................... 11

CAPTULO 2 VISUALIZACIN DE PLANETAS ................................................................................................ 12 2.1 2.2 2.3 2.4 2.4.1 2.4.2 2.4.3 2.4.4 2.4.5 2.4.6 2.4.7 2.4.8 2.4.9 2.4.10 2.4.11 2.4.12 2.4.13 2.5 HISTORIA Y USOS NOTABLES ................................................................................................................... 12 TRABAJOS PREVIOS ............................................................................................................................... 15 INSPIRACIN DEL MUNDO REAL Y LA CIENCIA FICCIN .................................................................................. 17 GENERACIN ALEATORIA DE TERRENOS .................................................................................................... 19 Representacin de los datos ................................................................................................................19 Interpolacin ........................................................................................................................................20 Midpoint Displacement ........................................................................................................................21 Random Faults......................................................................................................................................22 Perlin Noise ..........................................................................................................................................23 Perlin Noise Multifractal ......................................................................................................................28 Perlin Noise Ridged ..............................................................................................................................28 Perlin Noise Ridged Multifractal ..........................................................................................................29 Worley Noise ........................................................................................................................................29 Worley Noise Multifractal ....................................................................................................................32 Combinacin y Perturbacin ................................................................................................................32 Sparse dot Noise ..................................................................................................................................33 Algoritmos de Erosin ..........................................................................................................................34 ALGORITMOS PARA COLOREAR Y TEXTURIZAR TERRENOS .............................................................................. 36

3
2.5.1 2.5.2 2.5.3 2.5.4 2.6 2.6.1 2.6.2 2.6.3 2.6.4 2.6.5 2.6.6 2.7 2.8 2.8.1 2.8.2 2.9 2.9.1 2.9.2 2.9.3 2.9.4 2.9.5 Representacin de Color ......................................................................................................................37 Mapeado de Texturas ..........................................................................................................................37 Interpolacin ........................................................................................................................................38 Texturizado procedural ........................................................................................................................40 ALGORITMOS PARA MANEJO DE LA GEOMETRA Y NIVEL DE DETALLE ............................................................... 44 ROAM 2.0 .............................................................................................................................................45 Geometrical Mipmapping ....................................................................................................................47 Chunked LOD ........................................................................................................................................48 GPU Geometry Clipmaps ......................................................................................................................50 BDAM ...................................................................................................................................................54 Continuous Distance-Dependent Level of Detail (CDLOD) ...................................................................56 MANEJO DE TERRENOS ESFRICOS ........................................................................................................... 58 PRECISIN .......................................................................................................................................... 62 Jittering.................................................................................................................................................62 Z-Fighting ..............................................................................................................................................63 ASPECTOS ADICIONALES ........................................................................................................................ 64 Ocanos ................................................................................................................................................64 Atmsfera .............................................................................................................................................65 Nubes ...................................................................................................................................................66 Anillos planetarios ................................................................................................................................67 Campo de estrellas en el espacio .........................................................................................................67

CAPTULO 3 PROPUESTA DE TESIS.............................................................................................................. 69 3.1 PLANTEAMIENTO DEL PROBLEMA ............................................................................................................ 69 3.2 OBJETIVOS.......................................................................................................................................... 70 3.2.1 Objetivo general ...................................................................................................................................70 3.2.2 Objetivos especficos ............................................................................................................................70 3.3 PROPUESTA ........................................................................................................................................ 71 3.4 METODOLOGA.................................................................................................................................... 71 3.5 PRUEBAS A REALIZAR ............................................................................................................................ 72 BIBLIOGRAFA ............................................................................................................................................ 73

Introduccin
El despliegue o renderizado de terrenos es un tema muy importante en la computacin grfica, la infografa y visualizacin. En los ltimos aos poder renderizar terrenos a escala planetaria se ha convertido en un tema muy explorado y aparecieron numerosas aplicaciones. Entre ellas se incluyen: Cientficas: cartografa, planificacin del paisaje, prediccin climtica, simulacin planetaria Militar: simuladores de vuelo, combate virtual, planificacin de asalto Entretenimiento: pelculas, juegos de video, turismo virtual

El Despliegue de Terrenos abarca muchos campos de la computacin grfica. Este documento se centra en los ms difciles: Manejo de la Geometra y la Representacin de un Planeta haciendo uso de la Generacin Procedural Aleatoria de la geometra del terreno, texturizado en tiempo real, simulacin de la atmsfera, ocanos y vegetacin. El reto de este proyecto es desplegar en tiempo real, un mundo virtual de grandes dimensiones, en una computadora actualmente de especificaciones promedio. En la computacin grfica, un buen proyecto se basa en consumir la menor cantidad de tiempo para lograr un resultado visual bueno. Sin embargo, es difcil satisfacer ambas caractersticas. A tal fin, es imprescindible conocer la gama de tcnicas existentes para poder seleccionar aquella que ms se adece a las necesidades del proyecto. En este informe, se describen varias tcnicas para la representacin de los cuerpos planetarios de diversos conjuntos de datos. El algoritmo inicialmente se basa principalmente en el enfoque de Filip Strugar [0] con algunas modificaciones, y se propone extender para trabajar con terrenos esfricos utilizando un mtodo para mapear un cubo a una esfera [1]. Otros algoritmos para el manejo del nivel de detalle pueden ser tomados en cuenta pero la seleccin de la tcnica se basa en un equilibrio entre la simplicidad y resultado visual de su implementacin. Para la introduccin de la tcnica, en el captulo 1 se presentan los conceptos bsicos y fundamentos relacionados a la generacin aleatoria, despliegue y visualizacin de terrenos. En el captulo 2 se explican las diferentes tcnicas para la generacin aleatoria de mapas de altura, procedimientos aleatorios y tambin los diferentes mtodos para llevar a cabo el renderizado de terrenos a escala planetaria y finalmente en el captulo 3 se presenta una solucin como Propuesta de Trabajo Especial de Grado donde se plantea el problema, los objetivos, mtodos, tcnicas y pruebas a realizar.

Captulo 1 Conceptos Bsicos


En esta seccin se explica algunos trminos tcnicos sobre la generacin aleatoria y visualizacin de terrenos y planetas. Las explicaciones son cortas y sern discutidas en profundidad cuando sean necesarias durante el informe. Los trminos explicados ayudarn al lector a comprender el desarrollo del tema sin haber tenido conocimiento previo.

1.1 Modelo Digital de Elevacin (MDE)


Los Modelos Digitales de Elevacin o Digital Elevation Model en ingls definen una manera de representar una superficie topogrfica o un terreno de forma digital. Una imagen de mapa de bits o datos vectoriales pueden ser utilizados para la representacin de los MDE. Los sistemas de informacin geogrfica tienden a usar datos vectoriales mientras que en videojuegos se usan los mapas de bits. La representacin por datos vectoriales usualmente es una red irregular de tringulos descrita por vectores, mientras que el mapa de bits representa la elevacin una cuadrcula en forma de una imagen en escala de grises (figura 1.1).

1.2 Mapa de Alturas o Heightmap


Se le denomina Heightmap al mapa de bits que determina un MDE. Los Mapas de Alturas son la forma ms comn de almacenar los datos de elevacin de un terreno. Especialmente en videojuegos, cuando se visualiza un terreno, los heightmaps son usados todo el tiempo.

Figura 1.1: Mapa de Alturas generado de manera artificial con la Visualizacin correspondiente.

1.3 Parche o Chunk


En la visualizacin de terrenos un parche o chunk es un grupo de tringulos que tienen las mismas propiedades. En la mayora de los casos es mejor procesar grupos de tringulos en vez de procesarlos individualmente. Hoy en da los GPUs tienen la capacidad de dibujar un grupo de tringulos de manera rpida y eficiente y la mayora de los algoritmos para visualizacin de terrenos usan parches y no tringulos como el elemento ms pequeo de un terreno.

1.4 rbol Binario o Bintree


El rbol Binario o Bintree es una estructura que permite almacenar datos. Cada nodo del rbol tiene dos hijos. En la visualizacin de terrenos, la mayora de las veces, un rbol binario tiene dos tringulos que cubren todo el terreno. Luego cada uno de esos dos tringulos se divide nuevamente en dos nuevos tringulos de modo que agrega ms detalle al terreno. Esto se puede repetir continuamente hasta alcanzar un nivel deseado de detalle.

1.5 Quadtree
Los Quadtrees son algo similar a los bintrees pero la diferencia es que tienen cuatro hijos en vez de dos. En la visualizacin de terrenos, el nodo raz del rbol cubre todo el terreno. Luego el terreno se divide en cuatro partes iguales que pertenecen como hijos del nodo raz. El proceso se puede repetir hasta alcanzar un nivel de detalle deseado. La estructura Quadtree es muy famosa en la computacin grfica. Numerosos algoritmos son basados en Quadtrees. La aproximacin propuesta en este informe hace uso de esta estructura.

(a) Bintree (b) Quadtree Figura 1.2: Estructuras simples de Bintree y Quadtree.

1.6 TIN
Triangulated Irregular Network es una manera de representar geomtricamente un mapa de alturas. La ventaja es que se adapta a la forma del terreno, puede modelar cuevas y salientes, pero demanda una cantidad significativa de procesamiento para trabajar con ellas.

1.7 RTIN
Right TriangulatedIrregular Network es una manera ms eficiente de representar una TIN, al ser construida de tringulos rectngulos, puede ser fcilmente representada con un Quadtree o un Bintree.

(a) TIN (b) RTIN Figura 1.3: Representaciones geomtricas de un mapa de alturas

1.8 Nivel de Detalle o LOD


En la computacin grfica, los algoritmos de nivel de detalle (level of detail) tratan de reducir o incrementar la complejidad de un objeto de acuerdo a numerosas mtricas. Puede ser la distancia del objeto a la cmara, la velocidad de la cmara, el tamao del objeto, etc. Por ejemplo, cuando un objeto est lejos del espectador es preferible reducir la complejidad del mismo. De este modo menos procesamiento es necesario y adems el espectador no notar un cambio de la calidad. Usualmente los niveles de detalle de un objeto son precomputados y el nivel apropiado es seleccionado en tiempo de ejecucin, basado en alguna de las mtricas antes mencionadas.

1.9 Nivel de Detalle Continuo o CLOD


Algoritmos sobre Nivel de Detalle Continuo (CLOD) son un caso especial de los algoritmos de LOD. En este caso los diferentes niveles de detalle no son precalculados, son

8 recalculados continuamente cada cuadro o frame de la escena. Los algoritmos que se explican en captulos posteriores detallan las tcnicas ms populares de los CLOD.

1.10 Pixel Error


Los algoritmos de nivel de detalle afectan la calidad visual de un mallado. Durante las transiciones de niveles de alta calidad a baja calidad se producen errores visuales. La diferencia que hay en pixeles entre un nivel de alta calidad a otro en menor calidad se denomina pixel error. Esta diferencia se calcula proyectando la geometra en la pantalla, por lo cual tambin se puede denominar projected pixel error o error de pixel proyectado. En la visualizacin de terrenos es usual calcular el error de pixel por vrtice o por parche.

Figura 1.3: Niveles de detalle LOD de una geometra y el error de pixel entre ellos.

1.11 View-Frustum Culling


Al procesar geometra con una proyeccin en perspectiva, el espacio visible tiene una forma de pirmide truncada denominado View Frustum. Cualquier objeto fuera de este volumen puede ser descartado antes de ser desplegado. Usualmente se realiza mediante una prueba de corte contra seis planos, al mismo tiempo se combina con un poco de heurstica para acelerar la prueba. Los planos que son definidos como far plane y near plane son la base y el tope de la pirmide, donde uno delimita hasta dnde se puede ver y el otro delimita desde dnde se puede ver.

Figura 1.4: View-Frustum Culling sobre un terreno. Permite desplegar slo la geometra visible.

1.12 Nmeros pseudo-aleatorios


Un nmero pseudo-aleatorio es un nmero generado en un proceso que parece producir nmeros al azar, pero no lo hace realmente. Las secuencias de nmeros pseudoaleatorios no muestran ningn patrn o regularidad aparente desde un punto de vista estadstico, a pesar de haber sido generadas por un algoritmo completamente determinista, en el que las mismas condiciones iniciales o semilla de la funcin producen siempre el mismo resultado.

1.13 Algoritmos de Ruido


Al momento de generar un mapa de alturas, para formar un terreno, la primera aproximacin es asignar una altura aleatoria a cada vrtice del terreno, pero el resultado no es visualmente bueno, no parece real. Para dar realismo a un terreno generado artificialmente se hace uso algoritmos que producen un ruido aleatorio coherente, de este modo se simula un poco de naturalidad en el terreno. Estos algoritmos funcionan con diversos parmetros y funciones complementarias que generan un resultado diferente, y al hacer uso de nmeros pseudo-aleatorios, se puede conseguir un mismo resultado dos veces si usamos los mismos parmetros y la misma semilla.

1.14 Fractional Brownian Motion


Movimiento Browniano fraccional (fBm) es la suma de las partes sucesivas de ruido, cada uno con mayor frecuencia y menor amplitud. No importa qu tipo de ruido, la mayora da un resultado suficientemente aproximado a un elemento natural, dependiendo del tipo de ruido, el producto final es un fractal.

10

1.15 Fractales
La mejor manera de explicar un fractal es dar un ejemplo del mundo real. Si observamos una montaa desde una larga distancia o si sostenemos una roca en nuestras manos, ambas tienen una apariencia muy similar. Podemos encontrar las mismas caractersticas y la misma rugosidad de la superficie incluso si las miramos a diferentes escalas. Para la generacin del mapa de alturas de un terreno, el uso de fractales combinado con el ruido puede generar un resultado visualmente bueno y bastante natural.

1.16 Multifractales
Los modelos de terreno generados por las tcnicas de fractales se pueden clasificar como los llamados monofractales. Los conjuntos monofractales se caracterizan por una sola dimensin fractal. Los conjuntos multifractales [2], por otro lado se pueden dividir en un nmero de subconjuntos, cada uno con su propia dimensin fractal. Un sistema multifractal es comnmente encontrado en la naturaleza, especialmente en la geofsica. El principio bsico es definir un fractal en la que su funcin base cambia en escala o algn otro parmetro de la funcin para cada una de las dimensiones.

1.17 Mipmapping
Mipmaping es una tcnica de la computacin grfica, dnde se hace uso de los mapas MIP (del latn multum in parvo, que significa mucho en poco) que son un conjunto de imgenes de mapas de bits que derivan de una textura principal y ayudan a amentar la velocidad de despliegue y reducir artefactos. Consiste en utilizar la textura principal, durante el despliegue, cuando se puede visualizar a todo detalle, y cambia al mipmap adecuado cuando se despliega a cierta distancia o a una menor escala.

1.18 Clipmapping
Clipmapping es un mtodo para recortar un mapa MIP a un subconjunto de datos pertinentes a la geometra que se muestra. Esto es til para cargar tan poca informacin como sea posible cuando la memoria es limitada, como en una unidad de procesamiento de grficos (GPU).

1.19 Algoritmos de Fuerza Bruta


Los Algoritmos de Fuerza Bruta son soluciones triviales que intentan resolver un problema particular sin necesidad de hacerlo inteligente ni eficiente. Usualmente la velocidad depende completamente de la velocidad del hardware.

11

1.20 Algoritmos Out-of-core o Fuera de Ncleo


Algoritmos Out-of-core se refieren a algoritmos cuya data es demasiado grande como para caber en la memoria principal de una vez. Estos algoritmos deben ser optimizados para buscar y acceder data de otras fuentes que tienen una taza de transferencia de datos menor como son los discos duros o conexiones de red.

1.21 Shader
Se trata de un programa de computacin grfica que es ejecutado en un GPU y se escribe en un lenguaje de programacin especializado. Hay una tendencia comn para mover todas las tareas de los algoritmos de visualizacin del terreno a la GPU. En la actualidad, las tcnicas ms comunes hacen uso del vertex shader para manipular la geometra del terreno basndose en el mapa de alturas, y el fragment shader para texturizar la geometra y procesar la imagen resultante. Sin embargo, con las nuevas tecnologas, en el ltimo ao se han aadido nuevas funcionalidades a las GPU que permiten manejar la geometra del terreno y calcular el nivel de detalle mediante los tessellation shaders, que consisten en recibir como informacin base un parche definido por unos pocos vrtices y genera como salida un conjunto de tringulos.

1.22 Enfoque Bottom-Up


El enfoque Bottom-Up es una manera de resolver problemas. Primero, muchos pequeos sub-problemas son definidos y resueltos, luego el resultado de esos problemas se mezcla en grupos y forman nuevos problemas que son en menos nmero que los anteriores. El proceso se repite continuamente hasta que tenemos un solo problema a resolver.

1.23 Enfoque Top-Down


El Enfoque Top-Down es completamente lo contrario al enfoque anterior. En este enfoque tenemos slo un problema y lo dividimos continuamente en sub-problemas de menor tamao hasta que alcanzamos un nivel donde los sub-problemas son fciles de resolver.

12

Captulo 2 Visualizacin de Planetas


2.1 Historia y usos notables
La visualizacin o render de terrenos a escala planetaria es un tema muy interesante en la computacin grfica. De hecho en los ltimos aos ha sido estudiado a fondo aprovechando el uso de las GPUs modernas que tienen la capacidad de manejar grandes volmenes de datos a una taza de transferencia superior a los CPU. Las aplicaciones que requieren visualizacin y navegacin de ambientes tridimensionales han ido evolucionando de demandando cada vez mayor realismo en los resultados producidos. Aplicaciones como Google Earth y NASA World Wind se basan en la visualizacin del planeta tierra, su topografa, clima, territorios, mapas, turismo virtual, GPS, entre otras funciones haciendo uso de informacin topogrfica real obtenida mediante satlites y otros diversos tipos de mediciones. En el tpico de la visualizacin planetaria existe un nmero grande de captulos de la computacin grfica que se dedican al estudio independiente de cada punto en especfico. Los ms populares son: Manejo de la Geometra Generacin del Terreno Texturizado Iluminacin y sombreado Dispersin atmosfrica Despliegue de Ocanos Vegetacin Despliegue de Nubes

Ahora bien, cuando hablamos de generar y visualizar planetas completamente aleatorios de manera artificial tenemos que tomar en cuenta que la data que se va a visualizar no viene tomada de un objeto fsico existente, hay que crear el planeta, su forma bsica generando la topologa a partir de funciones aleatorias que al mismo tiempo le den realismo al planeta. A lo largo de la historia de la computacin grfica los paisajes virtuales marcaron incontables apariciones desde pelculas y juegos de video hasta simulaciones ordinarias en noticias de televisin o internet. En la poca cuando empez la produccin de este contenido hubo numerosos logros que impulsaron la industria con sus innovaciones. El primer uso de un terreno generado por computador en la industria del cine se ubica en la pelcula Alien del ao 1979. Almacenar la data de un terreno entero en disco era imposible en la poca debido a las limitaciones de los discos duros, por lo tanto la

13 compaa encargada de los efectos especiales Systems Simulation Ltd. escribi un algoritmo que poda generar de manera pseudo-aleatoria un terreno. El propsito para la pelcula era mostrar el mallado del terreno de un planeta en la computadora de la nave. El resultado se puede ver en la figura 2.1 Tres aos despus, mientras trabajaba en la pelcula Tron, Ken Perlin ide una funcin de ruido coherente que es usada hoy en da en muchos mbitos de la computacin grfica, en juegos de video y pelculas. La funcin se conoce como Perlin Noise y aunque la pelcula no logr ningn premio de la academia por efectos visuales, Ken Perlin obtuvo un premio por sus logros tcnicos en los efectos visuales. Un ejemplo del resultado obtenido por Perlin en la pelcula Tron se puede ver en la figura 2.1 En el curso de los siguientes aos, numerosas empresas de cine empezaron a usar software de terceros con herramientas especializadas especficamente en el campo de generacin de terrenos y paisajes que les permitan crear mundos y planetas completamente nuevos.

(a) Alien 1979 (b) Tron 1982 Figura 2.1 Primeras apariciones en cine de terrenos generados de manera artificial

Entre algunas de estas herramientas se pueden destacar las ms populares como son World Machine1, VistaPro2, Bryce3 o probablemente los ms conocidos y comerciales como son Vue4 y Terragen5. En los ltimos aos, estos softwares han sido usado en la creacin de numerosas pelculas, entre las que se pueden mencionar: Time Machine, 2012, The Day After Tomorrow y muchas otras. Algunos ejemplos de terrenos creados con Terragen 2 se pueden apreciar en la figura 2.2.

1. HTTP://WWW.WORLD-MACHINE.COM/ 2. HTTP://STORE.MONKEYBYTE.COM/INDEX.PHP/TOOLS/VISTAPRO-RENDERER-DOWNLOAD-PC.HTML 3. HTTP://WWW.DAZ3D.COM/I/PRODUCTS/BRYCE 4. HTTP://WWW.E-ONSOFTWARE.COM/PRODUCTS/ 5. HTTP://WWW.PLANETSIDE.CO.UK/

14

Figura 2.2 Terrenos generados por Terragen 2

En el campo de los juegos de videos tambin hubo grandes avances, como los desarrolladores de videojuegos apuntaban a alcanzar cada vez ms niveles de realismo en los juegos, crear varios tipos de escenarios y paisajes se convirti en una prctica comn. Al principio del desarrollo de los juegos de video, cuando la capacidad de los discos no era lo suficientemente grande, la mayor parte del mundo en los juegos era generada, como fue el caso de The Elder Scrolls II: Daggerfall. Sin embargo, luego de que la capacidad de los discos aumentara en gran escala, los desarrolladores pudieron abandonar la generacin del paisaje y pasaron a modelarlos manualmente con un mtodo hbrido en el cual se genera la base del terreno y posteriormente se modelan detalles especiales que le dan un toque artstico y nico al paisaje. Esta tcnica se us en las siguientes secuelas de la serie Morrowind, Oblivion y Skyrim como en otros numerosos juegos con mundos enormes como World of Warcraft, Star Wars, Lineage entre otros incluyendo simuladores de vuelo o trenes como son Microsoft Flight Simulator y Microsoft Train Simulator que hacen uso de data real combinado con modelado del terreno para lograr el realismo en sus paisajes. Algunos ejemplos de lo juegos mencionados se pueden ver en la figura 2.3. Aunque los terrenos en los juegos de video de hoy en da son principalmente modelados, existen dos grandes razones por las cuales el uso de terrenos generados de manera aleatoria tiene un uso importante: Reusabilidad Si podemos generar un mundo entero en cierto punto del juego la continuidad del mismo puede mantenerse generando el mismo terreno, ahora bien, si queremos que la experiencia de jugabilidad sea diferente en cada ocasin que el jugador empieza un nuevo juego, entonces podemos generar un nuevo mundo para recrear una nueva experiencia. Mundos enormes Es posible generar un juego dentro de un mundo virtual de un tamao enorme con la posibilidad de explorarlo completamente, con paisajes llamativos y realistas.

15 Este concepto es usado en muchos juegos como Minecraft y Spore en donde se utiliza la generacin mediante procedimientos aleatorios no solo del terreno y su coloracin sino tambin otros aspectos del juego.

(a) Daggerfall

(b) Skyrim

(c) Spore

(d) FLight Simulator

Figura 2.4: Juegos de video con terrenos generados (a, b y c). Simulador de vuelo con terrenos modelados a partir de data real (d).

En las siguientes secciones de este captulo se explicar en detalle las tcnicas y mtodos ms importantes usados actualmente para cubrir el tpico de la visualizacin de planetas haciendo nfasis en el manejo de la geometra, la generacin del terreno y el color y texturizado del mismo.

2.2 Trabajos previos


En la siguiente seccin se cubrirn algunos de los ms actuales trabajos referentes a la visualizacin de terrenos a escala planetaria. Los antecedentes del tema son relativamente nuevos, y aunque las investigaciones sobre la visualizacin de planetas vienen desde los comienzos de la computacin misma y los desarrollos de tecnologas aeroespaciales, no es sino en la ms reciente dcada que el hardware ha empezado a ser capaz de procesar y visualizar datos de enormes proporciones como los que representan los cuerpos planetarios. Aplicaciones conocidas como Google Earth y Nasa World Wind Son capaces de desplegar los datos de elevacin del planeta tierra, y recientemente, de la Luna y Marte entre otros cuerpos del sistema solar, adicionando capas extras como el clima, lugares tursticos, informacin de vas y carreteras entre otras funcionalidades. Estas aplicaciones

16 se enfocan en la fidelidad de las imgenes, ya que provienen de fotografas y mediciones satelitales con muy alta resolucin, de hasta centmetros por pixel, y su propsito es presentar al usuario una visin del mundo real de manera digital, poder interactuar con l y adquirir informacin que sea de inters. Ya que el tema principal de este trabajo no slo se basa en visualizar planetas cuyos datos son productos de medidas especiales, como satlites o fotografas areas, sino tambin de generar los terrenos y paisajes que conforman un cuerpo planetario, los trabajos citados a continuacin son capaces de visualizar planetas en ambos modos, aunque la mayora de ellos fueron desarrollados con el propsito de visualizar el modelo terrestre. Outerra: es un motor 3D para visualizar planetas, desde el espacio hasta la superficie. Puede usar MDE de resoluciones arbitrarias, refinando hasta centmetros usando algoritmos fractales. Visibilidad ilimitada, descarga progresivamente los datos, puede desplegar carreteras y puede generar contenido de manera procedural. Tiene integrado un motor de fsica para vehculos y aeronaves. El cdigo es cerrado, la aplicacin puede ser descargada gratuitamente para realizar pruebas, los autores quieren obtener un producto terminado para venderlo como software para simuladores o videojuegos. Proland4: es una librera escrita en C++/OpenGL para visualizar terrenos multiresolucin, incluyendo planetas enteros. Es capaz de representar datos vectoriales como carreteras, ros o delimitaciones de territorio. Es capaz desplegar ocanos, bosques, nubes y atmsfera, todo esto combinado con generacin procedural para dar ms detalle. La librera es de cdigo abierto, pero ha sido aparentemente abandonada ya que no recibe actualizaciones desde hace ms de un ao, adems, la implementacin no es robusta y no es compatible con muchos hardwares, incluso modernos, ya que fue hecha para un conjunto reducido de tarjetas de video. SpaceEngine5: es un software gratuito que permite explorar una simulacin del universo en tres dimensiones, comenzando con el planeta Tierra hasta las galaxias ms distantes. reas conocidas del universo son modeladas con datos reales, y las que no han sido exploradas son generadas de manera procedural. El punto de inters para este trabajo es que Space Engine despliega los planetas usando una combinacin de datos reales con generacin procedural, o simplemente generados en su totalidad, basados en ciertas caractersticas con el fin de minimizar el uso de datos, ya que, dependiendo de la resolucin, pueden ser muy grandes. El cdigo es cerrado y el uso de la aplicacin descargable es con propsito de pruebas.

1. HTTP://WWW.EARTH.GOOGLE.COM/ 2. HTTP://WORLDWIND.ARC.NASA.GOV/ 3. HTTP://WWW.OUTERRA.COM/ 4. HTTP://PROLAND.INRIALPES.FR/ 5. HTTP://EN.SPACEENGINE.ORG/

17 Aunque existen otras numerosas aplicaciones que son capaces de realizar la tarea de desplegar planetas, las tres aplicaciones antes expuestas son las ms modernas y cuyo objetivo es similar al presentado como propuesta de tesis en este trabajo.

2.3 Inspiracin del mundo real y la ciencia ficcin


Cuando se miran diferentes planetas se puede ver que hay literalmente millones de formaciones de terrenos y combinaciones de colores diferentes. Con slo comparar cun diferentes son la Tierra, la Luna y Marte podemos entender que las posibilidades son infinitas. La naturaleza ha demostrado la gran diversidad de formas que puede representar, desde las ms simples hasta las ms complejas, tambin el hombre ha podido crear con su imaginacin un sinfn de posibilidades con la ciencia ficcin, imaginar planetas que nunca hemos visto sino en pelculas como la saga de Star Wars, donde hay un planeta de lava llamado Mustafar y un planeta, principalmente desrtico, llamado Tatooine o incluso estaciones espaciales ms pequeas como la Death Star, muestran que las caractersticas de planetas, lunas o simplemente terrenos esfricos, pueden ser infinitas y heterogneas cuando las comparamos entre s.

(a) La Tierra

(b) La Luna

(c) Marte

(d) Planeta de Lava

(e) Planeta de Hielo

(f) Estrella de la Muerte

Figura 2.5: Comparacin en la diversidad de planetas reales y de ficcin. Del mundo real: (a) La Tierra. (b) La Luna. (c) Marte. Del universo de Star Wars: (d) Mustafar. (e) Planeta de hielo Hoth. (f) Death Star.

18 Lo que es ms impactante y asombroso sobre los planetas, es que son tan complejos y complicados desde los aspectos generales hasta los pequeos detalles. En la Tierra, por ejemplo, si se ve desde una larga distancia se puede observar su forma esfrica con continentes claramente visibles y sus ocanos. Si se observa ms cerca se pueden apreciar cordilleras, desiertos y llanuras. Una vez se llega a un punto lo suficientemente cerca de la superficie se pueden apreciar que hay colinas cubiertas con bosques, costas marinas y montaas rocosas cubiertas de nieve.

(a) Zonas continentales

(b) Coordillera de los Andes

(c) Desierto del Sahara

(d) Costa caribea

Figura 2.6: Ejemplos de las zonas de la Tierra vista desde diferentes alturas. (a) Zonas continentales de la Tierra. (b) Cordilleras montaosas. (c) Dunas de arena. (d) Costas marinas.

En la figura 2.6a se puede observar claramente la distribucin de los continentes en la Tierra y la proporcin aproximada de suelo y agua. Tambin se aprecia la diversidad de las costas, extensiones desrticas y densidad de la vegetacin que dependen de las latitudes debido a las influencias climticas bajo las cuales nuestro planeta est sometido. Si observamos ms de cerca, podemos apreciar la aleatoriedad con la que distintas formaciones de terreno se presentan, hay algunos principios bsicos y patrones como la dependencia de la altura y la ausencia de formaciones vegetales o de nieve en terrenos muy empinados. Incluir todas estas caractersticas es uno de los principales objetivos que sern propuestos como proyecto de tesis.

19

2.4 Generacin aleatoria de terrenos


La forma ms sencilla de generar un terreno aleatorio parece ser la de asignar a cada posicin en el terreno una altura al azar. Sin embargo el resultado se parece muy poco a un terreno natural. En la naturaleza, la altura del terreno en un lugar determinado, es en promedio ms parecida a lugares cercanos que en alguna ubicacin arbitraria, el terreno natural es ms o menos continuo, mientras que vara en altura de manera compleja en funcin de la posicin. La creacin de este tipo de terrenos continuos al azar es el desafo constante de los generadores de terrenos aleatorios. Los algoritmos de generacin de terreno a menudo aproximan un ruido fractal o multifractal, que tambin tiene aplicaciones ms generales dentro de la generacin del paisaje; tales como la sntesis de texturas y crean distribuciones aleatorias para cualquier otro elemento ecosistemtico del paisaje como bosques, rocas, ros, etc. Existen muchos algoritmos para generar terrenos con un aspecto natural, pero cuando se utilizan para generar a gran escala, y en este caso planetas, el resultado visual parece repetitivo, empiezan a aparecer patrones claramente visibles causando una prdida de naturalidad y realismo al paisaje porque la realidad es mucho ms compleja y los algoritmos usan nmeros pseudo-aletorios que eventualmente empiezan a repetirse. En la mayora de los casos los algoritmos existentes estn destinados para la generacin de un parche limitado de terreno. Esto significa que la malla generalmente es un plano de dos dimensiones y los algoritmos desplazan los vrtices a una tercera dimensin. Pero como se van a utilizar estos algoritmos para la generacin de la superficie de un planeta, es necesario realizar cambios en la aplicacin de estos algoritmos para que puedan trabajar sobre una esfera. Sin embargo, los cambios no son muy importantes en los algoritmos y solo se van a sealar las diferencias significativas haciendo abstraccin de la implementacin. Otro punto importante que se debe mencionar, cuando se genera un terreno a escala planetaria, es que para dar un mayor realismo se debe tomar en cuenta los distintos tipos de superficies naturales y formaciones de terreno que pueden existir en un mismo planeta, desde una escala macro como continentes, una escala media como cordilleras, montaas, llanuras y costas y una escala micro donde puedan apreciarse formaciones rocosas, pequeos desniveles, erosin y relieve. 2.4.1 Representacin de los datos La mayora de los algoritmos de nivel de detalle, en especial los presentados en este captulo, usan un mapa de alturas como la fuente de los datos del terreno. Como fue mencionado antes, el mapa de alturas es un mapa de bits que determina un MDE. Puede ser representado como un arreglo bidimensional de celdas igualmente espaciadas que almacenan una muestra de la altura correspondiente a un punto del terreno. Usualmente

20 las dimensiones del arreglo son en potencia de 2, permitiendo una divisin equitativa al momento de separar una data de grandes proporciones en porciones ms pequeas para un procesamiento ms fcil. Un mapa de alturas puede ser almacenado como una imagen en escala de grises, donde el negro representa la altura mnima y blanco representa la altura mxima. Al visualizar el mapa se puede especificar la cantidad de desplazamiento para cada pixel. Tambin se puede explotar el uso de los canales de color individuales para aumentar detalle. Por ejemplo, un estndar RGB 8-bit de imagen slo puede mostrar 256 los valores de gris y por tanto slo 256 alturas. Mediante el uso de colores, un mayor rango de alturas se puede almacenar mejorando notablemente el aspecto visual y detalle del terreno al costo de usar ms memoria. Un uso adicional del mapa de alturas en la visualizacin de terrenos es que permite, mediante tcnicas especficas, calcular el modelo de iluminacin y sombras del terreno. Adems, un mapa de alturas puede ser generado con factores especficos donde cada valor del mapa puede ser interpretado no como la altura en ese punto del terreno sino como el color del terreno o incluso an ms complejo, se puede interpretar como un tipo de objeto ubicado en ese punto, por ejemplo, un rbol, una roca, etc. Es necesario mencionar que el mapa de alturas representa la data de un terreno descrito por una malla de dos dimensiones. En este trabajo se trata de ampliar el modelo para trabajar en una esfera, los detalles de la solucin sern mencionados ms adelante, sin embargo, el uso de los mapas de alturas sigue siendo la principal representacin de la data a visualizar. 2.4.2 Interpolacin Los algoritmos de interpolacin son usados para calcular valores aproximados entre otros valores conocidos en un rango discreto o para redimensionar un conjunto de datos. Cuando se trata de mapas de alturas, la interpolacin es usada por la mayora de los algoritmos generadores, ya sea para suavizar el ruido o escalar el resultado. Adems, como los datos de un mapa de alturas estn separados de manera discreta, los valores intermedios se interpolan para dar continuidad a la superficie, de este modo no se nota una diferencia brusca, como escalones, entre dos puntos adyacentes. Existen numerosos algoritmos de interpolacin que se pueden usar dependiendo del contexto. Uno de los mtodos de interpolacin ms sencillos es el lineal, es rpido aunque no muy preciso. En general, en la interpolacin lineal se utilizan dos puntos , (xa, ya) y (xb, yb), para obtener un tercer punto interpolado (x,y) a partir de la siguiente frmula:

21 Otro mtodo de interpolacin muy utilizado en este campo es la interpolacin con splines. Los splines son curvas continuas definidas por segmentos de curvas ms sencillas, como polinomios de bajo grado. La interpolacin por medio de splines, a diferencia de la interpolacin lineal, es que puede tomar un numero N de puntos para interpolar entre ellos y arrojar una curva polinmica aproximada resultando en una interpolacin ms suave y realmente ajustada a la muestra de puntos.

Figura 2.7: Interpolacin por mtodo de splines, el primer y ltimo punto determinan la pendiente inicial y final de la curva

La frmula de interpolacin lineal y la interpolacin por splines se pueden extender para interpolar en cualquier dimensin, las ms usadas en dos dimensiones son la interpolacin bilineal y la interpolacin cuadrtica de splines, y en tres dimensiones la interpolacin trilineal y la interpolacin cbica de splines. 2.4.3 Midpoint Displacement Tal vez el ms fcil de comprender de todos los algoritmos de ruido es el Midpoint Displacement o Desplazamiento del Punto Medio. Midpoint Displacement funciona de una manera bastante sencilla. En primer lugar, comienza con una lnea recta entre dos puntos, en el punto medio de esta lnea, el valor se convierte en el promedio de los dos puntos exteriores adems de un valor aleatorio (llamado error). Contina recursivamente para cada segmento de lnea creado, hasta que se alcanza el nivel de detalle deseado. Es as de simple, slo con un detalle menor: El rango del valor aleatorio de error debe ser determinado por la longitud del segmento de lnea. De lo contrario, cada punto medio podra saltar errticamente. Al reducir el rango, los rasgos iniciales son grandes, pero planos, mientras que los rasgos posteriores son pequeos, pero detallados. Combinados, se forma una imagen con rasgos grandes pero definidos y pequeos detalles. Esto es bastante fcil de visualizar como una lnea unidimensional, sin embargo, se escala muy fcilmente a las dimensiones superiores. Al crear un paisaje 2D, se subdivide en cuadrados, y cada uno de los cuatro puntos medios de los bordes de un cuadrado se calcula como antes. Sin embargo, el punto medio nico en el centro del cuadrado en s tambin debe ser calculado mediante el promedio de las cuatro esquinas y sumando un valor de error aleatorio. Un ejemplo del resultado puede observarse en la figura 2.8.

22

Figura 2.8: Terreno obtenido con Midpoint Displacement, a la izquierda el modelo en wireframe, a la derecha el modelo texturizado.

2.4.4 Random Faults Aunque el algoritmo de Random Faults para paisajes esfricos descrito por Hugo Elas [3] no se considera generalmente como un algoritmo fractal, puede ser encontrado en la literatura como uno de los algoritmos bsicos para la generacin de terreno. Por otra parte, por ejemplo, en [4] se clasifica como un algoritmo capaz de producir un modelo de terreno con ciertas caractersticas fractales. El concepto es muy simple: Se genera un plano aleatorio P. Se genera un nmero aleatorio A en el rango [0, Altura]. Se divide la esfera en dos hemisferios con el plano P. Se agranda un hemisferio por A. Se reduce el otro hemisferio por A. Se repite el proceso por un nmero N de iteraciones (N>100).

Figura 2.9: Proceso con las tres primeras iteraciones

23

(a) 100 iteraciones

(b) 1000 iteraciones

(c) 10000 iteraciones

Figura 2.10: Luego de 100 iteraciones (a) se pueden apreciar continentes bien formados. A las 1000 iteraciones (b) comienzan a aparecer montaas e islas. Con 10000 iteraciones (c) ya se pueden ver grandes montaas, costas complejas, numerosas islas y lagos.

Podemos ver que este algoritmo no crea el modelo de terreno en un solo paso. En cada iteracin agrega ms y ms caractersticas en el modelo y el terreno se vuelve ms y ms natural y aleatorio. Por esa razn el nmero de iteraciones es un parmetro muy importante que influye en la apariencia final del terreno. A pesar de que se usa un plano para cortar la esfera y el corte podra verse como una lnea recta en la superficie, despus de aadir un nmero suficiente de iteraciones el conjunto de lneas rectas comienzan a desaparecer como resultado de orientaciones aleatorias de estos planos de corte. 2.4.5 Perlin Noise Perlin Noise es, probablemente, el algoritmo fractal ms conocido para la generacin de terrenos y de texturas. Su uso no se limita nicamente a las dos reas, tambin se utiliza comnmente en la animacin por computadora, para simular un movimiento de apariencia natural y casi en cualquier lugar donde se requiere algo que parezca que fue creado por la naturaleza. En la seccin 2.1 se mencionan algunos usos notables de este algoritmo y, se puede ver, que es el ms verstil cuando se trata de generacin de un ruido aleatorio coherente. Este ruido es comnmente implementado como una funcin de 2, 3 o 4 dimensiones, pero se puede definir para n dimensiones. Por simplicidad, se describe la versin unidimensional del algoritmo, una descripcin ms detallada se puede encontrar en [5] para 2, 3 y 4 dimensiones. El principio bsico de Perlin Noise consiste en la suma de diferentes funciones de ruido aleatorio (ver 1.4). Una funcin de este tipo de ruido es, bsicamente, una funcin pseudo-aleatoria (ver 1.3) que toma un valor como entrada, llamado semilla, y retorna un valor dentro de un rango establecido. A diferencia de la mayora de los generadores de nmeros aleatorios, este generador tiene como salida un valor aleatorio como funcin de

24 alguna entrada. En otras palabras, para la misma entrada del generador siempre retorna el mismo valor de salida, a menos que se usen semillas diferentes. Si se usa este generador de nmeros aleatorios, para generar valores en algunos puntos discretos equidistantes, se puede obtener, por ejemplo, una respuesta similar a la que se muestra en la Figura 2.11a. Si se utiliza algn tipo de tcnica de interpolacin entre los valores, se obtiene una funcin continua que devuelve algn valor real para cualquier punto de entrada a partir del intervalo elegido. Esta es la funcin bsica del algoritmo de Perlin Noise. Se muestra en la figura 2.11b.

(a) Valores Aleatorios

(b) Interpolacin suave

Figura 2.11: Funcin base del Perlin Noise. (a) Valor aleatorio de salida para cada punto discreto. (b) La interpolacin suave entre los puntos.

En la definicin de fractales se dice que hay una repeticin de una caracterstica a diferentes escalas, lo que significa que la funcin base debe generar una gama de diferentes escalas. Si se quiere transferir la funcin base a otra escala, se tiene que escalar apropiadamente su frecuencia y su amplitud. Aunque se puede utilizar diferentes proporciones para el ajuste a escala, la forma ms comn de obtener la funcin base a una escala inferior es el doblar la frecuencia y reducir la amplitud a la mitad. De esta manera podemos obtener una secuencia de la misma funcin base a diferentes escalas, como se muestra en la Figura 2.12.

25

Figura 2.12: La misma funcin base a diferentes escalas. En cada escala la amplitud se reduce a la mitad y la frecuencia se duplica.

Con el fin de crear una nica funcin que repita la misma forma en diferentes escalas, simplemente sumamos todas estas funciones base de manera adecuada. El resultado de esta superposicin es la funcin de Perlin Noise basada en Fractional Brownian Motion. Como se muestra en la Figura 2.13, se puede ver claramente que la funcin es auto similar y se repite la misma forma en diferentes escalas.

Figura 2.13: La funcin de Perlin Noise.

El mismo principio se demuestra en la figura 2.14 donde se genera una imagen con la funcin 2D de Perlin Noise. El valor de salida del algoritmo de Perlin Noise se interpreta como el coeficiente de mezcla entre los colores blanco y negro. Se puede ver que las escalas ms altas influyen significativamente en el aspecto global de la funcin, mientras que las escalas bajas aaden detalle y aleatoriedad al resultado.

26

(a) Octava 1

(b) Octava 2

(c) Octava 3

(d) Octava 4

(e) Octava 5

(f) fBm Perlin Noise

Figura 2.14: Funcin 2D fBm Perlin Noise. (a) (e) octavas numero 1 5. (f) Resultado de la suma de todas las octavas o fBm Perlin Noise.

Trminos importantes: Frecuencia: Se refiere a la distancia entre dos puntos adyacentes que se usan para la interpolacin de la funcin continua. Lambda = 1/frecuencia Amplitud: Es la altura de la funcin, es el rango de posibles valores que se puede asignar a cada punto. Octavas: Cada funcin base a escala que se superpone en la funcin final. Define la complejidad fractal dependiendo del nmero de octavas. Lacunarity: Define la brecha que hay entre una octava y otra mediante la relacin de la frecuencia de la octava actual respecto a la anterior. Persistencia: Es la escala de la amplitud. Define cmo se relaciona la reduccin de la amplitud en una octava respecto a la anterior.

Para ser ms precisos, usando los trminos que se acaban de definir, se puede formular matemticamente la funcin fBm de Perlin Noise como la siguiente ecuacin, donde el vector puede representar un punto en 1D, el espacio 2D, 3D o cualquier dimensin:

27 Con el fin de ser capaz de utilizar este algoritmo para la generacin de terrenos se tiene que extender la versin descrita de 1D a 2D y para el caso de la generacin de un modelo planetario, se debe extender a una versin 3D. Aunque sera suficiente crear un mapa de alturas 2D y luego mapear en una esfera 3D, la creacin de una funcin de Perlin Noise 3D es una mejor solucin ya se puede determinar la elevacin de cada punto de la esfera en el espacio 3D. De esta manera no se tiene que lidiar con problemas como la conexin discontinua de los bloques de terreno 2D. Como la funcin de Perlin Noise es una funcin continua, por lo tanto la versin 3D puede mapear el terreno de manera suave y constante por todo el planeta. Esto trae varias ventajas en comparacin con los algoritmos anteriores. Perlin Noise toma como entrada una esfera o cualquier otro slido ya existente y slo desplaza apropiadamente los puntos. Esto significa que se crea el modelo de terreno en un solo paso, a diferencia de Random Faults o Midpoint Displacement que necesitan de un nmero elevado de iteraciones. Existe una variacin del algoritmo de Perlin Noise creado por Ken Perlin en 2001 [6] llamada Simplex Noise que presenta algunas ventajas respecto a la versin clsica, especialmente para dimensiones superiores. Las ventajas del Simplex Noise sobre Perlin Noise: Simplex Noise tiene una complejidad computacional significativamente ms baja y requiere menos multiplicaciones. Simplex Noise escala a dimensiones superiores (4D, 5D) con menos costo computacional, la complejidad es O(n) para n dimensiones en vez de O(2n) de la versin clsica. Simplex Noise no tiene artefactos direccionales notables (es isotrpico). Simplex Noise tiene un gradiente continuo y bien definido en todas partes que se puede calcular con un bajo costo. Simplex Noise es fcil de implementar en hardware.

(a) Perlin Noise y Simplex Noise 3D

(b) Perlin Noise y Simplex Noise 4D

Figura 2.15: Comparacin visual de las versiones clsica y simple de Perlin Noise. (a) Aplicacin de Perlin Noise 3D y Simplex Noise 3D respectivamente sobre una esfera. (b) Misma comparacin con Perlin Noise 4D y Simplex Noise 4D.

28 2.4.6 Perlin Noise Multifractal Esta es una variacin multifractal del algoritmo clsico de Perlin Noise. Con el fin de producir ms realismo en un terreno, se tiene que variar la dimensin fractal. Una forma obvia de hacerlo es hacer que la dimensin fractal dependa en funcin de la altitud. Si se utiliza la elevacin del punto, que est determinada por la suma de las contribuciones de todas las octavas calculadas y se escala con la contribucin de la escala actual, entonces cuando la elevacin es cercana a 0, el terreno se ver ms suave, debido a que la contribucin de las octavas ms altas se reduce. Por otro lado, si la elevacin del punto es mayor, por lo tanto se acenta la contribucin de las octavas ms altas y el terreno se ver ms spero e irregular.

Figura 2.16: Terreno generado con Perlin Noise Multifractal

2.4.7 Perlin Noise Ridged Es una ligera modificacin en el algoritmo clsico de Perlin Noise. El principio fundamental del algoritmo es el mismo. La nica diferencia est en la forma en que se usa el valor de salida generado por la funcin. Si interpretamos el Perlin Noise clsico desde el punto de vista del terreno, entonces el valor -1 significa generalmente fondo del mar y el valor 1 significa una montaa alta. En oposicin a esto, Perlin Noise Ridged interpreta ambos lados del intervalo [-1, 1] como el fondo dell mar y slo levanta la lnea entre ellos como montaas. La principal diferencia de un terreno producido por Perlin Noise clsico y por Perlin Noise Ridged es que ste ltimo tiende a crear islas largas y estrechas, pennsulas y cordilleras.

29

(a) Perlin Noise Classic

(b) Perlin Noise Ridged

Figura 2.17: Comparacin de terrenos generados con (a) Perlin Noise clsico y (b) Perlin Noise Ridged

2.4.8 Perlin Noise Ridged Multifractal Esta modificacin del algoritmo de Perlin Noise Ridged crea un terreno ms realista mediante la incorporacin del principio multifractal variando de la dimensin fractal. No se va a explicar esta versin con mucho detalle, porque se utilizan los principios que ya se han explicado. Se calcula y modifica la respuesta de la funcin de Perlin Noise como se explica en la seccin 2.4.7 sobre el algoritmo Perlin Noise Ridged. A continuacin, se utiliza el mismo principio para aadir detalle multifractal en el terreno que ya se ha explicado en la seccin 2.4.6. Esto significa que se crea la dimensin fractal en funcin de la altura. El algoritmo producir tierras bajas y costas suaves y montaas rugosas e irregulares. 2.4.9 Worley Noise Tambin conocida como Cell Noice, es una funcin de ruido introducida por Steven Worley [7] en 1996, el cual describe la generacin su ruido como un diagrama de Voronoi. En el rea de la computacin grfica se utiliza para crear texturas procedurales, es decir, texturas que se crean automticamente con precisin arbitraria y no tienen que ser dibujadas a mano. Worley Noise se acerca a la simulacin de texturas de piedra, agua, o clulas. La idea bsica es tomar puntos al azar en el espacio (2D o 3D) y posteriormente, para cada punto en el espacio, tomar la distancia al n-simo punto ms (por ejemplo, el segundo punto ms cercano) como algn tipo de informacin de color [8] en la figura 2.18 se puede observar cmo funciona el algoritmo. Ms precisamente: Distribuir aleatoriamente puntos de la entidad en el espacio que se llamarn puntos caractersticos. Noise Fn (x) es la distancia desde x hasta el punto caracterstico n-simo ms cercano.

30 Para encontrar el n-simo ms cercano, los puntos caractersticos distribuidos aleatoriamente, son subdivididos en una estructura de Quadtree o, para el caso en 3D, en una estructura Octree, permitiendo encontrar rpidamente los puntos ms cercanos.

Figura 2.18: Los puntos caractersticos aleatoriamente distribuidos se encuentran en una estructura de Quadtree, el punto x representa la muestra y se observa que se calcula la distancia desde x hasta los puntos cercanos, el algoritmo retorna el segundo ms cercano.

Implementaciones tpicas, en tres dimensiones, dividen el espacio en cubos. Un nmero fijo de posiciones se generan por cada cubo. En el caso de tres dimensiones, es necesario generar al menos un punto caracterstico en alguno de los nueve cubos para asegurar que se encuentre el ms cercano.

(a) F1(x)

(b) F2(x)

Figura 2.19: Resultados al usar Noise FN(x) con N = 1, 2.

Ahora bien, si se observa la Figura 2.19a se puede percibir el resultado de colocar a cada valor de x la distancia hasta el primer punto ms cercano. Hay que tomar en consideracin que el valor cero (negro) significa que la distancia es cero y el valor uno (blanco) significa que la distancia es igual o super la unidad mxima de distancia, la cual es un parmetro de entrada del algoritmo, puede estar basada en las dimensiones de la imagen, nmero de puntos caractersticos, distancia mxima entre cualquier par de puntos o distancia promedio entre los puntos caractersticos. Si se observa la Figura 2.19b se aprecia una

31 gran diferencia del resultado usando el segundo punto caracterstico ms cercano sobre el mismo grupo de puntos caractersticos aleatoriamente distribuidos. Si se combinan los resultados de dos o ms distancias de n-simos puntos ms cercanos se pueden obtener diferentes resultados. Por ejemplo, en la Figura 2.20 se puede observar diferentes efectos de ruido logrados mediante la combinacin de las distancias desde x hasta el primero y el segundo punto caracterstico ms cercano.

(a) F2(x) F1(x)

(b) F1(x) * F2(x)

(c) (F1(x)+F2(x))/2

Figura 2.20: Comparacin de los resultados combinando las distancias al primer y segundo punto caracterstico ms cercano.

La manera de calcular la distancia influye en el resultado de la imagen, por ejemplo, si en vez de usar la distancia Euclidiana se usa la distancia Manhattan, el resultado genera patrones de diamantes como se puede observar en la figura 2.21a. Otros criterios de distancia pueden ser usados, como por ejemplo, la distancia de Chebyshev, cuadrtica, logartmica o Minkowski, en la figura 2.21b se puede observar un patrn de rectngulos formado por F1(x) usando como clculo la distancia de Chebyshev.

(a) Distancia Manhattan

(b) Distancia Chebyshev

Figura 2.21: Comparacin de F1(x) usando (a) Distancia Manhattan. (b) Distancia de Chebyshev

En el campo de la generacin de terrenos el algoritmo de Worley Noise, por s solo, no es de mucha utilidad, a menos que la meta sea crear un terreno sinttico con caractersticas de apariencia fabricadas, ya que genera estructuras muy artificiales, generalmente con lneas irregulares duras o superficies que semejan burbujas. Sin

32 embargo, combinado con la apariencia natural de otra funcin de ruido, como el Perlin Noise se pueden crear paisajes distintivos. 2.4.10 Worley Noise Multifractal Esta modificacin del algoritmo, combina el resultado del Worley Noise a diferentes frecuencias, generando un fBm de Worley Noise. El principio bsico es combinado con parmetros que distingan una diferencia entre octavas, por ejemplo, la funcin de distancia usada o la combinacin de las distancias de los n-simos puntos caractersticos. El resultado del fBm de Worley Noise genera un paisaje de apariencia ms natural, sin necesidad de combinarlo con otro tipo de ruido. En la figura 2.22 se puede apreciar el fBm de Worley Noise para F1(x).

Figura 2.22: fBm Worley Noise para F1(x)

2.4.11 Combinacin y Perturbacin El problema con el uso de Perlin Noise o Worley Noise para simular terrenos realistas es que son estadsticamente homogneos e isotrpicos, propiedades que un terreno natural no comparte. Una forma de romper la monotona y controlar las principales caractersticas del paisaje es combinar diferentes algoritmos de ruido que generen caractersticas distintas a cada escala del terreno. Por ejemplo, Jacob Olsen [9] sugiere que la perturbacin de la combinacin de diferentes funciones de ruido, ya sea por suma, multiplicacin, diferencia, promedio, interpolacin o producto ponderado, tiende a producir un terreno ms heterogneo, con caractersticas ms naturales. Por ejemplo, en la Figura 2.23 se puede observar el resultado de combinar un terreno generado con Midpoint Displacement y uno con Worley Noise.

33

(a) F2-F1

(b) Midpoint Displacement

(c) a+b

(d) Perturbacin de c

Figura 2.23: Resultado de la combinacin entre (a) y (b) alterado con un algoritmo de perturbacin.

La perturbacin es el punto ms importante cuando combinamos dos o ms funciones de ruido, porque elimina cualquier artefacto no natural mientras que al mismo tiempo incrementa la naturalidad del paisaje generado. En [10] se describe un filtro que puede ser aplicado para poder lidiar por las lneas rectas que producto del Worley Noise. Este filtro de perturbacin funciona mediante el uso de una funcin de ruido (similar a las descritas anteriormente) para calcular un desplazamiento con la distancia y una direccin aleatoria para cada pixel del mapa de alturas. 2.4.12 Sparse dot Noise Este algoritmo de ruido de puntos dispersos o Random placement patterns no genera por s solo un mapa de alturas, pero su uso mediante la combinacin con otros algoritmos de ruido, como fue descrito anteriormente en 2.4.11, puede contribuir an ms con el resultado de un mapa de alturas, aportando caractersticas nicas al paisaje. En [10] se describe un algoritmo de patrones aleatorios que consiste en un numero de patrones regulares o irregulares, tambin llamados bombas que se dejan caer en posiciones, orientaciones y escalas aleatorias sobre el mapa de alturas. Esta tcnica de bombardeo sirve para agregar sobre el terreno generado algunas propiedades particulares que dan mucha ms naturalidad. Entre las caractersticas que pueden ser incorporadas al mapa de alturas se pueden mencionar crteres, rocas y surcos. Los crteres en especial son muy importantes, porque son la base principal cuando se generan lunas o planetas con atmsfera ligera, que permiten el paso de asteroides y sufren de impactos de asteroides, dejando crteres dispersos por toda la superficie. En la figura 2.24 se puede apreciar el resultado de agregar crteres sobre un mapa de alturas.

34

Figura 2.24: Visualizacin de un mapa de alturas con crteres generados.

2.4.13 Algoritmos de Erosin Las combinaciones de algoritmos de ruido pueden crear paisajes interesantes, pero la erosin puede ayudar a aadir una capa extra de realismo. Los efectos de la erosin son difciles de describir matemticamente, el trmino erosin [9] abarca muchos fenmenos naturales. Diferentes tipos de terrenos y climas producen muchos tipos de cambios distintos en un paisaje. En general, la mayora de los tipos de erosin disuelven materiales de pendientes pronunciadas, lo transportan hacia abajo y luego depositan el material a las bajas inclinaciones. Esto tiende a hacer las pendientes an mayores, y aplanar el terreno a baja altura, cuando se deposita el material transportado. Existen dos algoritmos bsicos de erosin que fueron descritos por primera vez en 1989, y desde entonces, se han establecido como una base desde la cual se han propuesto diversas mejoras, los algoritmos son: Thermal Erosion: Los modelos de erosin trmica desgastan las superficies que son demasiado empinadas. Si el ngulo es demasiado fuerte, el suelo va a caer a una zona ms baja. La erosin trmica es un modelo bastante simple. En primer lugar, se define la diferencia T, que es la diferencia mxima permitida antes de que la gravedad se haga cargo. Para todos los pxeles: 1. Se obtiene la diferencia de altura entre este pxel y el pxel vecino 2. Si la diferencia es mayor que T, se elimina una cierta cantidad de suelo desde el pxel ms alto y se deposita en el pxel inferior. Muy simple, pero funciona rpidamente. Esto se hace varias veces hasta que se alcanza la cantidad deseada de la erosin. La velocidad de este algoritmo se puede mejorar an ms cambiando el tipo de vecino. Los tres tipos estndar de vecinos son el de Moore, el de Von Neumann, y Von Neumann rotado. Mientras que al usar el

35 vecino de Moore proporciona los mejores resultados, tambin es el ms lento. El vecino de Von Neumann rotado da buenos resultados, y aumenta la velocidad. Hydraulic Erosion: La erosin hidrulica modela el agua de la lluvia arrastrando partculas del suelo, hacia abajo, a las superficies ms planas, luego se evapora, dejando un depsito tierra. La erosin hidrulica proporciona resultados de buena calidad, pero es muy lenta. Este algoritmo tambin requiere grandes cantidades de memoria. Mientras el algoritmo de erosin trmica trabaja directamente con la imagen original, la erosin hidrulica requiere una estructura para modelar el agua y otra para los sedimentos, lo que significa que puede utilizar hasta 3 veces la memoria de la erosin trmica. Para comenzar el algoritmo, una tabla de agua se configura, que es una matriz del tamao de la imagen que mantiene la cantidad de agua en cada pxel. Una tabla de sedimentos tambin se utiliza para rastrear la cantidad de sedimento en el agua. Algunas variables que deben ser definidas: cantidad_de_lluvia: la cantidad de lluvia cae por iteracin solubilidad: la cantidad de suelo que se erosiona en una unidad de agua evaporacin: qu porcentaje del agua se evapora en cada iteracin? capacidad: la cantidad de sedimentos que una unidad de agua puede contener Mediante el ajuste de estas variables, los efectos de la erosin cambian. Una alta evaporacin mueve la tierra unas distancias cortas, mientras que la baja evaporacin crea charcos de agua. Una vez que estos se definen, el proceso se puede dividir en cuatro partes que se realizan en cada pxel: 1. Precipitaciones: se agregan cantidad_de_lluvia unidades de agua a cada pxel en la tabla de lluvia. 2. Erosin: mueve solubilidad*agua[x][y] tierra de la imagen base a la tabla de sedimentos. 3. Movimiento: movimiento del agua hacia abajo, si es posible 4. Evaporacin: elimina evaporacin*agua[x][y] agua del pixel. Si el sedimento en el sedimento[x][y] excede capacidad*agua[x][y], se mueve tierra desde la tabla de sedimento a la imagen base hasta que ya no excede la capacidad. Esto se lleva a cabo para cada pxel, por cada iteracin. La erosin hidrulica tiende a funcionar lentamente, pero da buenos resultados.

36

Figura 2.25: Resultado de aplicar la Erosin Trmica sobre un terreno generado.

Existen otros tipos de algoritmos de erosin para simular el desgaste generado por el mar en las zonas costeras, otros que simulan la erosin del viento o incluso la erosin generada por el movimiento de glaciares. Mientras ms tipos de erosin se agregan a la generacin del terreno, el paisaje se vuelve cada vez ms natural pero a su vez el clculo es ms lento y costoso, sin embargo, no afecta el rendimiento general cuando se van a visualizar.

2.5 Algoritmos para colorear y texturizar terrenos


Una parte de la generacin de modelos planetarios de aspecto realista es la generacin del terreno, pero no hay duda de que cualquier modelo de terreno nunca se ver realista sin una buena coloracin de la superficie. De hecho, en el caso de generacin de planetas, el color es, incluso, ms importante que el propio terreno. Esto es especialmente cierto cuando se mira el planeta desde una distancia mayor. En esta situacin, las caractersticas del terreno, como montaas o valles, no son visibles en lo absoluto. La nica manera de diferenciar estos detalles es destacndolos mediante un buen modelo de coloracin. El reto es definir un buen modelo que contemple la coloracin del planeta desde diferentes puntos de vista, desde distintas alturas y que contemple las coordenadas geogrficas, ecosistemas, alturas del terreno o, incluso, distintos tipos de planetas, como mundos rocosos, gaseosos, de hielo o, algo ms fantstico, como mundos mecnicos o biolgicos. En esta seccin, se va a describir algunas tcnicas y principios bsicos para colorear de manera realista la superficie de un planeta. Algunos slo dependen del modelo de terreno que se utiliza, otros incorporan los principios fractales para aadir ms aleatoriedad y una apariencia ms natural. En lugar de una descripcin de los algoritmos de coloreo especficos y esquemas para texturizar, en esta seccin se explican algunas de las tcnicas y mtodos ms utilizados. En el prximo captulo, se explicar con mejor detalle la tcnica propuesta para dar realismo a los distintos paisajes que se pueden apreciar en un solo

37 planeta, coloracin de la superficie vista desde diferentes alturas y cmo dar detalle en cada nivel. 2.5.1 Representacin de Color Existen diferentes representaciones de color que se utilizan en la computacin grfica. Discutir sobre las ventajas o desventajas de una u otra es irrelevante. El modelo ms usado para representar el color es mediante el sistema RGB. Cada color se describe como una composicin ponderada de los tres colores bsicos: rojo, verde y azul. En la figura 2.26 se muestra el espacio de color. Esta es una representacin habitual del espacio de color que se utiliza en muchos lenguajes de programacin.

Figura 2.26: Espacio de color RGB.

2.5.2 Mapeado de Texturas Por lo general, una textura es una imagen de tipo bitmap que se utiliza para cubrir la superficie de un modelo virtual, le da color y realismo. Es posible usar ms de una sola textura sobre un mismo polgono, este mtodo se denomina multitexturizado. La tcnica de multitexturizado es muy til en el rea de visualizacin de terrenos, proporciona naturalidad y detalle al mismo mediante el uso de varias texturas dependiendo de ciertas propiedades y caractersticas del terreno, como por ejemplo, la altura o la inclinacin. Cuando se trata de planetas, coloracin general viene dada por la combinacin de las texturas de las diferentes extensiones y zonas del terreno que lo conforman. En la siguiente figura, se puede observar tres tipos de texturas aplicadas sobre un mapa de alturas, el tipo de textura aplicado depende de la elevacin del terreno y son interpoladas entre s para evitar transiciones bruscas.

38

Figura 2.27: Texturizado de un terreno dependiendo de la altura

2.5.3 Interpolacin El color de un terreno, normalmente, cambia de manera gradual. Por ejemplo, si se observa un borde entre bosques y montaas rocosas, se puede ver que por lo general no es una lnea clara. A medida que nos acercamos a altitudes ms altas, hay cada vez menos rboles y el color poco a poco, de forma continua, cambia de tonos verdes a una especie de un color marrn rocoso. En lugar de transiciones bruscas entre dos colores, se tiene que cambiar continuamente el tono del color. La interpolacin lineal es una tcnica bsica para hacerlo. Cuando se representa el color como una composicin de tres partes RGB, se tienen los valores exactos que se pueden utilizar para la interpolacin. Si se quiere interpolar entre dos colores, primero se debe interpolar separadamente entre sus componentes RGB correspondientes y luego juntar las respectivas componentes para obtener el color final. Como fue explicado en la seccin 2.4.2, existen numerosas maneras de interpolar entre dos o ms valores, en este caso, colores. La interpolacin lineal y la interpolacin por splines pueden generar resultados diferentes, dependiendo del contexto. En el caso de coloracin de un planeta, puede ser muy til cuando se trata de dar caractersticas generales de todo el globo. En la figura 2.28 se puede observar una esfera coloreada con diferentes puntos de colores interpolados con la funcin de splines en el eje vertical de la esfera, dando un resultado parecido a los anillos de Saturno. ste tipo de coloracin puede dar resultados muy artificiales, pero combinados con las tcnicas que se detallarn ms adelante, se pueden lograr coloraciones muy naturales.

39

Figura 2.28: Interpolacin por splines de colores sobre una superficie esfrica.

Las tcnicas de interpolacin pueden ser tiles tambin al momento de texturizar, se pueden usar dos o ms texturas para crear una nueva textura compuesta. Esta nueva textura es el producto de interpolar entre las texturas bases usando alguna tcnica, por ejemplo, usando una textura adicional que se denomina mscara de mezcla, que contiene la informacin de la proporcin de interpolacin del color a ser mezclado entre las texturas por cada pixel. Como se puede observar en la figura 2.29, dos texturas son mezcladas mediante una mscara de mezcla. Esta tcnica tiene muchas extensiones y las posibilidades son inmensas, en las prximas secciones se explicar con detalle el funcionamiento y propsito de usar texturas de mscaras de mezclas, las cuales, como se puede observar, pueden ser creadas de manera procedural usando los algoritmos que se han descrito anteriormente.

(a) Textura de tierra

(b) Textura de grama

(c) Mscara de mezcla

(d) Resultado de la mezcla Figura 2.29: Interpolacin entre una textura de tierra y una de grama mediante una mscara de mezcla da como resultado una textura ms natural y realista.

40 2.5.4 Texturizado procedural Cuando se habla de texturizar un planeta, se deben tomar en cuenta las diferentes escalas y qu tanto detalle se quiere conseguir. Si se desea que un terreno sea texturizado con un detalle nico desde kilmetros hasta centmetros, la cantidad de datos necesarios para conseguir ese detalle es imposible de manejar con el hardware actual. Existen dos soluciones para este problema, la primera es segmentar los datos en porciones ms pequeas y manejarlas out of core o fuera de ncleo, ya sea en discos duros o almacenadas en servidores y recuperadas por una conexin de red. La otra solucin es realizar un texturizado procedural de la superficie. Cuando se habla de texturizar de manera procedural, existen dos corrientes que influyen en el proceso. La primera abarca la generacin de imgenes de texturas, mediante funciones matemticas o variaciones de funciones de ruido, mientras que la segunda hace uso de dichas funciones para determinar el color de un pixel mediante la combinacin total o parcial de un conjunto de imgenes ya existentes. Para la visualizacin de terrenos y planetas, la segunda corriente de texturizado procedural es el foco de estudio en este trabajo. Aunque no existe un mtodo especfico para texturizar terrenos, existen numerosos artculos y publicaciones [12] [13] [14] en las que se han ideado distintos mtodos para texturizar terrenos. Con algunas tcnicas en comn y haciendo uso eficiente de los recursos, se puede lograr texturizar un terreno con una apariencia muy natural. Como fue explicado al principio de este trabajo, un terreno de magnitudes planetarias tiene una gama muy variada de caractersticas geolgicas y elementos ecosistemticos que forman un mundo nico y al mismo tiempo un universo de posibilidades infinitas. Cada una de estas caractersticas puede ser representada como un grupo de formaciones de terreno con propiedades en comn y que pueden ser texturizadas siguiendo distintos patrones. Cuando se observa una porcin de terreno planetario a una escala alta, como los son los continentes (ver figura 2.30a), se puede apreciar que existen diferentes zonas que comparten un patrn visible y gradual que depende de la latitud del territorio, por ejemplo en la tierra, cerca del ecuador es un terreno ms desrtico, mientras que cerda de los polos, el terreno se hace ms montaoso hasta llegar a un terreno helado. Ahora bien, si se observa el planeta desde una escala media, como por ejemplo valles y cordilleras montaosas, (ver figura 2.30b) se puede ver que tambin existe un cambio gradual en el color del terreno. Las partes ms bajas del suelo tienden a ser de grama, y mientras la altura del terreno es mayor, se puede observar como progresivamente el suelo empieza a ser ms rocoso y, si la altura de la montaa es suficiente, tambin se puede ver un cambio continuo de un suelo rocoso hacia un suelo con nieve. Adems es posible apreciar que los terrenos empinados poseen caractersticas peculiares, por

41 ejemplo, en una montaa nevada, las zonas con una pendiente pronunciada tienden a no tener nieve y se puede ver la roca. Finalmente, cuando observamos la superficie del planeta a una escala pequea, existen distintas variaciones del terreno que le proporcionan caractersticas nicas en cada metro cuadrado que pueda ser visto. Por ejemplo, (ver figura 2.30c) una superficie de grama puede tener reas donde no hay vegetacin y se observa slo la tierra, al mismo tiempo la grama puede tener reas de distintos colores o incluso distintos tipos de grama. Lo mismo sucede cuando se observa la parte media de una montaa, (ver figura 2.30d) en las zonas planas puede crecer vegetacin mientras que en las ms empinadas slo se puede observar la roca.

(a) Continente desde el espacio

(b) Valles y montaas

(c) Terreno a nivel del suelo

(d) Detalle de la inclinacin de una montaa

Figura 2.30: Caractersticas que pueden ser modeladas con el texturizado procedural.

El reto del texturizado procedural es usar un conjunto reducido de texturas de una calidad media y repetirla, dependiendo del tipo de terreno, adicionalmente se toman en cuenta los cambios de altitud del terreno para desplazar gradualmente entre una textura y otra. Existen algunos problemas cuando se repite una misma textura en una extensin grande de geometra, pero el texturizado procedural es capaz de resolverlos haciendo uso de funciones matemticas y funciones de ruido para combinar las texturas.

42 El principal problema causado por repetir la misma textura es el tiling, que es un artefacto en el que se percibe la misma textura como una serie de baldosas repetidas cuando se observa el terreno desde una distancia lejana. Este artefacto produce un terreno que no se ve natural y el patrn repetitivo es inevitable. Otro problema es la resolucin, ya que no se pueden usar texturas con mucha resolucin, las imgenes tienden a cubrir entre unos 4 a 16m por pixel, cuando el observador se ubica a tan solo centmetros de la superficie, un solo pixel de la textura cubre un rea grande del terreno. La solucin para el primer problema es combinar dos o ms texturas mediante un algoritmo de ruido. Ya se ha explicado en detalle varios algoritmos que generan un ruido coherente y aleatorio, estas funciones de ruido son infinitas y no se repiten, si se usa la salida de una funcin de ruido entre cero y uno, se puede interpolar el color de un pixel entre una textura y otra usando como parmetro dicha salida, resultando en un efecto que elimina por completo el problema de tiling. En la figura 2.31 se puede observar un rea de terreno en el que se aprecia el artefacto de tiling y cmo se soluciona al combinar interpolando, con la salida de funciones de ruido, con otra textura de caractersticas similares.

(a) Tiling

(b) Solucin

Figura 2.31: Eliminacin del artefacto de tiling mediante una combinacin de texturas usando algoritmos de ruido.

Como las funciones de ruido pueden ser evaluadas a cualquier escala, el segundo problema tambin se puede resolver con funciones de ruido aleatorio. La diferencia es, que para dar detalle a nivel de centmetros de la superficie, se debe conocer el tipo de textura usada para definir un patrn que se vea real, no es lo mismo un detalle de grama a uno de tierra o rocas. Algunas funciones de ruido son difciles de modificar para que generen patrones correspondientes a texturas naturales mientras que otras son fciles de conseguir. En la figura 2.32 se puede apreciar cmo se puede eliminar el artefacto producido por la resolucin, se agrega detalle a la superficie con una funcin de ruido de alta frecuencia.

43

(a) Resolucin

(b) Detalles agregados

Figura 2.32: Ambas imgenes son la misma escena, un terreno visto desde centmetros de la superficie. El problema de resolucin es evidente. Se le agrega detalle mediante algoritmos de ruido.

Otra solucin bsica y simple al problema de resolucin de la textura es usar detail textures. Las texturas de detalle o detail textures [13] son texturas que crean la ilusin de una textura de alta resolucin. La tcnica puede solucionar de manera fcil este artefacto y consiste en multiplicar la textura original por una textura de detalle. La idea principal es escalar la textura de detalle de tal modo que se repita con mayor frecuencia, cuando el observador est lejos del terreno, no se aprecia el detalle, pero cuando est cerca la textura de detalle agrega los pequeos elementos que no son visibles desde la distancia. En la figura 2.33a se puede observar un terreno cuyo detalle se pierde al acercarse el observador, en la figura 2.33b se ve el terreno slo con la textura de detalle y finalmente en la figura 2.33c se observa que se agrega un buen detalle en la cercana mientras se mantiene la misma textura en la distancia.

(a) Textura sin detalle

(b) Textura de detalle

(c) Resultado de la multiplicacin

Figura 2.33: Resultado de aplicar una textura de detalle a un terreno.

Las funciones matemticas pueden describir estructuras bastante complejas, pero con el fin de ser desplegadas en tiempo real, la funcin tiene que evaluarse lo suficientemente rpido. Esto significa que las texturas "simples" como la nieve, o, posiblemente, arena o rocas pueden ser completamente procedurales, mientras que las formas ms complejas como la grama y distintos tipos de vegetacin, pueden permanecer como una textura con un detalle aadido proceduralmente. En general, una mezcla de texturas y funciones se utiliza para el mejorar efecto.

44 Lo ms importante para construir una textura procedural son las funciones de ruido. Dichas funciones tomar las coordenadas de textura, de un pixel particular, como parmetro de entrada y retornan un valor entre 0 y 1. Las funciones de ruino no son nicas y cada una puede ser modificada para lograr diferentes efectos como se ha explicado anteriormente. Perlin Noise, puede ser usado a diferentes escalas, para interpolar varias texturas con un resultado spero muy natural. Worley Noise tambin se puede usar a cualquier escala, dependiendo del tipo de textura que se quiera conseguir, por ejemplo, puede definir estructuras como lava o pisos de rocas. Otro tipo de ruido que es muy til al momento de agregar detalle a la textura es el Sparse dot Noise, con ste ltimo se pueden aadir pequeos parches de vegetacin o piedras. Finalmente si se combinan diferentes texturas usando diferentes funciones de ruido, que adems se pueden perturbar, las posibilidades de texturizacin son infinitas. El Encontrar las frecuencias y amplitudes correctas para que una funcin de ruido pueda mezclar texturas con una apariencia realista, es un arte ms que una tarea computacional.

2.6 Algoritmos para manejo de la geometra y nivel de detalle


En el pasado, los algoritmos de LOD se ejecutan principalmente en la CPU. Sin embargo, en los ltimos aos, la potencia de la CPU ha sido superada, por mucho, por la potencia de la GPU. Como resultado, desplegar un polgono es a menudo ms rpido que determinar si debe desplegarse o no. Debido a esto, los nuevos algoritmos de renderizado de terreno tratan de empujarle ms trabajo a la GPU y minimizar el uso de la CPU. Han dejado de inspeccionar y seleccionar polgonos individuales, y en cambio, se dedican a agrupar los polgonos en grupos ms grandes y hacer la seleccin entre estos grupos. Usando de este enfoque, la mayor parte del trabajo se lleva a cabo en la GPU. Para lograr velocidades de cuadros por segundos de calidad interactiva, el nmero de tringulo a ser desplegados debe reducirse considerablemente. Una cantidad discreta de esta reduccin se llama el nivel de detalle. Debido a las propiedades de la proyeccin en perspectiva, el nivel de detalle tiene que ser diferente para diferentes partes de los objetos visualizados. Cuando el cambio en la simplificacin del nivel de detalle es gradual a lo largo de la superficie del mallado, se habla de un nivel continuo de detalle. Cada algoritmo que ha sido descrito en secciones anteriores de este captulo, hacen uso de una estructura que se denomina como mallado. Ahora, cuando se describe un mallado, se puede decir que es un conjunto de vrtices desplegados de forma regular o irregular y que forman una malla o red de polgonos. Sin embargo, cuando se quiere desplegar planetas, una estructura simple como un mallado es tan solo una pequea fraccin de la estructura que lo conforma.

45 Como ya se ha mencionado, uno de los objetivos principales de este trabajo, es enfocar la propuesta de trabajo especial de grado en el manejo de la geometra del planeta y su representacin. En las siguientes secciones se hace un estudio breve de los algoritmos ms populares capaces de hacer este trabajo, se dejarn de lado algoritmos obsoletos y se har nfasis en los ms modernos, ya que hacen uso, en la mayora de sus tareas, de la GPU. Adems, estos nuevos algoritmos para despliegue de terrenos son capaces (bajo ciertas modificaciones) de renderizar cuerpos planetarios, adicionalmente, se mencionan algunas ventajas y desventajas de cada una de las tcnicas. Antes de profundizar en la explicacin de las tcnicas y algoritmos, se debe hablar de los dos problemas ms habituales que se encuentran al usar algoritmos LOD: cracks y popping. Los cracks o grietas se producen cuando un parche muy detallado del terreno est situado al lado de un parche de detalle inferior. En tales casos no hay correspondencia uno-a-uno entre los vrtices del borde de cada parche. Esto puede dar lugar a agujeros en el terreno y no hay una forma estndar de tratar con las grietas. El otro problema que se debe hacer frente en los algoritmos de LOD es el popping, que se produce cuando un parche del terreno cambia de nivel de detalle a uno ms alto o de menor nivel. Si el espectador se encuentra cerca del parche de terreno cuando se produce el cambio, se ve un cambio brusco. Popping es ms visible en los algoritmos que trabajan con parches en lugar de tringulos individuales. Esto tiene sentido, porque cuando se hace uso de los parches, una gran cantidad de tringulos se cambian a otro nivel de detalle al mismo tiempo. Una vez ms, para este problema no hay una forma estndar de tratarlo y deben idearse soluciones. 2.6.1 ROAM 2.0 Hwa, Duchaineau y Joy [15] modernizaron un algoritmo conocido, pero ya obsoleto Real-time Optimally-Adapting Meshes (ROAM) [16], por lo tanto, su contribucin se conoce como ROAM 2.0. Un enfoque similar es tambin el algoritmo RUSTIC [17] pero ROAM 2.0 es mucho ms avanzado. Facilita el procesamiento por lotes, que est optimizado para el hardware grfico moderno, mediante la sustitucin de los tringulos individuales, que se hacen uso en el algoritmo de ROAM, por parches triangulares con una topologa de tipo RTIN 4-8. El bintree de tringulos original se sustituye con una estructura de datos ms eficiente basada en un quadtree de diamantes de tringulos. Cada diamante en este rbol representa un vrtice que se comparte como un vrtice de cuatro tringulos rectngulos vecinos. En contraste con el quadtree regular, todos los diamantes que no son raz del quadtree de diamantes tienen dos padres, por lo que esta estructura de datos es un Grafo Acclico Dirigido (GAD). La figura 2.34 muestra esta estructura de datos de una manera ms explicativa.

46

Figura 2.34: Demostracin de dos niveles de detalle de una malla de tringulos 4-8 en un algoritmo ROAM 2.0. Un diamante - cuatro tringulos que comparten un vrtice comn - (representado en color rojo) tiene cuatro diamantes hijos en el nivel de mayor resolucin (los de color azul), dos padres (en naranja) en un nivel de resolucin ms baja y seis hermanos (los diamantes amarillos). Los vrtices coloreados son asignados de manera apropiada a cada nodo diamante de la estructura.

Un simple refinamiento de parches geomtricos, con una cola doble, es ampliado con colas de divisin y fusin para los parches de textura. Esto significa que la geometra y la textura de los niveles de detalles se seleccionan independientemente. Hay otra cola de prioridad para la planificacin de la creacin de objetos textura, ya que sta es una operacin costosa que se realiza en cada cuadro de imagen. Un flujo bajo el esquema outof-core es soportado, utilizando una curva de llenado definida por el espacio de Sierpinski, para organizar, tanto la geometra como la textura en una unidad de almacenamiento externo. El mismo principio de la curva de llenado es usado para crear los ndices una tira de tringulos (triangle strip) que se puede usar en el cach de vrtices de la GPU eficientemente.

Figura 2.35: Ejemplo de una curva de llenado en el espacio de Sierpinski en dos niveles consecutivos de detalle de un mallado de tringulos 4-8

El refinamiento en tiempo de ejecucin, explota la coherencia temporal proporcionada por las colas de prioridad dual. Cada cuadro, las prioridades se recalculan utilizando viewfrustum culling con los parmetros de visualizacin actual y luego son equilibrados con las operaciones de divisin y fusin hasta alcanzar un cierto valor de error en el frente de cada cola. El procedimiento se puede detener cuando se alcanza una medida de error

47 especfico o un nmero de parches a desplegar definido. De esta manera, la velocidad constante de cuadros por segundo puede ser garantizada. Ventajas: o Buen control del nivel de detalle. o Maneja fcilmente las grietas. Desventajas: o Estructura de grafo compleja. o An hay un manejo pesado de los datos en CPU.

2.6.2 Geometrical Mipmapping Un mtodo muy simple (en su forma original), pero al mismo tiempo muy poderoso, es el algoritmo de Geomipmapping [17]. En tiempo de carga se construye un quadtree de cajas delimitadoras, o bounding boxes, tan grande como el mapa de alturas. Las hojas del quadtree estn vinculadas con pedazos del mapa de alturas de igual tamao, como se muestra en la figura 2.36. Esto permite cortar una gran cantidad de geometra que no es visible. Para ello, se pone a prueba el view-frustum de la cmara con las dimensiones de las cajas del quadtree utilizando un enfoque top-down. Pero an as, esto no es suficiente, si el conjunto de datos es muy detallado todava se tiene que empujar demasiada geometra a la GPU, mucha ms de la que puede manejar. Debido a esto, se utilizando un esquema de LOD con el fin de simplificar la geometra que est lejos del observador. Durante la carga, se crean versiones ms simples y menos detalladas de cada parche de alturas, llamado geomipmaps. Y slo en tiempo de ejecucin se elige la versin adecuada segn el error de pixel proyectado de cada parche. Este enfoque tiene el mismo concepto de mipmapping en texturizado.

Figura 2.36: Esquema unidimensional del quadtree usado en Geomipmapping.

En este enfoque, tambin se tiene que lidiar con las grietas entre los parches de distintos niveles de detalle. Hay varias maneras de eliminar las grietas, la ms obvia sera

48 para alterar los datos de los vrtices en los bordes de cada parche en tiempo de ejecucin. Sin embargo, esta solucin requiere una gran cantidad de procesamiento en la CPU. Una solucin muy buena y rpida es cambiar la conectividad de los vrtices del geomipmap de mayor detalle, eliminando aquellos que causan las grietas en las conexiones entre parches. En la figura 2.37 se puede ver la solucin a las grietas, eliminando los vrtices que las causan y redefiniendo la conexin de cada triangulo afectado en el borde del parche. Debido a que en la tcnica de geomipmapping se necesita de almacenar, en tiempo de carga, todos los conjuntos de datos en la memoria con todos los niveles de detalle, es slo apto para terrenos de pequeos conjuntos de datos.

(a) Grietas entre parches de distito LOD

(b) Solucin a las grietas

Figura 2.37: Manejo de grietas en geomipmapping.

Ventajas: o Implementacin fcil y sencilla. o Maneja fcilmente las grietas. Desventajas: o No puede manejar un conjunto enorme de datos.

2.6.3 Chunked LOD Chunked LOD [18] fue propuesto por Urich en SIGGRAPH 2002. El objetivo principal de este algoritmo es desplegar conjuntos de datos muy grandes en tiempo real. En la base de esta tcnica hay un rbol de parches estticos previamente procesados. Un rbol y sus nodos (llamados chunks o parches) se crean en una etapa de pre-procesamiento utilizando un conjunto de datos de alta resolucin. El parche es simplemente un mallado esttico de tringulos con las mismas propiedades, por lo que se puede desplegar con una sola llamada a la GPU. El parche en el nivel superior del rbol (raz del rbol) contiene una representacin de muy bajo detalle de todo el conjunto de datos. Los nodos hijos dividen al padre en varios fragmentos. Cada fragmento es otro rbol, donde el nodo raz es una parte del nodo en el nivel superior pero con mayor detalle. Esto se repite de forma recursiva a una profundidad arbitraria. Cuanto ms profundo se itere en el rbol, los

49 parches son de mayor detalle. En la figura 2.38 se pueden apreciar los primeros 3 niveles del rbol.

Figura 2.38: Chunked LOD. Primeros tres niveles del rbol.

Para cada bloque hay una caja delimitadora, o bounding box, y un error geomtrico mximo , asociado con el bounding box. Este error representa la mxima diferencia geomtrica de cada parche con respecto al mallado original de alto detalle. Urich, en su artculo Chunked LOD, utiliza una frmula simple para calcular este valor:

Donde L es el nivel en el rbol. Al dividir los parches para crear el rbol, se puede seguir las reglas de la estructura, que pueda ser adecuada, dependiendo de las necesidades. Una opcin muy sencilla y buena es la estructura de quadtree. En tiempo de ejecucin, a fin de decidir si se puede desplegar un parche, se calcula el error de pixel proyectado para este parche, y si el error de pixel es aceptable, entonces se despliega. Se calcula este error del boinding box y del valor del parche usando la frmula:

En donde , como se ha mencionado antes, es el error geomtrico mximo asociado al parche, D es la distancia desde la posicin de observador hasta el punto ms cercano del bounding box, y K es el factor de proyeccin, que se depende de tamao de ventana y el campo de visin de la cmara:

Chunked LOD tambin debe hacer frente a las grietas. Una forma muy fcil de manejar grietas es simplemente crear faldas alrededor del permetro de cada parche. Las faldas

50 deben ser perpendiculares al plano virtual del terreno. Su parte superior coincidir con la topologa de los vrtices del borde parche, mientras que el lado inferior puede no coincidir con nada en particular.

(a) Una grieta entre parches con distinto LOD

(b) Agregar una falda resuelve el problema

Figura 2.39: Manejo de grietas en Chunked LOD usando faldas.

Para evaluar el rbol de niveles de detalle, se recorre utilizando un enfoque top-down a partir del nodo raz. Por cada determinado parche, se calcula el error de pixel proyectado. Si el error es menor que un cierto valor de tolerancia entonces, se despliega su geometra. Si no es as, se procede a los hijos del nodo. Debido a que el mallado de los parches se encuentra en el disco duro y se deben transmitir de forma dinmica, se necesita al menos un hilo extra para poder hacerlo en paralelo. La tcnica de Chunked LOD es capaz de desplegar terrenos de cantidades enormes de datos, virtualmente infinitas, siendo una buena tcnica para manejar la geometra de un planeta, con algunas modificaciones, ya que permite desplegar slo lo que se puede ver. Ventajas: o Diseo sencillo. o Soporta virtualmente conjuntos de datos infinitos. o Se integra fcilmente con otras tcnicas. Desventajas: o El preprocesamiento no es trivial. o La implementacin requiere de programacin concurrente.

2.6.4 GPU Geometry Clipmaps Este enfoque, introducido en 2004 [19], y mejorado en 2005 [20], utiliza otra analoga del texturizado, los clipmaps. Ellos son una extensin de los mipmaps, ofrecien una aceleracin en el manejo de la textura creando mipmaps anidados de manera anillada, con el nivel 0 de mayor resolucin pero de menor tamao en el centro y creciendo exponencialmente (en potencias de 2) con mayor tamao pero menor resolucin. Si se consideran unos niveles mipmap, con crecimiento de tamao exponencial en ambas dimensiones, como en la figura 2.40 el clipmap se establece como los niveles de mipmap recortados usando un valor fijo (mostrado en amarillo) como el tamao del clipmap. Las partes restantes del recorte (mostradas en naranja) no estn presentes en la

51 memoria principal, sino almacenadas en disco, listas para ser paginadas cuando el observador se mueve.

Figura 2.40: Construccin de clipmaps mediante el recorte de mipmaps.

Los niveles de clipmaps pueden ser separados en dos grupos: clipmap pyramid, que son el grupo formado por los mipmaps originales y clipmap stack, que son el grupo de clipmaps formados por mipmaps recortados. Este concepto es usado de manera geomtrica para manejar mapas de alturas y texturas enormes, sin embargo, los niveles de clipmaps son almacenados en la memoria principal de la GPU como texturas de vrtices de dos dimensiones y la piramide de clipmaps, creada a base del mapa de alturas, es almacenada y paginada desde la memoria RAM a la GPU. Fracciones cuadradas de geometra generadas por niveles de clipmaps, con la misma resolucin de cuadrculas, son anidadas una dentro de otra, ocupando un espacio geomtrico de crecimiento exponencial, mostrado en la figura 2.41. Adicionalmente, se puede calcular la resolucin ptima de los clipmaps anidados para un tamao de pantalla y campo de visin de la cmara dados para alcanzar una cantidad de tringulos lo suficientemente buena para prevenir cualquier artefacto.

Figura 2.41: Tres clipmaps anidados de resolucin 5. Es recomendable usar valores entre 255 y 2047.

Durante el tiempo de ejecucin, se mantienen cuatro conjuntos diferentes de reas de clipmaps. En primer lugar estn las llamados regiones de corte (regiones negras cr X en la figura 2.42a) que representan la extensin de los datos de cada regin clipmap que estn presentes en la memoria de la GPU. En segundo lugar estn las regiones activas (regiones rojas ar X en la figura 2.42a) cuyo tamao del clipmap es el mismo que la regin de corte correspondiente pero centrado en la posicin actual de la cmara, y que representan los

52 nuevos lmites para las regiones de corte del cuadro actual. Los datos que faltaban (reas amarillas y anaranjadas en la figura 2.42a) se copian, si es posible, a los buffers de clipmas antes de ser visualizados. Los buffers se actualizan en un orden top-down, desde el clipmap ms grande (ms alejado del observador) hasta el clipmap ms pequeo pero de mayor resolucin (ms cercano al observador) hasta que se alcanza una cuota de tiempo dada. Las transferencias de memoria sin terminar (reas de color naranja en la figura 2.42) son dejados y, en consecuencia, las regiones activas se recortan para formar regiones de recorte (reas rojas de lneas discontinuas en la figura 2.42a) y las regiones slidas negras en la figura 2.42b). Por ltimo, las regiones que se van a desplegar, se crean como diferencias entre las regiones de corte, para un nivel actual de clipmap, y una regin de corte para el siguiente nivel ms fino (zonas coloreadas en la figura 2.42a). Al final del despliegue del cuadro, las regiones de recorte se convierten en regiones de corte para el siguiente cuadro.

(a) Regiones activas, de corte y recorte

(b) Resultado de regiones de despliegue

Figura 2.42: Regiones del Geometry Clipmaps

Por otro lado, el uso de clipmaps como un mallado anidado de distintos niveles de detalle, puede introducir discontinuidades espaciales y temporales. Para evitar la aparicin de grietas en los bordes de los clipmas, los autores optan por incorporar geometra adicional a los bordes de cada clipmap. La idea consta de formar tringulos cada tres vrtices de los bordes. Estos tringulos son denominados de rea cero (zeroarea triangles), porque si los tres vrtices son colineales, el tringulo ser de rea nula y ser descartado en el pixel shader. En el caso en el que los vrtices no sean colineales, resulta un tringulo vertical que oculta la grieta (Figura 2.43). Con respecto a los artefactos de popping, el trabajo define una zona de transicin dentro de cada clipmap donde se aplica geomorphing.

53

Figura 2.43: Tringulos utilizados para evitar las grietas en los bordes de clipmaps vecinos de distinto nivel de detalle. El tringulo ABC termina siendo de rea nula, mientras que el tringulo CDE tiene una superficie que cubre la grieta.

Finalmente, puede apreciarse que Geometry Clipmaps propone una tcnica de despliegue de terrenos innovadora, optimizando el procesamiento y el uso de recursos mediante distintas estrategias. Sin embargo, la ganancia en rendimiento es obtenida junto con una limitacin. Los mismos autores mencionan que se asume la representacin de un terreno con detalles de baja frecuencia. En el caso de poseer detalles de alta frecuencia, es probable que los mismos aparezcan de manera repentina y tarde en la visualizacin. Esta limitacin es consecuencia de la independencia del algoritmo respecto de las particularidades de los terrenos, ya que nunca tiene en cuenta la rugosidad de las superficies representadas. Tambin existe una extensin de Geometry Clipmaps para terrenos esfricos [21]. Spherical clipmaps prcticamente estn formados por la mitad de una esfera, siempre orientada hacia el observador. Estn hechas de anillos concntricos con una densidad exponencialmente creciente de paralelas entre el ecuador y el polo. La Figura 2.44 muestra cuatro de stos clipmaps. Una ventaja es que no hay que tomar casos especiales en los bordes para evitar las grietas, pero la mayor desventaja, en comparacin con la versin plana, es que los mapas de alturas, normalmente imgenes rectangulares, tienen que ser parametrizadas a coordenadas esfricas, debido a que la geometra de los clipmas se encuentra en dichas coordenadas. Adicionalmente, como la geometra es fija y se mueve con la cmara, ocurre un artefacto de odulacin causado por el muestreo de alturas interpoladas sobre la parametrizacin del mapa de alturas.

54

Figura 2.44: Mitad de una esfera de clipmaps concntricos con densidad exponencialmente creciente de paralelas.

Ventajas: o Diseo simple, sin estructuras complicadas. o Despliegue ptimo. Cantidad de tringulos constante. o Puede desplegar terrenos de tamaos enormes. Desventajas: o El popping no es completamente eliminado en terrenos de alta frecuencia. o El manejo de las texturas y el mapa de alturas es manejado en un buffer de estructura anillada que requiere de clculos complejos para su actualizacin.

2.6.5 BDAM Batched Dynamic Adaptive Meshes (BDAM) [22] emplea una topologa de parches triangulares similares a ROAM 2.0. La idea principal explota la propiedad de RTINs de que un tringulo se puede conectar a otro tringulo del mismo nivel, un nivel superior a travs de su hipotenusa o un nivel inferior del tringulo a travs de uno de sus catetos. Una triangulacin del terreno puede ser representada como un conjunto de parches triangulares de una jerarqua de bintree, simplificada en una cierta medida de error que se comparte entre posibles tringulos vecinos, de niveles del rbol adyacentes a lo largo de los bordes del parche y que se distribuye gradualmente por los bordes del parche. Esto se representa en la figura 2.45, donde las tres primeras imgenes son tres niveles del rbol binario de parches triangulares y la ltima imagen es un ejemplo de tal triangulacin. El mximo error geomtrico, para cada nivel, disminuye exponencialmente.

55

Figura 2.45: Tres niveles consecutivos de un bintree de parches del algoritmo BDAM.

Con esta organizacin, no hay que tomar en cuenta ninguna condicin adicional para llenar los vacos en la triangulacin, porque cada parche se puede conectar slo con los parches simplificados con el mismo valor de error y por lo tanto con bordes perfectamente coincidentes. La geometra interior del parche puede tener una topologa arbitraria y puede ser optimizada y refinada, de manera adaptativa, en una etapa de preprocesamiento que luego se comprime para su transferencia efectiva durante el despliegue. Una textura cuadrada de terreno se representa con un quadtree, ya que sta es una representacin ms adecuada para ello, pero con el fin de asignar mejor la textura de los nodos del quadtree, apropiados para la geometra de los nodos del bintree, el rbol binario tiene que ser dividido en dos mitades. Una jerarqua de volmenes de error, (bounding boxes) por cada nodo, se construye, la cual tambin sirve para calcular el refinamiento del parche y aplicar la prueba de view-frustum culling sobre el rbol, en pocas palabras, que denotan la distancia desde la cual ciertos parches deben ser visibles o si se encuentran fuera del campo de visin de la cmara, en cuyo caso, el parche y todos los nodos hijos quedan fuera de la triangulacin. El refinamiento es impulsado por el nivel del quadtree de textura y cuando se elige un parche de textura adecuado, se ve enva a la GPU como un objeto de textura. Luego, el refinamiento contina en ambos rboles binarios de geometra, desde los nodos que se corresponden con el nodo del parche de textura, hasta que se cumpla una medida de error geomtrica o se cumpla una cuota de tiempo. Los parches geomtricos son luego desplegados para todo el parche de textura que fue enviado a la GPU previamente. Adicionalmente, este algoritmo tiene algunas extensiones. Un soporte de datos a escala planetaria ha sido implementado, P-BDAM [23] (ver figura 2.46) que permite desplegar planetas enteros usando esta tcnica, bajo ciertas modificaciones.

56

Figura 2.46: Ejemplo de visualizacin un terreno planetario usando el algoritmo P-BDAM.

Ventajas: o Soporta grandes conjuntos de datos. o El refinamiento dependiente del error geomtrico genera muy buenos resultados visuales. o El manejo de las grietas est implcito en la solucin. Desventajas: o El popping no se elimina por completo si para cada cuadro no se alcanza el nivel de error geomtrico a tiempo. o La geometra irregular hace difcil el texturizado procedural.

2.6.6 Continuous Distance-Dependent Level of Detail (CDLOD) CDLOD [0] es una tcnica de nivel de detalle basada en GPU para desplegar terrenos basados en mapas de alturas, la cual es un refinamiento de otras tcnicas existentes con la incorporacin de nuevas ideas. Es similar al mtodo de Geometry Clipmaps porque despliega el terreno directamente del mapa de alturas pero en lugar de usar un mallado anidado, est estructurado en un quadtree de parches regulares, similar a la tcnica de Ulrich en Chunked LOD que provee una mejor distribucin de los niveles de detalle. La principal mejora que ofrece este algoritmo, respecto a las otras tcnicas es que la funcin que calcula el nivel de detalle de un parche est basada en la distancia precisa entre el observador y el terreno. Para lograr esto, una nueva tcnica para manejar los cambios, entre los niveles de detalle de diferentes parches, es implementada, y genera resultados suaves y precisos. CDLOD organiza el mapa de alturas en un quadtree, que se utiliza para seleccionar los nodos adecuados entre los distintos niveles de detalle en tiempo de ejecucin. Una

57 prueba de view-frustum culling se realiza para obtener los nodos correspondientes. El algoritmo de seleccin se lleva a cabo de tal manera, que proporciona aproximadamente la misma complejidad tringulos en pantalla independientemente de la distancia que se encuentre el observador. En la figura 2.47 se puede observar el algoritmo de seleccin de nodos en proceso.

Figura 2.47: Seleccin de nodos del quadtree. Los nodos de color oscuro estn fuera del campo de visin.

El despliegue real del terreno se realiza con las reas cubiertas por los nodos seleccionados, usando slo un parche nico de dimensiones ajustables, la lectura de las alturas y el desplazamiento de los vrtices se realiza en el vertex shader. Un parche ms detallado puede ser suavemente transformado en uno menos detallado en el mismo vertex shader, de tal modo que se puede sustituir, sin problemas, por un parche de menor resolucin cuando se encuentra fuera de rango, y viceversa. En la figura 2.48 se puede observar la transicin continua, mediante morphing de vrtices, entre distintos niveles de detalle representados por los diferentes colores.

Figura 2.48: Transicin continua entre niveles de detalle.

58 La estructura de quadtree se genera a partir del mapa de alturas como entrada. Es de profundidad constante, predeterminada por la memoria y los requisitos de granularidad. Una vez creado, el quadtree no cambia a menos que el mapa de alturas original cambie. Cada nodo tiene cuatro nodos secundarios y contiene los valores mnimo y mximo de la altura de la zona de alturas rectangular que cubre. El algoritmo provee de dos implementaciones para el quadtree, una en la que cada nodo contiene la informacin necesaria para ser desplegado, y la otra implementacin, que consume mucha menos memoria, contiene la informacin bsica en cada nodo y el resto es calculado durante el recorrido del quadtree, por lo cual es tambin ms compleja. Ventajas: o Diseo e implementacin muy sencillos. o La estructura de quadtree permite realizar clculos adicionales como colisiones. o No hay problemas con grietas y el popping se reduce con el morphing. o Se pueden modificar los parmetros de seleccin de nodos, y tambin usar un parche con mayor o menor detalle, para conseguir un balance entre el rendimiento y la calidad visual. o Soporta despliegue de terrenos de grandes conjuntos de datos. Desventajas: o Ocurren artefactos visuales en la textura de las zonas de transicin de niveles de detalle debidos al morphing.

2.7 Manejo de terrenos esfricos


Los mapas de alturas rectangulares son muy buenos para muchos propsitos, pero cuando se trata de desplegar un planeta, se necesitan superficies esfricas. Al trabajar un mallado esfrico, aparecen algunos problemas. En la siguiente seccin se cubrirn algunos algoritmos para generar superficies esfricas que puedan ser manejadas por los principales algoritmos de LOD para terrenos. Existen numerosas maneras de representar y subdividir un mallado esfrico, escoger uno adecuado para un tipo de algoritmo de LOD para terrenos es el principal reto cuando se plantea desplegar planetas. La principal cualidad que debe tener la estructura esfrica es que permita una subdivisin jerrquica, ya que todos los algoritmos de LOD se basan en estructuras de este tipo. Otra caracterstica que debe poseer es que la distribucin de vrtices, a lo largo de la superficie de la esfera, debe ser lo ms equitativamente posible para tener un terreno uniforme en todo el espacio y en cada nivel de detalle. A continuacin se describen las cuatro principales formas bsicas de representar un terreno esfrico, especialmente diseados para planetas:

59 Esfera Geogrfica: es la forma ms intuitiva de crear una esfera para terrenos planetarios. Est basada en coordenadas geogrficas de latitudes y longitudes y la generacin de sus vrtices proviene de una frmula trigonomtrica, que transforma los vrtices de coordenadas esfricas a coordenadas cartesianas. En la figura 2.49 se puede apreciar el proceso en el que en cada paso se agrega ms detalle a la esfera.

Figura 2.49: Subdivisin de una esfera geogrfica. La distribucin de puntos es conectada con tringulos.

El principal problema que tiene esta implementacin es que la cantidad de vrtices en los polos no es proporcional al resto de la superficie, es decir, la distribucin no es uniforme, lo cual puede causar distorcin al mapear las alturas o las texturas cada zona. Adicionalmente, ningn algoritmo de LOD se acopla bien en esta estructura ya que no representa una estructura jerrquica intuitiva y no es posible definir una raz para dicha estructura. Icosaedro: es un poliedro de veinte caras, convexo y cncavo, formado por tringulos equilateros de igual rea. Si se subdivide un icosaedro de manera recursiva, en el que cada cara es particionada en tres tringulos equilateros, se puede obtener lo que se denomina una geoesfera. Esta estructura genera una esfera con vrtices uniformemente distribuidos, perfecta para algoritmos como ROAM 2.0 y P-BDAM si cada uno de los tringulos es dividido por una de sus bisectrices formando tringulos rectngulos. En la siguiente figura se puede observar la formacin de una esfera a partir de un icosaedro mediante subdivisiones recursivas de cada cara.

Figura 2.50: Formacin de una esfera mediante las tres primeras subdivisiones recursivas.

60 Un problema con esta estructura es definir la raz del bintree. Una solucin es definir un bosque de veinte bintrees y manejar cada uno por separado, tomando en cuenta las conexiones con rboles vecinos. HEALPix: es el acronimo de Hierarchical Equal Area isoLatitude Pixelisation (requiere traduccin) y se refiere a una proyeccin de mapeo de texturas sobre una esfera. Es una clase general de proyeccin esfrica, que comparte propiedades claves de la proyeccin cilndrica para las regiones ecuatoriales mientras que para los polos la proyeccin es planar, subdividida en cuatro tringulos iguales. La estructura para generar un mallado esfrico difiere de su concepto para mapear la textura. HEALPix [24] descompone la esfera en doce parches de base cuadrilteros curvilneos de igual rea. Estos se subdividen uniformemente como sea necesario para formar una malla que puede representar los datos de un mapa de alturas. En comparacin con otros mtodos de representacin esfrica, que utilizan sistemas de coordenadas implcitas, la proyeccin HEALPix se da en una forma cerrada. Esta propiedad permite la proyeccin eficiente, sobre la marcha, de los mapas de altura del espacio paramtrico al espacio euclidiano en el vertex shader. En la figura 2.51 se puede apreciar la generacin de una esfra basada en la parametrizacin de vrtices con una estructura HEALPix.

Figura 2.51: Subdivisin del HEALPix para formar una esfera.

El resultado muestra una esfera con vrtices uniformemente distribuidos y se pueden apreciar las estructuras cuadrilteras de las que est formada. Si se intenta generar un slido de caras planas con cada uno de dichos cuadrilteros, sera imposible, por lo cual la formacin de cada uno debe ser realizada mediante la parametrizacin del HEALPix, la cual es un poco compleja. Sin embargo, con propsito de definir un algoritmo de LOD se puede usar cada cuadriltero como un quadtree deformado y manejar todo el planeta como un bosque o grupo de doce rboles de manera independiente. El mayor inconveniente de esta aproximacin es que al poseer doce rboles como base del planeta, puede ser difcil resolver el problema de conexin entre cuadrilteros vecinos y adems hay que parametrizar todos los mapas de alturas y texturas para trabajar con esta estructura.

61 Exploded Cube: esta tcnica consiste en explotar un cubo subdividido. El enfoque ingenuo consiste en normalizar cada vrtice del cubo y luego escalar por el radio del planeta. Este enfoque puede generar una distribucin de vrtices no muy uniforme hacia el centro de cada lado del cubo, mientras que en las esquinas hay una mayor densidad de los mismos. Al mismo tiempo los vrtices pierden precisin y el mallado se forma de manera irregular, incluso solapando las posiciones de varios vrtices en una sola posicin. Philip Nowell [1] propone una tcnica que genera una esfera, a partir de un cubo subdividido, mediante la siguiente transformacin:

En la figura 2.52 se puede apreciar la transformacin de un cubo subdividido a una esfera usando esta tcnica, logrando una distribucin casi uniforme de vrtices. ste mtodo es uno de los ms usados para representar la geometra de un terreno a escala planetaria, ya que al ser slo seis caras, cada una se puede representar como un quadtree, resultando en una implementacin sencilla y que visualmente genera una buena calidad, ya que la distribucin de los nodos del quadtree es muy uniforme.

Figura 2.52: Cubo transformado a una esfera.

El principal problema de usar un cubo es tomar en cuenta las caras vecinas para evitar grietas, pero existen numerosas soluciones, otro problema son las zonas en las esquinas, los parches dejan de ser cuadrados y tienden a convertirse en diamantes, lo cual puede generar artefactos de deformacin tanto en la geometra como en la textura.

62

2.8 Precisin
En un mundo virtual, por un momento el espectador puede estar viendo el planeta desde una cierta distancia, como por ejemplo desde el espacio, y al momento siguiente, el espectador podr acercarse a un valle, una montaa o a nivel del suelo. Al mismo tiempo, los datos del planeta deben ser copiados en memoria y ser representados con precisin. La libertad de exploracin y la capacidad de visualizar un espacio enorme en tiempo real es lo que le da a la visualizacin de planetas su mayor cualidad. Estos factores conducen a una serie de retos de representacin interesantes y nicos, dnde el principal problema es la precisin. Dado el gran tamao de un terreno a escala planetaria, como por ejemplo la Tierra, y la capacidad para que los usuarios vean el mundo como un todo o acercar a niveles del suelo, los planetas o mundos virtuales, requieren una gran distancia de la visin y poder manejar las grandes coordenadas de su geometra. Si se trata de desplegar una escena masiva utilizando el enfoque ingenuo, donde el view-frustum es definido por un near plane muy cercano a la cmara y un far plane muy distante, y adems, se usan coordenadas de nmeros grandes con precisin simple de punto flotante, conlleva a dos artefactos conocidos como jittering y z-fighting. Ambos artefactos son an ms notables cuando el espectador se mueve. En la siguiente seccin se explican las tcnicas [25] para resolver cada artefacto. 2.8.1 Jittering La mayora de las GPUs de hoy en da slo soportan valores de punto flotante de 32 bits, lo que no proporciona suficiente precisin para manipular grandes posiciones en terrenos de escala planetaria. Jitter o inquietud en los vrtices, se produce cuando el observador hace zoom, gira o se mueve en la escena, entonces los polgonos comienzan a rebotar hacia atrs y adelante. La mejor solucin para este problema es utilizar el mtodo "Rendering Relative to Eye Using the GPU" descrito en la parte II de [25]. Este mtodo, bsicamente, consiste en fijar todas las posiciones utilizando la precisin doble de punto flotante (64 bits) de la CPU para los parches, posicin de la cmara y otros objetos del mundo. Luego la matriz de proyeccin se centra en el observador, mediante el establecimiento de su traslacin a (0,0,0)T y finalmente las posiciones antes definidas con precisin doble, son codificados en una representacin de punto fijo usando dos flotantes de precisin simple, low y high por cada coordenada de cada vrtice. La codificacin que genera el mejor resultado respecto a la precisin es el mtodo conocido como DSFUN90, contenido en la librera de Fortran, que provee de rutinas para

63 realizar aritmtica de doble precisin usando slo precisin simple, la cual permite tener aproximadamente 15 dgitos decimales de exactitud. La codificacin funciona de la siguiente manera:
double value = // . . . float high = ( float ) value ; float low = ( float ) ( value high ) ;

Posteriormente, al procesar los vrtices en la GPU, se transforman a precisin simple mediante una aritmtica un poco ms compleja pero el resultado elimina por completo el artefacto de jittering. Otras maneras de resolver el problema pueden ser ideadas, usar una implementacin propia para definir las posiciones con mucha mejor precisin, pero puede resultar ms complejo. La idea principal es mantener la solucin simple. 2.8.2 Z-Fighting El buffer de profundidad (Z-buffer) es una parte de la memoria de la GPU que se encarga de gestionar las coordenadas de profundidad de los grficos 3D que se quieren desplegar. El clculo se realiza en hardware y en dicho clculo se decide qu elementos se dibujan y cules no. Cuando un objeto se dibuja, la profundidad del pixel generado se almacena en el Z-buffer, si algn otro objeto de la escena se despliega en el mismo pixel, la GPU compara las dos profundidades y elige la ms cercana al observador, descartando el otro. La granularidad de un Z-buffer tiene una gran influencia en la calidad de la escena, por ejemplo, un buffer de 16 bits puede producir el artefacto de z-fighting, que ocurre cuando dos objetos estn muy prximos, el buffer de profundidad falla al encontrar que los pixeles de ambos objetos ocupan la misma profundidad, por lo que ocurre un solapamiento de las imgenes de ambos objetos, resultando en una representacin errnea de la escena. Un Z-buffer de 32 bits se comporta mucho mejor ya que posee ms precisin, pero cuando se despliega una escena enorme, como un terreno a escala planetaria, un Z-buffer de 32 bits no es suficiente, incluso, si se pudiera tener un z-buffer de precisin doble, no importa que valores se definan para el near plane y far plane del view-frustum, siempre va a ocurrir el artefacto, aunque en menor escala. Debido a que el clculo es hecho en el hardware de la GPU, es imposible emular un buffer de mayor precisin, pero se puede usar una tcnica descrita en [25] [26] que permite eliminar por completo el artefacto de z-fighting de una manera sencilla y fcil de implementar, con la nica desventaja de que todos los objetos de la escena deben ser desplegados usando el mismo buffer, lo cual puede parecer innecesario para objetos independientes del terreno, como aviones, rboles, animales, edificios, etc.

64 La tcnica se conoce como Logarithmic Depth Buffer o Buffer de Profundidad Logartmico. Este buffer mejora la precisin del buffer para objetos distantes mediante el uso de una distribucin logartmica, la cual encaja perfecta con los algoritmos de LOD para terrenos. La implementacin es simple, slo requiere de la modificacin del valor de profundidad luego de que ha sido transformado por la matriz de proyeccin, mediante la siguiente ecuacin:

En donde la constante C reemplaza el valor del near plane (znear) y define la resolucin del buffer cerca de la cmara. El valor de C cubre un rango arbitrario mayor que cero, donde este valor cercano al cero aumenta la precisin en la distancia pero reduce la precisin cerca del observador.

2.9 Aspectos adicionales


Al principio de este documento se hizo nfasis en que, la representacin de terrenos a escala planetaria y mundos virtuales, son inspirados del mundo real. Cuando se despliega un planeta en tiempo real, tambin se quiere lograr un efecto de realismo en la imagen final de cada cuadro generado. El espectador debe sentirse que est explorando un mundo real, aunque su generacin sea artificial. Existen numerosos aspectos que se pueden agregar a la escena final cuando se despliega un planeta, que le dan una apariencia autntica y mayor naturalidad a que si slo se muestra el terreno y sus texturas. Entre los numerosos aspectos que pueden simularse dentro y fuera de un planeta, se pueden mencionar los ros, bosques, ciudades, ocanos, anillos, lunas, estrellas, entre otras muchas caractersticas naturales que pueden ser observadas en el mundo real. En la siguiente seccin se cubrirn algunas tcnicas, sin explicar en detalle su implementacin, que pueden ser implementadas para agregar elementos naturales al planeta. 2.9.1 Ocanos La animacin y el despliegue realista del ocano es un aspecto importante para simuladores, pelculas y videojuegos. Por naturaleza, el mar es un problema difcil de simular en la computacin grfica, ya que es un sistema dinmico, que combina secuencias de olas en todas las escalas, en un rango de kilmetros hasta milmetros. Peor an, el ocano es generalmente visto desde varias distancias, o incluso muy cerca de la lnea del horizonte, que dado al problema de ser un sistema en constante movimiento a

65 diferentes escalas, genera artefactos de aliasing. La iluminacin proviene de fuentes de luz natural, como el sol, que tambin es dinmico. Eric Bruneton en [27] propone un nuevo algoritmo para el modelado, animacin, iluminacin y despliegue de los ocanos, en tiempo real, a todas las escalas y para todas las distancias de visin. Este algoritmo se basa en una representacin jerrquica, combinando la geometra, las normales y la BRDF. Para cada distancia de observacin, se calcula una versin simplificada de la geometra, y se codifican los datos que faltan dentro de la normal y la BRDF, dependiendo del nivel de detalle requerido. Luego, se utiliza esta representacin jerrquica para la iluminacin y despliegue del ocano. El algoritmo se ejecuta en tiempo real, y produce imgenes y animaciones muy realistas. En la siguiente figura se puede observar cmo el algoritmo puede desplegar ocanos con una calidad muy buena y de aspecto realista.

Figura 2.53: Despliegue de ocanos usando Real-time Realistic Ocean Lighting using Seamless Transitions from Geometry to BRDF

2.9.2 Atmsfera Cuando se visualiza un planeta, una parte importante es la atmsfera. Existen numerosos algoritmos que pueden aadir el efecto de la atmsfera a un planeta, la mayora se basa en usar un gradiente de color para calcular el color final dependiendo de la altura de la cmara respecto a la superficie del planeta. En [28] se propone una tcnica usando el mtodo de ray tracing en GPU, dentro de un volumen definido como una capa atmosfrica. El mtodo consiste en trazar un rayo por cada pixel de la imagen que atraviesa el volumen de la atmsfera, acumulando color dependiendo de la densidad de la atmsfera y la posicin de la cmara. La implementacin es muy simple y puede realizarse, en un proceso separado luego de desplegar el planeta, haciendo uso de vertex shader y un fragment shader con instrucciones sencillas. En la siguiente figura se puede observar el resultado de agregar el detalle de la atmsfera a un planeta generado.

66

Figura 2.54: Visualizacin de la atmsfera sobre un planeta virtual.

2.9.3 Nubes Aunque existen varias tcnicas para desplegar nubes sobre un terreno, cuando se trata de planetas, las nubes pueden ser un problema difcil de resolver, ya que su representacin es un volumen de enormes dimensiones que encierra por completo el planeta. Las nubes, al igual que los ocanos, es un sistema dinmico, tienen diferentes formas y presentan un reto completamente aparte, al nivel de un trabajo de grado independiente. Para la propuesta presentada en este trabajo, este aspecto de las nubes ser tomado en consideracin pero usando una implementacin simple, que aunque no es muy realista, puede generar buenos resultados. La publicacin ms reciente, y que genera los mejores resultados, es tambin propuesta por Eric Bruneton [29] en la que plantea un algoritmo para la simulacin en tiempo real de volmenes de nubes y su iluminacin, basado en un algoritmo de ray tracing en GPU similar al descrito en la seccin anterior para visualizar la atmsfera del planeta. En la siguiente figura se puede observar algunos resultados de nubes desplegadas con este algoritmo.

Figura 2.55: Visualizacin de nubes sobre un terreno planetario usando el algoritmo Interactive multiple anisotropic scattering in clouds

67 2.9.4 Anillos planetarios Un anillo planetario es un disco con un radio interior y un radio exterior. El disco utiliza una textura 1D donde la coordenada de textura viene dada por la distancia desde el centro del planeta, donde la coordenada es 0 si el vrtice se encuentra en radio interno y es 1 si se encuentra en el radio externo. La textura anillo puede se crea utilizando la interpolacin de splines en colores generados aleatoriamente con una funcin de ruido en 1D, como por ejemplo Perlin Noise y la interpolacin genera valores transparentes entre un color y otro. No existe un mtodo definido para desplegar anillos en planetas, pero en [30] se decribe un mtodo sencillo y prctico que permite agregar este detalle a los planetas generados. Consiste en desplegar el anillo con una tcnica geomtrica en el cual se define el anillo como una tira de tringulos de pocos polgonos pero que puede ser recortado en el fragment shader para dar una apariencia perfectamente circular. Tambin se propone una tcnica para dar detalle de partculas cuando el observador se acerca al anillo y adicionalmente se agrega iluminacin, por ejemplo, la sombra del planeta sobre el anillo. En la siguiente figura se muestra un planeta generado con un anillo que lo rodea.

Figura 2.56: Visualizacin de anillos en un planeta generado.

2.9.5 Campo de estrellas en el espacio Cuando de visualiza un planeta, es importante tomar en cuenta el espacio en donde se encuentra. Un planeta normalmente pertenece por definicin a un sistema solar, dichos sistemas se encuentran infinidades de veces por todo el universo. Al momento de desplegar un planeta visto desde el espacio, o incluso a nivel de la superficie, se pueden observar las estrellas alrededor de todo el espacio. Simular todo un universo no es el propsito de este trabajo, pero agregar el detalle de un campo de estrellas, aade

68 realismo al resultado final. Una vez ms, no hay una tcnica concreta para este fin, pero existen mecanismos que sirven para simular un espacio infinito alrededor del observador, esta tcnica se denomina skybox. La tcnica de skybox logra hacer que la escena se vea mucho ms grande e impresionante mediante el envolvimiento del observador, en una textura continua y sin divisiones notables, que rodea la cmara en 360 grados. La textura, en este caso, es una imagen que muestra innumerables estrellas, galaxias y nebulosas de un sistema estelar cualquiera y puede ser generada con aplicaciones especiales. En la figura 2.57 se puede apreciar un planeta generado, visualizado desde el espacio con un campo de estrellas envolvindolo.

Figura 2.57: Tcnica de Skybox usada para visualizar el espacio.

69

Captulo 3 Propuesta de Tesis


3.1 Planteamiento del problema
Generacin y visualizacin de terrenos es una parte muy importante de la computacin grfica. Por ejemplo, se pueden ver varios modelos de terreno en innumerables aplicaciones, como lo son los juegos de video, turismo virtual, planificacin de ciudades, entrenamiento militar, simulaciones de vuelo, etc. En la mayora de los casos, el objetivo deseado es desplegar un terreno con caractersticas realistas y naturales, ya sea que provenga de datos reales o generados. Si se considera la visualizacin de un modelo de terreno a escala planetaria, existen numerosos factores que, como fueron descritos anteriormente, definen cada parte de la topologa de un planeta a diferentes escalas. Lo primero que se debe tomar en cuenta es el manejo y despliegue de la geometra, como principal objetivo para este trabajo. Tambin debe ser posible manejar la textura y niveles de detalle de la geometra mediante alguno de los algoritmos de LOD mencionados en la seccin anterior. Adicionalmente se debe poder generar el planeta entero a partir de algoritmos de ruido y desplegarlo, tanto con mapas de alturas reales como generados por el usuario. Para que el planeta generado pueda ser observado con un buen nivel de realismo, se debe cuidar la correcta distribucin de los continentes e islas, la correcta distribucin de montaas, valles y llanuras, y hacer nfasis en la coloracin y texturizado de todas y cada una de las diferentes estructuras que pueden existir o ser generadas en un mundo virtual. Actualmente el hardware ofrece la capacidad de desplegar grandes volmenes de geometra, como la encontrada cuando se despliega un planeta, y se puede explotar al mximo las capacidades de las GPU con el propsito expuesto. Segn el enfoque del uso y explotacin de la GPU para visualizar planetas, se propone implementar un framework que trabaje bajo un enfoque mixto, entre el uso de mapas de alturas fijos (obtenidos de datos reales o generados) y generacin procedural, mediante el uso de algoritmos fractales, para recrear los detalles a menores escalas, y en esta misma lnea de trabajo, se propone implementar una aplicacin que sea capaz de generar y editar planetas para su posterior visualizacin.

70

3.2 Objetivos
3.2.1 Objetivo general Disear e implementar un framework que permita la visualizacin de terrenos a escala planetaria y una aplicacin que proporcione de herramientas para generar y editar planetas. 3.2.2 Objetivos especficos Disear un algoritmo que maneje la geometra del planeta basado en la subdivisin de un cubo [1] como se describe en la seccin 2.7, usando la estructura de quadtree para cada cara del mismo. Implementar el algoritmo de CDLOD [0] en cada cara del cubo para el manejo del nivel de detalle de la geometra del planeta. Implementar las propuestas de eliminacin de artefactos de jitter y z-fighting descritas en la seccin 2.8. Implementar una estructura de quadtree para el manejo de los mapas de alturas. Implementar una estructura de quadtree para el manejo de las texturas en planetas basados en datos reales. Implementar un algoritmo, basado en ruido fractal, que aada detalle tanto a la geometra de la superficie como a la textura utilizada. Implementar un algoritmo que permita convertir, un mapa de alturas o una textura en coordenadas esfricas, a 6 imgenes en coordenadas cartesianas, una por cada cara del cubo. Implementar un algoritmo que permita generar la topologa de la superficie de un planeta mediante algoritmos de ruido fractal. Implementar un algoritmo que permita al usuario editar puntualmente caractersticas del terreno del planeta. Implementar un algoritmo que permita aplicar texturas procedurales al planeta, dependiendo del tipo de terreno y sus caractersticas. Implementar las propuestas descritas en la seccin 2.9 [24][25][26][27][30] para la visualizacin de los ocanos, atmsfera, nubes y anillos de un planeta. Permitir la importacin de modelos 3D dentro de la escena del planeta. Permitir un clculo de colisin bsica con el terreno del planeta. Permitir la navegacin del planeta a diferentes escalas y en diferentes velocidades

71

3.3 Propuesta
Se propone el desarrollo de un framework implementado en C/C++ que permita la visualizacin de terrenos a escala planetaria junto a una aplicacin que proporcione al usuario de herramientas para la generacin y edicin de planetas. El framework debe ser capaz de desplegar un planeta generado por la aplicacin, usando el mtodo de CDLOD para el nivel de detalle y las diferentes tcnicas propuestas para dar realismo a la escena. La aplicacin debe ser capaz de proveer al usuario de mecanismos que le permitan generar un planeta entero, tomando en cuenta tres distintas escalas, como lo son: continentes e islas para la escala macro, montaas, valles y llanuras para la escala media y erosin y tipo de terreno (arenoso, dunas, rocoso, etc) para la escala micro. Adicionalmente debe contar con un mdulo que permita al usuario determinar los diferentes tipos de topologas y caractersticas de cada una de las escalas, as como las texturas a utilizar y la edicin de los parmetros para las funciones de ruido a ser utilizadas en cada escala, tanto para el detalle de la geometra como de la textura. Para poder soportar el uso de datos reales, la aplicacin de edicin y generacin de planetas, debe proveer un mdulo que permita al usuario importar una imagen de mapa de alturas, con su respectiva textura, y convertirlo en el formato adecuado para poder ser desplegado por el framework. Las imgenes que se proponen para ser soportadas como datos reales de entrada, son proporcionadas por la NASA [31] y se encuentran disponibles gratuitamente. stas imgenes estn en coordenadas esfricas de la forma 2:1 y se presentan en diferentes resoluciones. Por ltimo, se propone agregar los aspectos adicionales propuestos en la seccin 2.9 para dar mayor realismo a la escena. stas caractersticas podrn ser configuradas en el editor de planetas por el usuario.

3.4 Metodologa
El desarrollo de esta propuesta se basar en el paradigma de la programacin orientada a objetos. El hardware requerido para ella consistir en una PC convencional moderna con una tarjeta grfica que soporte OpenGL versin 3.0 en adelante y GLSL versin 1.20 con al menos 256MB de video para planetas completamente procedurales y 1GB de video para planetas basados en datos reales. El hardware base a ser usado para la implementacin consiste de una laptop MSI GT60 con las siguientes especificaciones: CPU: Intel Core i7 3630QM @2.4Ghz RAM: 12GB DDR3 GPU: NVIDIA Geforce GTX 675M 2GB VRAM

72 Por otro lado, se requiere el siguiente software para el desarrollo: Windows 7 como Sistema Operativo. Microsoft Visual Studio 2010 como ambiente de trabajo. Crazy Eddie's GUI (CEGUI) para la interfaz grfica dentro de la aplicacin. FreeGLUT 2.8.1 como librera de despliegue de objetos 3D sobre OpenGL 3.X. GLEW 1.9.0 como librera de manejo de extensiones y shaders de OpenGL. Open Asset Import Library 2.0 para la carga de modelos 3D adicionales. FreeImage 3.15.4 como librera para la carga de imgenes. Librera GLMath 0.6.4 para el uso de funciones matemticas.

3.5 Pruebas a realizar


Para poder evaluar los resultados del rendimiento del framework, se propone disear un grupo de pruebas mediante las cuales se puede medir dicho rendimiento en funcin de los cuadros por segundo desplegados frente a la calidad visual. Se implementar una aplicacin demo interactiva que despliegue un conjunto de planetas con diferentes caractersticas. De manera individual. Se implementar una aplicacin no interactiva que despliegue un conjunto de planetas, tambin de manera individual, pero que recorra el planeta, de manera automtica, en diferentes escalas.

En cada prueba se tomarn en cuenta los parmetros de detalle del algoritmo de CDLOD a implementar para poder comparar entre las distintas distancias, y niveles de detalle, resolucin del parche, resolucin de la pantalla, tamao de las texturas y si se usa generacin procedural de detalles a la geometra y/o texturas.

73

Bibliografa
[0] Filip Strugar. Continuous Distance-Dependent Level of Detail for Rendering Heightmaps (CDLOD). Journal of Graphics, GPU and Game Tools, 11 de Julio de 2010. [1] Philip Nowell. Mapping a Cube to a Sphere [en lnea]. [Fecha de consulta: 03 de Febrero de 2013]. Disponible en: http://mathproofs.blogspot.com/2005/07/mappingcube-to-sphere.html [2] J. Van Pabst y H. Jense, Dynamic Terrain Generation Based on Multifractal Techniques. [3] Hugo Elias. Spherical Landscapes [en lnea]. [Fecha de consulta: 15 de marzo de 2013]. Disponible en: http://freespace.virgin.net/hugo.elias/models/m_landsp.htm [4] Fractal Geometry [en lnea]. [Fecha de consulta: 15 de marzo de 2013]. Disponible en: http://homepages.uel.ac.uk/4511r/Fractals.html [5] Hugo Elias. Perlin Noise [en lnea]. [Fecha de consulta: 15 de marzo de 2013]. Disponible en: http://freespace.virgin.net/hugo.elias/models/m_perlin.htm [6] Stefan Gustavson. Simplex Noise Demystified. 2005. [7] Carl-Johan Rosn. Cell Noise and Processing. 2006. [8] Steve Worley. A Cellular Texture Basis Function. [9] Jacob Olsen. Realtime Procedural Terrain Generation: Realtime Synthesis of Eroded Terrain for Use in Computer Games. 2004. [10] David S. Ebert, F. Kenton Musgrave, Darwyn Peachey, Ken Perlin y Steven Worley. Texturing and Modeling: A Procedural Approach (Tercera Edicin). Morgan Kaufmann Publishers, 2003. [11] Heinz-Otto Peitgen, Michael Fielding Barnsley y Dietmar Saupe. The Science Of Fractal Images. Springer Verlag, 1988. [12] Procedural Texturing [en lnea]. [Fecha de consulta: 15 de marzo de 2013]. Disponible en: http://wiki.flightgear.org/Procedural_Texturing [13] Johan Andersson. Terrain Rendering in Frostbite Using Procedural Shader Splatting. DICE, 2013. [14] Shawn Hargreaves. Detail Textures [en lnea]. [Fecha de consulta: 15 de marzo de 2013]. Disponible en: http://blogs.msdn.com/b/shawnhar/archive/2008/11/03/detailtextures.aspx [15] Lok M. Hwa, Mark A. Duchaineau y Kenneth I. Joy. Real-time optimal adaptation for planetary geometry and texture: 4-8 tile hierarchies. IEEE Transactions on Visualization and Computer Graphics, 2005. [16] Mark. A. Duchaineau, M. Wolinsky, D. E. Sigeti, M. C. Miller, M. B. Mineev-Weinstein y C. Aldrich. ROAMing terrain: Real-time optimally adapting meshes. IEEE Visualization, 1997. [17] Willem H. de Boer. Fast Terrain Rendering Using Geometrical MipMapping. E-mersion Project, Octubre 2000. [18] Thatcher Urlich. Rendering Massive Terrains Using Chunked Level of Detail Control. SIGGRAPH 2002 Course Notes. San Antonio, TX: ACM, 2002. [19] Frank Losasso y Huges Hoppe. Geometry Clipmaps: Terrain Rendering Using Nested Regular Grids. International Conference on Computer Graphics and Interactive Techniques, ACM New York, NY, EEUU, 2004.

74 [20] Arul Asirvatham y Huges Hoppe. Terrain rendering using GPU-based geometry clipmaps. GPU Gems, vol. 2, no. 2, 2005. [21] M. Clasen y H. C. Hege. Terrain rendering using spherical clipmaps. Eurographics IEEEVGTC Symposium on Visualization, 2006. [22] P. Cignoni, F. Ganovelli, E. Gobbetti, F. Marton, F. Ponchio y R. Scopigno. BDAM batched dynamic adaptive meshes for high performance terrain visualization. EUROGRAPHICS 2003, vol. 22, 2003. [23] P. Cignoni, F. Ganovelli, E. Gobbetti, F. Marton, F. Ponchio y R. Scopigno. Planet-sized batched dynamic adaptive meshes (P-BDAM). IEEE Transactions on Ultrasonics, Ferroelectrics and Frequency Control, 2003. [24] Rolf Westerteiger, Andreas Gerndt y Bernd Hamann. Spherical Terrain Rendering using the hierarchical HEALPix grid. 2011. [25] Patrick Cozzi, Kevin Ring, 3D Engine Design for Virtual Globes, CRC Press, 2011. [26] Brano Kemen. Maximizing Depth Buffer Range and Precision [en lnea]. [Fecha de consutla: 20 de junio de 2013]. Disponible en: http://outerra.blogspot.com/2012/11/maximizing-depth-buffer-range-and.html [27] Eric Bruneton, Fabrice Neyret y Nicolas Holzschuch. Real-time Realistic Ocean Lighting using Seamless Transitions from Geometry to BRDF. EUROGRAPHICS, vol. 29, no. 2, 2010. [28] Sean ONeil. Chapter 16: Accurate Atmospheric Scattering [en lnea]. [Fecha de consulta: 21 de junio de 2013]. Disponible en: http://http.developer.nvidia.com/GPUGems2/gpugems2_chapter16.html [29] A. Bouthors, F. Neyret, N. Max, E. Bruneton y C. Crassin. Interactive multiple anisotropic scattering in clouds. EVASION-LJK. [30] John Whigham. Planetary Rings [en lnea]. [Fecha de consulta: 21 de junio de 2013]. Disponible en: http://johnwhigham.blogspot.com/2011/11/planetary-rings.html