El documento describe un sistema para simular y dibujar grandes multitudes en tiempo real utilizando el procesador gráfico (GPU). Se describen diferentes arquitecturas para simular comportamientos de agentes, incluyendo probabilística, jerárquica y por capas. El sistema permite especificar comportamientos mediante máquinas de estado finito representadas en formato XML y traducirlas automáticamente a shaders para su ejecución en el GPU.

1. isaac rudomin rudomin@itesm.mx octubre 2008

2. Se describe un sistema para simular y dibujar megamultitudes en tiempo real utilizando el procesador gráfico. r a c t A b s t

3. S i m u l a c i ó n d e m u l t i t u d e s La simulación de multitudes de personajes basados en agentes tiene aplicaciones varias: arquitectura y urbanismo, mitigación de desastres, cine y videojuegos, simulación biológica Agenda: Simulación en el CPU Simulación en el GPU Trabajo futuro

4. Basada en máquinas de estado finito Scripting XML e imagenes auxiliares Extendida a otras arquitecturas, probabilística, jerárquica, por capas S i m u l a c i ó n en el CPU

5. Scripts que contienen: Comportamientos atómicos Estados Transiciones Condicionales Variables Internas Tipos de agentes Comportamientos grupales <agenttype name=&quot;boid&quot;> <var name=&quot;closest&quot; type=&quot;user&quot; /> <state name=&quot;init&quot; initial=&quot;true&quot;> <switch> <condition type=&quot;close&quot; class=&quot;user&quot;> <set var=&quot;closest&quot; /> <transition to=&quot;follow_me&quot; /> </condition> </switch> <behavior type=&quot;turn&quot; style=&quot;run&quot; angle=&quot;10&quot; time=&quot;0.5&quot; /> </state> <state name=&quot;follow_me&quot;> <behavior type=&quot;follow&quot; style=&quot;run&quot; target=&quot;closest&quot; speed=&quot;12&quot; time=&quot;0.25&quot; /> </state> </agenttype> <group name=&quot;flock&quot; x=&quot;-20&quot; y=&quot;-20&quot; radius=&quot;40&quot;> <model type=&quot;boid&quot; size=&quot;8&quot; src=&quot;mon.md2&quot; tex=&quot;mon.bmp&quot; /> </group> Follow me: follow User Close Scripts FSM en XML Init: turn

6. Mapas de mundo Mapas de agente Imagenes auxiliares

7. Las FSMs son predecibles y regulares. Un FSM probabilistico tiene probabilidades asociadas a cada transición <probset cumulative=&quot;true&quot;> <option prob=&quot;25%&quot;> <behavior type=&quot;turn&quot; style=&quot;run&quot; angle=&quot;20&quot; time=&quot;0.5&quot;/> </option> <option prob=&quot;25%&quot;> <behavior type=&quot;turn&quot; style=&quot;run&quot; angle=&quot;-20&quot; time=&quot;0.5&quot;/> </option> <default> <behavior type=&quot;go&quot; style=&quot;run&quot; dist=&quot;5&quot; time=&quot;0.5&quot; /> </default> </probset> Arquitectura probabilística

8. Arquitectura jerárquica <procedure name=&quot;proc1&quot;> <var name=&quot;one“ type=&quot;agent_one&quot; /> <state name=&quot;start“ initial=&quot;true&quot;> ... list of statements <return /> </state> </procedure> Las FSMs jerárquicas llaman a otras sub FSMs para poder realizar tareas comunes, logrando organizar mejor el código e inclusive definiciones recursivas <agenttype name=&quot;agent_two&quot;> <var name=&quot;v1&quot; type=&quot;agent_one&quot; /> <state name=&quot;init &quot;initial=&quot;true&quot;> ... list of statements <call proc=&quot;proc1&quot;> <param name=&quot;one” value=&quot;v1“> </call> ... list of statements </state> </agenttype>

9. En una arquitectura por capas cada capa contiene una tarea independiente que produce una acción a partir de las entradas del ambiente. Capas superiores pueden examinar datos de capas inferiores e inhibir su salida. Arquitecturas por capas <layerset> <layer name=&quot;bottom&quot;> <takeover cond=&quot;farther&quot; class=&quot;obj1&quot; range=&quot;2&quot; /> <takeover cond=&quot;closer&quot; class=&quot;obj2&quot; range=&quot;5&quot; /> ... list of statements </layer> <layer name=&quot;top&quot;> <takeover cond=&quot;always&quot; /> ... list of statements </layer> </layerset>

10. Problema clásico resuelto mediante un modelo de capas. Un grupo de vehiculos se mandan a un planeta lejano a recolectar muestras pero sin conocer el ambiente. Mars Explorers 4. Explore 3. Collect samples 2. Take samples to the ship 1. Avoid obstacles

11. Personajes que compran bebidas, amas de casa con listas de compras aleatorias, ladrones. Vas al super o a la comer?

12. Pieza interactiva con diversas escenas y personajes Crowds

13. Simulación en el CPU es versatil pues el uso de XML para especificar diversas arquitecturas (probabilística, jerárquica y por capas) asi como diversas combinaciones nos da una poderosa herramienta para simular una variedad de comportamientos de personajes en distintas situaciones. Conclusiones CPU

