Megamultitudes
Upcoming SlideShare
Loading in...5
×
 

Like this? Share it with your network

Share

Megamultitudes

on

  • 572 views

 

Statistics

Views

Total Views
572
Views on SlideShare
572
Embed Views
0

Actions

Likes
0
Downloads
2
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Megamultitudes Presentation Transcript

  • 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
  • 22.  
  • 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/SIGGRAPH08Chapter03-SBOT-March_of_The_Froblins.pdf
    Referencias