Simulación Física para Realidad Virtual Mauricio Franco Martínez Universidad Tecnológica de Bolívar Cartagena de Indias, 31 de marzo de 2004

Introducción: Gráficos 3D Renderizador Modelo 3DImagen 2D Geometría Sombreado Transformación espacial Píxeles de colores

El Proceso de Renderización Renderizador Vértices x 1 y 1 z 1 x 2 y 2 z 2 x 3 y 3 z 3 x 4 y 4 z 4 x 5 y 5 z 5 x 6 y 6 z 6 x 7 y 7 z 7 x 8 y 8 z 8 … x n y n z n (x, y) = (x/z, y/z) Plano 2D

Renderizador Vértices Algoritmo de Línea de Bressenham Caras 1: v 1 v 2 v 3 2: v 2 v 4 v 5 3: v 3 v 6 v 7 4: v 7 v 10 v 11 5: v 12 v 8 v 13 … n: v i v j v k Plano 2D El Proceso de Renderización

Renderizador Vértices Cálcula el color de cada píxel dependiendo de las características de la luz y del material. Caras Propiedades de las luces de la escena: Posición Angulo de incidencia Intensidad Color Propiedades de los materiales: Ángulos de reflexión Propiedades de absorción y reflexión de la luz Imagen 2D Luces y materiales El Proceso de Renderización

Renderizador Vértices Combina el color de cada píxel con el color de la textura. Caras Imagen 2D Coordenadas de Mapeo de la imagen 2D en el sólido 3D. Imagen 2D Luces y materiales Textura El Proceso de Renderización

Renderizador Imagen 2D Vértices Caras Traslación T = x, y, z Rotación R =  x,  y,  z Escalamiento S = x, y, z Luces y materiales Textura Transformación El Proceso de Renderización