14. Basada en máquinas de estado finito Scripting XML e imagenes auxiliares S i m u l a c i ó n en el GPU

15. El GPU se ha convertido en últimas fechas en un procesador extremamente flexible y poderoso Programable Precisición Poder Bajos precios P o r q u e G P U ?

16. Simular y dibujar megamultitudes exige grán poder de cómputo. El actual estado del arte: [Reynolds 2006]:10K personajes con Playstation3. [Rudomin et al. 2006]: 100K to 1M personajes sencillos simulados y dibujados en el GPU . [DeSouza et al. 2007]: simulación de agentes a megaescala en el GPU para simulaciones biológicas [ Shopf et al. 2008]: 60K personajes detallados simulados en el GPU mas nuevo de ATI utilizando subdivisión por hardware Estado del arte en simulación de grandes multitudes

17. Simular y dibujar muchos personajes se vuelve posible haciendo: Simulación de comportamiento en el GPU : Autómatas de estado finito , implementados en GLSL Un método para especificar scripts en XML y convertirlos automáticamente a GLSL e imágenes auxiliares un método de fusión de entradas con expresiones embebidas extienden el rango de simulaciones y comportamientos posibles Técnicas de nivel de detalle (LOD) G P U para Megamultitudes

18. Un enfoque basado en agentes para simular grandes multitudes en el GPU: Los comportamientos de agentes individuales se especifican como máquinas de estado se guardan como una imagen (originalmente hecha a mano). Imagenes adicionales del mundo (etiquetas) y agentes. El comportamiento de cada agente se determina en tiempo real consultando estas imagenes. . G P U y s i m u l a c i ó n

19. De mundo Obstáculos, alturas, Gradientes (colisiones, atracción, repulsión) Etiquetas, ID de agentes, caminos, moronas De agente Estado, posición, ID Umbrales Messages I m á g e n e s A u x i l i a r e s

20. Dibujamos los personajes de dos maneras: impostores para personajes distantes con poco detalle instancias para personajes cercanos con mayor detalle Dibujado de multitudes

21. Inicialmente los mapas y “shaders” para simulación se generaban manualmente Se decidió mejor traducir de manera automática scripts FSM codificados en XML que especifican el comportamiento de multitudes de agentes a un conjunto de “shaders” de propósito específico e imagenes Traducción a GLSL

23. Por omisión, las imagenes auxiliares (de mundo o personajes) se combinan ya sea para la entrada o la salida mediante ponderación (esto lo llamamos fusión de entradas) Fusión Es mejor tener código de “shader” embebido dentro del script XML: permite reemplazar las ponderaciones simples y obtener mayor flexibilidad y poder. Un ejemplo: <expression name=&quot;motion&quot; type=&quot;vec2&quot; value=&quot;vec2(cos(rand*6.28),sin(rand*6.28))*(fear+0.1)&quot; />

24. Sin LOD 16,384 personajes (de 500 poligonos) a 5.45 fps usando una NV6800. Con LOD 59-60 fps para16,384 personajes, 29.9-60 fps para 65,536, 3.1-4.6 fps para 1,048,576. R e s u l t a d o s :

25. Simular comportamiento en el GPU funciona bien para grandes multitudes (cientos de miles de personajes) formadas de personajes sencillos y con comportamientos especificados mediante FSMs básicas y probabilísticas, en espacios definidos por mapas 2D. C o n c l u s i o n e s GPU

26. Mejorar calidad de personajes mediante el uso de imagenes de geometría Uso de CUDA para lograr acelerar las otras arquitecturas e implementar eficientemente mensajes y mapas 3D Trabajo F u t u r o

27. Modelos faciales animables para multitudes Usamos un grupo pequeño (5 a 7) de imagenes de geometría representativas, además de 3 imagenes auxiliares y parámetros individualizados para modelar y animar de una vez todas las caras de una multitud.

28. Modelos faciales animables para multitudes

29. La idea es adaptar a CUDA el trabajo que se hizo para implementar en CPU la traducción del XML a C++ de modelos jerárquicos modelos por capas Manteniendo de la implementación que se hizo en el GPU mediante GLSL el esquema de preprocesar el XML para generar kernels de CUDA en manera semejante a como se generaron shaders de GLSL el esquema de dibujo que permite las velocidades Agregar de manera eficiente capacidades como mensajes entre agentes mapas 3D Si se hace bien debiera funcionar también este enfoque para generar kernels de OpenCL o compute shaders de DirectX11. CUDA-Crowds

30. Reynolds et al 2006: Big Fast Crowds on PS3 http://portal.acm.org/citation.cfm?id=1183333 Rudomin et al 2006: Large Crowds in the GPU: http://rudomin.cem.itesm.mx/~rudomin/shader-agents.htm De Souza et al 2007: Mega-Scale Interactive Agent-Based Model Simulations on the GPU: http://www.me.mtu.edu/~rmdsouza/ABM_GPU.html Shopf et al 2008: March of the Froblins http://ati.amd.com/developer/SIGGRAPH08\Chapter03-SBOT-March_of_The_Froblins.pdf Referencias