1 / 75

Simulación Física para Realidad Virtual

Simulación Física para Realidad Virtual. MauricioFranco@icqmail.com. 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 3D. Imagen 2D. Píxeles de colores. Geometría Sombreado

doctor
Download Presentation

Simulación Física para Realidad Virtual

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

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

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

  3. Vértices El Proceso de Renderización x1 y1 z1 x2 y2 z2 x3 y3 z3 x4 y4 z4 x5 y5 z5 x6 y6 z6 x7 y7 z7 x8 y8 z8 … xn yn zn Renderizador (x, y) = (x/z, y/z) Plano 2D

  4. Vértices El Proceso de Renderización Caras 1: v1 v2 v3 2: v2 v4 v5 3: v3 v6 v7 4: v7 v10 v11 5: v12 v8 v13 … n: vi vj vk Renderizador Algoritmo de Línea de Bressenham Plano 2D

  5. Vértices El Proceso de Renderización Caras Luces y materiales • 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 Renderizador Cálcula el color de cada píxel dependiendo de las características de la luz y del material. Imagen 2D

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

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

  8. Pixar Renderman Silicon Graphics OpenGL Microsoft Direct3D Renderizadores 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(); }

  9. Animación Posición Orientación Transformación Geometría Sombreado Renderizador // 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ón 2D

  10. Animación Interactiva Posición Orientación Transformación Geometría Sombreado Renderizador // 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 2D

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

  12. Dinámica de Partículas

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

  14. 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.

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

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

  17. RungeKutta4th 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; }

  18. F M V class Particle { public: // propiedades físicas floatmass; // masa floatx, y, z; // posición floatvx, vy, vz; // velocidad floatfx, 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(); }; Clase Partícula P = { x, y, z }

  19. Código de Dinámica en C++ // crea una partícula p Particlep; p.mass = 100; p.x = p.y = p.z = 0; // usa time para calcular el dt floattime = 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(floatdt,floattime) { // halla la nueva aceleración floatax = fx / mass; floatay = fy / mass; floataz = 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); }

  20. Hola Mundo!!

  21. Fuerzas Fuerzas unarias Fuerzas binarias Fuerzas de interacción espacial • Gravedad terrestre • Viento • Viscosidad del medio • Resortes • Fuerza eléctrica • Fuerza gravitacional

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

  23. Umma-gumma

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

  25. Electric Lady-Land

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

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

  28. N V Vt -Vn Coeficiente de restitución Vt V Vn Resolución de Colisiones

  29. Interpenetración

  30. Interpenetración

  31. Interpenetración

  32. Interpenetración

  33. Interpenetración

  34. Interpenetración

  35. Interpenetración

  36. VROOM

  37. Contacto de Reposo Fn Vn = 0 fricción = -kf (-Fn . N ) vt Vt N = -Fn Contacto de Reposo

  38. Voila!!

  39. Sistemas de Partículas

  40. Partículas Fuerzas Planos Sistemas de Partículas Sistema de Partículas

  41. F M V class Particle { public: floatmass; // masa floatx, y, z; // posición floatvx, vy, vz; // velocidad floatfx, fy, fz; // acumulador de fuerzas boolfixed; // 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(); }; Clase Partícula P = { x, y, z }

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

  43. Fuerzas 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(); }; 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(); };

  44. N D Y X Z 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); };

  45. struct ParticleContact { Particle *p; Plane *plane; }; Clase Sistema de Partículas class ParticleSystem { public: Particleparticles[100]; // arreglo de partículas Force forces[100]; // arreglo de fuerzas Planeplanes[10]; // arreglo de planos private: ParticleContactcontacts[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 };

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

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

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

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

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

More Related