RenderizadoresRenderizadores Microsoft Direct3D Pixar Renderman Silicon Graphics OpenGL void OpenGL_Render(void) { // limpia la pantalla glClear(GL_COLOR_BUFFER); // especifica la transformación glRotatef(45.0, 0, 1, 0); glTranslatef(0.0, 0.0, 1.0); // especifica el sombreado glColor4f(0.5, 0.5, 0.5, 1.0); // especifica la geometría glBegin(GL_TRIANGLES); glVertex3f(1.0, 0.0, 0.0); glVertex3f(0.0, 0.0, 0.0); glVertex3f(0.0, 1.0, 0.0); glEnd(); // renderiza glSwapBuffers(); }

Animación 2D // repita indefinidamente while (1) { // incremente el ángulo de rotación roty = roty + 5.0; // cambie la transformación rotate(roty, 0, 1, 0); // dibuje render(); } AnimaciónAnimación Renderizador Transformación Geometría Sombreado Posición Orientación

Animación 2D // mientras no se presione ESC while ( ! key[ESC] ) { // lea la entrada updateInput(); // actualice la transformación if ( key[SPACE] ) roty = roty + 5.0; // cambie la transformación rotate(roty, 0, 1, 0); // dibuje render(); } Animación Interactiva Renderizador Transformación Geometría Sombreado Posición Orientación

Animación Basada en la Física Renderizador Transformación Geometría Sombreado Posición Orientación Ecuaciones que describen el movimiento de los cuerpos provocado por la acción de las fuerzas. Leyes Físicas Cinética Dinámica

Dinámica de Partículas

PartículasPartículas M Posición = { x, y, z } X X Y Y Z Z F F V V

Ecuaciones de Dinámica La velocidad es el cambio de la posición en el tiempo. La aceleración es el cambio de la velocidad en el tiempo. La fuerza de un objeto es proporcional a su masa y aceleración.

Algoritmo de Dinámica 1.Se hallan todas las fuerzas que actúan sobre la partícula. 2.Se dividen las fuerzas entre la masa para hallar la nueva aceleración de la partícula. 3.Se integra la aceleración para hallar la nueva velocidad de la partícula. 4.Se integra la velocidad para hallar la nueva posición de la partícula. 5.Se renderiza la partícula en la nueva posición. 6.Regresa al punto 1.

Integración Numérica (Integrador de Euler) Error numérico Integrador de Runge Kutta

Integrador Runge-Kutta void RungeKutta4th(float dt, float x0, float t, float *x1, float (*f)(float, float)) { float k1 = h * (*f)(x0, t); float k2 = h * (*f)(x0 + k1/2, t + dt/2); float k3 = h * (*f)(x0 + k2/2, t + dt/2); float k4 = h * (*f)(x0 + k3, t + dt); *x1 = x0 + 6*k1 + k2/3 + k3/3 + 6*k4; } RungeKutta4th

Clase Partícula class Particle { public: // propiedades físicas float mass; // masa float x, y, z; // posición float vx, vy, vz; // velocidad float fx, fy, fz; // acumulador de fuerzas public: // constructor, destructor Particle(); ~Particle(); // limpia el acumulador de fuerzas void clearForces(); // añade una fuerza sobre la partícula void addForce(float x, float y, float z); // halla la nueva velocidad y posición void integrate(float dt, float time); // dibuja la partícula void render(); }; M P = { x, y, z } F F V V

Código de Dinámica en C++ // crea una partícula p Particle p; p.mass = 100; p.x = p.y = p.z = 0; // usa time para calcular el dt float time = getTime(); // ciclo principal while (1) { // añade la fuerza de gravedad sobre la partícula p.addForce(0.0, -9.8, 0.0); // halla el tiempo transcurrido desde la última integración float dt = getTime() – time; time = time + dt; // integra para hallar el nuevo estado de la partícula i p.integrate(dt, time); // limpia el acumulador de fuerzas de la partícula p.clearForces(); // renderiza la partícula i p.render(); } Particle::integrate(float dt, float time) { // halla la nueva aceleración float ax = fx / mass; float ay = fy / mass; float az = fz / mass; // integra la aceleración para hallar la velocidad RungeKutta4th(dt, ax, ay, az, t, &vx, &vy, &vz, f); // integra la velocidad para hallar la posición RungeKutta4th(dt, vx, vy, vz, t, &x, &y, &z, f); } Particle::integrate(float dt, float time) { // halla la nueva aceleración float ax = fx / mass; float ay = fy / mass; float az = fz / mass; // integra la aceleración para hallar la velocidad RungeKutta4th(dt, ax, ay, az, t, &vx, &vy, &vz, f); // integra la velocidad para hallar la posición RungeKutta4th(dt, vx, vy, vz, t, &x, &y, &z, f); }

Hola Mundo!!

FuerzasFuerzas Fuerzas unariasFuerzas binariasFuerzas de interacción espacial Gravedad terrestre Viento Viscosidad del medio Resortes Fuerza eléctrica Fuerza gravitacional

Ecuación del Resorte Coeficiente de Hooke Elongación Distancia en reposo Coef. de elasticidad Pos B – Pos A Vel B – Vel A AB Ley de Hooke Elasticidad

Umma-gummaUmma-gumma

Fuerza Eléctrica Constante de Coulomb Cargas eléctricas Distancia entre partículas

Electric Lady-Land

Ecuación del Plano Normal N N Distancia al origen X X Y Y Z Z D

Detección de Colisiones N N P = { x, y, z } // distancia de un punto a un plano float distance(Plane p, Vector3 x) { return ( (p.normal * x) + p.distance ); }

Resolución de Colisiones N N V V VtVt VnVn V V VtVt -V n Coeficiente de restitución

InterpenetraciónInterpenetración

InterpenetraciónInterpenetración

InterpenetraciónInterpenetración

InterpenetraciónInterpenetración

InterpenetraciónInterpenetración

InterpenetraciónInterpenetración

InterpenetraciónInterpenetración

VROOMVROOM

Contacto de Reposo FnFn FnFn VtVt VtVt N = -F n V n = 0 fricción = -k f (-F n. N ) v t Contacto de Reposo

Voila!!Voila!!

Sistemas de Partículas

PartículasFuerzas Planos Sistema de Partículas

Clase Partícula class Particle { public: float mass; // masa float x, y, z; // posición float vx, vy, vz; // velocidad float fx, fy, fz; // acumulador de fuerzas bool fixed; // partícula fija? public: Particle(); // constructor ~Particle(); // destructor // limpia el acumulador de fuerzas void clearForces(); // añade una fuerza sobre la partícula void addForce(float x, float y, float z); // halla la nueva velocidad y posición void integrate(float dt, float time); // dibuja la partícula void render(); }; M P = { x, y, z } F F V V

Clase Fuerza class Force { public: Force(); // constructor ~Force(); // destructor virtual void applyForce()=0; // aplica la fuerza };

FuerzasFuerzas class SpringForce : public Force { public: Particle *p1, *p2; // partículas unidas por el resorte float Ks, Kd; // coeficientes del resorte (Hooke y elasticidad) float r; // distancia de reposo public: SpringForce(); // constructor ~SpringForce(); // destructor virtual void applyForce(); }; class UnaryForce : public Force { public: ParticleSystem *ps; // sistema de partículas sobre el que ejerce fuerza float fx, fy, fz; // magnitud de la fuerza public: UnaryForce(); // constructor ~UnaryForce(); // destructor virtual void applyForce(); };

Clase Plano class Plane { public: float nx, ny, nz; // normal del plano float d; // distancia al origen public: Plane(); // constructor ~Plane(); // destructor // distancia de un punto a un plano friend float distance(Plane p, float x, float y, float z); }; N N X X Y Y Z Z D

Clase Sistema de Partículas class ParticleSystem { public: Particle particles[100]; // arreglo de partículas Force forces[100]; // arreglo de fuerzas Plane planes[10]; // arreglo de planos private: ParticleContact contacts[100]; // lista de contactos por resolver public: ParticleSystem(); // constructor ~ParticleSystem(); // destructor virtual bool load(char* filename); // carga un sistema de un archivo virtual bool save(char* filename); // guarda un sistema en un archivo virtual void update(float dt, float t); // actualiza el estado del sistema virtual void render(); // dibuja el sistema private: void clearForces(); // limpia los acumuladores de fuerzas void applyForces(); // aplica las fuerzas a las partículas void integrate(float dt, float t); // avanza el estado del sistema void checkCollisions(); // chequea si hay colisión con los planos void solveCollisions(); // resuelve las colisiones que se presentaron }; struct ParticleContact { Particle *p; Plane *plane; }; struct ParticleContact { Particle *p; Plane *plane; };

Sistema de Partículas void ParticleSystem::update(float dt, float t) { applyForces(); solveContacts(); integrate(dt, t); checkContacts(); clearForces(); }

Sistema de Partículas void ParticleSystem::update(float dt, float t) { applyForces(); solveContacts(); integrate(dt, t); checkContacts(); clearForces(); } void ParticleSystem::applyForces() { // aplica las fuerzas del sistema for (int i = 0; i<100; i++) { forces[i].applyForce(); } Halla para cada partícula.

Sistema de Partículas void ParticleSystem::update(float dt, float t) { applyForces(); solveContacts(); integrate(dt, t); checkContacts(); clearForces(); } Recorre la lista de contactos. Para cada partícula y plano en contacto: si no Halla: Aplica: Colisión Aplica: fr = -k f (-F n. N) v t Cancela: F n Contacto de Reposo

Sistema de Partículas void ParticleSystem::update(float dt, float t) { applyForces(); solveContacts(); integrate(dt, t); checkContacts(); clearForces(); } Halla para cada partícula:

Sistema de Partículas void ParticleSystem::update(float dt, float t) { applyForces(); solveContacts(); integrate(dt, t); checkContacts(); clearForces(); } Inicializa la lista de contactos. Chequea la distancia de cada partícula a cada plano: si Retrocede la partícula una distancia -d. Añade el plano y la partícula a la lista de contactos. Interpenetración

Sistema de Partículas void ParticleSystem::update(float dt, float t) { applyForces(); solveContacts(); integrate(dt, t); checkContacts(); clearForces(); } void ParticleSystem::applyForces() { // resetea los acumuladores de fuerzas for (int i = 0; i<100; i++) { particles[i].fx = 0; particles[i].fy = 0; particles[i].fz = 0; } Resetea los acumuladores de fuerzas:

Uso del Sistema de Partículas #include “ParticleSystem.h” int main(void) { // inicia el sistema de video initVideo(); // usa time para calcular el dt float time = getTime(); // crea un sistema de partículas ParticleSystem ps; // carga el sistema de partículas desde un archivo ps.load(“cloth.par”); // ciclo principal while (1) { // halla el tiempo transcurrido desde la última integración float dt = getTime() – time; time = time + dt; ps.update(dt, time); // actualiza el systema de partículas ps.render(); // renderiza el sistema de partículas }

Aplicación: Tela

Aplicación: Emisor de Partículas Reeves, William. Lucasfilm Ltd. Particle Systems: A Technique for Modeling a Class of Fuzzy Objects. ACM Transactions on Graphics, Vol. 2, No. 2, April 1983, Pages

Dinámica de Cuerpos Rígidos

Cuerpos Rígidos Colección Infinita de Partículas Fuertemente Interconectadas Posición = { x, y, z } X X Y Y Z Z V V M

Centro de Masa V cm

Movimiento Angular X X Y Y Z Z Orientación = Velocidad Angular = F F

Momento de Inercia

Algoritmo de la Dinámica de Cuerpos Rígidos 1.Se hallan todas las fuerzas y torques que actúan sobre el cuerpo. 2.Se dividen las fuerzas entre la masa para hallar la aceleración lineal del centro de masa. 3.Se dividen los torques entre el momento de inercia para hallar la aceleración angular del cuerpo. 4.Se integra la aceleración lineal para hallar la velocidad lineal en el centro de masa. 5.Se integra la aceleración angular para hallar la velocidad angular del cuerpo. 6.Se integra la velocidad lineal para hallar la nueva posición del centro de masa. 7.Se integra la velocidad angular para hallar la nueva orientación del cuerpo. 8.Se regresa al punto 1.

Respuesta a la Colisión A A B B N N P P

Corre Conejo, Corre!!

Temas Pendientes

Cálculo de las Propiedades de Masa Masa Centro de Masa Tensor de Inercia Mirtich, Brian. Fast and Accurate Computation of Polyhedral Mass Properties. Journal of Graphics Tools, 1 (2) :

Representación de Orientaciones en el Espacio 2D Euler ? Eje y ángulo ? Cuaternios !! (Quaternions) Cuaternios !! (Quaternions) Cerradura del Cardán (Gimbal Lock) Dam, Erik. Koch, Martin. Lillholm, Martin. Quaternions, Animation and Interpolation

Colisiones y Contactos en Cuerpos Rígidos Detección de Colisiones con Volúmenes Envolventes Cálculo de Fuerzas de Contacto Baraff, David. Fast Contact Force Computation for Non-Penetrating Rigid Bodies. Proceedings of Siggraph pp GAMMA Group. University of North Carolina. Determinación del Tiempo Exacto de Colisión Determinación de la Información de Contacto (puntos de contacto, normales de colisión)

Restricciones

Cuerpos Deformables Terzopoulos. Platt. Barr. Fleischer. Elastically Deformable Bodies. Proceedings of ACM Siggraph Deformación de Forma Libre Método de Elementos Finitos

Simulación de Fluidos Fedkiw, Ron. Nguyen, D. and Jensen, H. Physically Based Modeling and Animation of Fire. Siggraph 2002 Annual Conference. Fedkiw, Ron., Stam, J. and Jensen, H.. Visual Simulation of Smoke. Siggraph 2001 Annual Conference, (2001). Foster, N. and Fedkiw, R. Practical Animation of Liquids. S iggraph 2001 Annual Conference, (2001). Ecuaciones de Navier-Stokes

Comentarios Finales

Bibliotecas de Simulación Física OpenDinamicsEngine (ODE) Freeware Novodex SDK Havok

Tridium Franco, Mauricio. Villamizar, Henry. Biblioteca en C++ para la Simulación de Ambientes Virtuales en Tiempo Real. Universidad Tecnológica de Bolívar Sistema de transformaciones basado en cuaternios. Determinación de la visibilidad y descarte de geometría mediante “Octrees”. Manejo de terrenos grandes mediante “Quadtrees”. Simulación física (partículas y cuerpos rígidos).

Simulador del Puerto de Cartagena

Bibliografía Hecker, Chris. Behind the Screen Columns. Game Developer Magazine. October June Also available on Baraff, David. Witkin, Andrew. Physically Based Modeling: Principles and Practice Course Notes. Siggraph ’01 course notes Foley, James. Van Dam, Andries. Feiner, Steven. Hugues, John. Computer Graphics: Principles and Practice. Addison-Wesley OpenGL Architecture Review Board. OpenGL Programming Guide and Reference Manual. Addison-Wesley Press. Flannery. Teukolsky. Vetterling. Numerical Recipes in C. Cambridge University Press, Cambridge, England, 1988.

Eso es todo Amigos!!