Simulación Física para Realidad Virtual

Simulación Física para Realidad Simulación Física para Realidad VirtualVirtual

Mauricio Franco MartínezMauricio Franco Martínez

Universidad Tecnológica de BolívarUniversidad Tecnológica de Bolívar

Cartagena de Indias, 31 de marzo de Cartagena de Indias, 31 de marzo de 20042004

[email protected]

Introducción: Gráficos Introducción: Gráficos 3D3D

Introducción: Gráficos Introducción: Gráficos 3D3D

RenderizadorModelo 3D Imagen 2D

• Geometría

• Sombreado

• Transformación espacial

• Píxeles de colores

El Proceso de El Proceso de RenderizaciónRenderizaciónEl Proceso de El Proceso de

RenderizaciónRenderización

Renderizador

Vértices

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

(x, y) = (x/z, y/z)

Plano 2D

Renderizador

Vértices

Algoritmo de Línea de Bressenham

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

Plano 2D



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



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



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



RenderizadoreRenderizadoress

RenderizadoreRenderizadoress

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 2DAnimación 2DAnimación 2DAnimación 2D

// repita indefinidamentewhile (1){ // incremente el ángulo de rotación roty = roty + 5.0;

// cambie la transformación rotate(roty, 0, 1, 0);

// dibuje render();}

AnimaciónAnimaciónAnimaciónAnimación

RenderizadorTransformación

Geometría

Sombreado

Posición

Orientación

Animación 2DAnimación 2DAnimación 2DAnimación 2D

// mientras no se presione ESCwhile ( ! 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 Animación InteractivaInteractivaAnimación Animación InteractivaInteractiva


Geometría

Sombreado

Posición

Orientación

Animación Basada en la Animación Basada en la FísicaFísica

Animación Basada en la Animación Basada en la FísicaFísica


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ículasDinámica de Partículas

PartículaPartículassPartículaPartículass

M

Posición = { x, y, z }

XX

YY

ZZ

FF

VV

Ecuaciones de DinámicaEcuaciones de DinámicaEcuaciones de DinámicaEcuaciones 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.

m

fa

dtvx .

dtav .

dtdx

v

dtdv

a

maf

Algoritmo de Algoritmo de DinámicaDinámicaAlgoritmo de Algoritmo de DinámicaDiná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.

m

fa

dtav .

dtvx .

Integración Integración NuméricaNuméricaIntegración Integración NuméricaNumérica

dtvx . dtvxx .01 (Integrador de Euler)

n

nn

t

x

n

dttxf

dttxf

dttxf

dttxfdtXX

.!

),('''.!4

),(''.!3

),('.!2

),(. 0

4

0

3

0

2

001

Error numérico

Integrador de Runge Kutta

Integrador Runge-Integrador Runge-KuttaKuttaIntegrador Runge-Integrador Runge-KuttaKutta

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

0x1x

dt

t),( txf

Clase Clase PartículaPartículaClase Clase PartículaPartículaclass 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 }

FF

VV

Código de Dinámica en C+Código de Dinámica en C+++Código de Dinámica en C+Código de Dinámica en C+++

// crea una partícula pParticle p;p.mass = 100;p.x = p.y = p.z = 0;

// usa time para calcular el dtfloat time = getTime();

// ciclo principalwhile (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 Hola Mundo!!Mundo!!Hola Hola Mundo!!Mundo!!

FuerzaFuerzas s FuerzaFuerzas s

Fuerzas unarias

Fuerzas binarias

Fuerzas de interacción espacial

• Gravedad terrestre

• Viento

• Viscosidad del medio

• Resortes • Fuerza eléctrica

• Fuerza gravitacional

Ecuación del Ecuación del ResorteResorteEcuación del Ecuación del ResorteResorte

ab

dsa

ff

ll

lll

krlkf

.)(

.

.

l

l

k

r

l

k

d

s Coeficiente de Hooke

Elongación

Distancia en reposo

Coef. de elasticidad

Pos B – Pos A

Vel B – Vel A

A B

Ley de Hooke Elasticidad

Umma-Umma-gummagummaUmma-Umma-gummagumma

Fuerza Fuerza EléctricaEléctricaFuerza Fuerza EléctricaEléctrica

221

dqqC

fe

Constante de Coulomb Cargas

eléctricas

Distancia entre partículas

Electric Lady-Electric Lady-LandLandElectric Lady-Electric Lady-LandLand

Ecuación del PlanoEcuación del PlanoEcuación del PlanoEcuación del Plano

0: DCzByAxPlano

Normal

NN

Distancia al origen

XX

YY

ZZ

D

Detección de Detección de ColisionesColisionesDetección de Detección de ColisionesColisiones

NNP = { x, y, z }

ColisióndSi )0(

d

// distancia de un punto a un planofloat distance(Plane p, Vector3 x){ return ( (p.normal * x) + p.distance );}

DPNd ).(

dDCzByAx

Resolución de Resolución de ColisionesColisionesResolución de Resolución de ColisionesColisiones

NN0t

VVVt

Vn

nt

n

VVV

NNVV

).(

1t

VV Vt

-Vn

nt

nn

VVV

rVV

.

Coeficiente de restitución

InterpenetracióInterpenetraciónnInterpenetracióInterpenetraciónn

0t

d


1t

d


2t

d


3t

d


?t


3t

d


3t

d

VROOMVROOMVROOMVROOM

Contacto de ReposoContacto de ReposoContacto de ReposoContacto de Reposo

FnFn

VtVt

N = -FnN = -Fn

Vn = 0Vn = 0fricción = -kf (-Fn . N ) vt

fricción = -kf (-Fn . N ) vt

)0( nVSi Contacto de Reposo

Voila!Voila!!!Voila!Voila!!!

Sistemas de Sistemas de PartículasPartículas

Sistemas de Sistemas de PartículasPartículasSistemas de Sistemas de PartículasPartículas

PartículasFuerzas Planos

Sistema de Partículas

Clase Clase PartículaPartículaClase Clase PartículaPartículaclass 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 }

FF

VV

Clase Clase FuerzaFuerzaClase Clase FuerzaFuerza

class Force{ public: Force(); // constructor ~Force(); // destructor

virtual void applyForce()=0; // aplica la fuerza};

FuerzaFuerzassFuerzaFuerzass

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 Clase PlanoPlanoClase Clase PlanoPlano

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);};

NN

XX

YY

ZZD

Clase Sistema de Clase Sistema de PartículasPartículasClase Sistema de Clase Sistema de PartículasPartí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 Sistema de PartículasPartículasSistema de Sistema de PartículasPartículas

void ParticleSystem::update(float dt, float t){

applyForces();

solveContacts();

integrate(dt, t);

checkContacts();

clearForces();

}



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



applyForces();

solveContacts();

integrate(dt, t);

checkContacts();

clearForces();

}

Recorre la lista de contactos.Para cada partícula y plano en contacto:

?)0( nVsi

no

nt

n

VVV

NNVV

).(

Halla:

Aplica: rVV nn .

Colisión

Aplica: fr = -kf (-Fn . N) vt

Cancela: Fn

Contacto de Reposo



applyForces();

solveContacts();

integrate(dt, t);

checkContacts();

clearForces();

}

Halla para cada partícula:

m

fa

dtav .

dtvx .



applyForces();

solveContacts();

integrate(dt, t);

checkContacts();

clearForces();

}

Inicializa la lista de contactos.

Chequea la distancia de cada partícula a cada plano:

DPNd ).(

?)0( d si

Retrocede la partícula una distancia -d.

Añade el plano y la partícula a la lista de contactos.

Interpenetración



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 Uso del Sistema de PartículasPartículasUso del Sistema de Uso del Sistema de PartículasPartí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: TelaAplicación: TelaAplicación: TelaAplicación: Tela

Aplicación: Emisor de Aplicación: Emisor de PartículasPartí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 91-108.

Dinámica de Cuerpos Dinámica de Cuerpos RígidosRígidos

Cuerpos Cuerpos RígidosRígidos

Colección Infinita de Partículas Fuertemente Interconectadas

Posición = { x, y, z }

XX

YY

ZZ

VV

M

Centro de MasaCentro de Masa

VcmVcm Mxm

xii

cm

cmtotal vv

cmtotal aa

Movimiento Movimiento AngularAngular

XX

YY

ZZ

Orientación =

Velocidad Angular =

dFF

dF

Momento de InerciaMomento de Inercia

dF

dt.

dt.

?I

dmrI .2

Algoritmo de la Dinámica de Cuerpos Algoritmo de la Dinámica de Cuerpos RígidosRí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.

m

fa

dtav .

dtvx .

I

dt.

dt.

Respuesta a la Respuesta a la ColisiónColisión

AAPAA

AAA

INjr

NMj

vv

..01

01

BBP

AAP

BA

AB

INr

INr

MMNN

Nvej

..11.

..)1(0

AA

BBNN

PPAPr

BPr

Corre Conejo, Corre Conejo, Corre!!Corre!!Corre Conejo, Corre Conejo, Corre!!Corre!!

Temas Temas PendientesPendientes

Cálculo de las Propiedades de MasaCálculo de las Propiedades de Masa

dmrI

mdmxx

dvm

ocm

2

/

.Masa

Centro de Masa

Tensor de Inercia

Mirtich, Brian. Fast and Accurate Computation of Polyhedral Mass Properties.Journal of Graphics Tools, 1 (2) : 31-50. 1996

?

Representación de Orientaciones en el Representación de Orientaciones en el EspacioEspacio

2D2D Euler ?Euler ? Eje y ángulo ?Eje y ángulo ? Cuaternios !!

(Quaternions)

Cuaternios !!

(Quaternions)

Cerradura del Cardán (Gimbal Lock)

Cerradura del Cardán (Gimbal Lock)

Dam, Erik. Koch, Martin. Lillholm, Martin.Quaternions, Animation and Interpolation.

http://citeseer.nj.nec.com/dam98quaternions.html, 1998.

http://citeseer.nj.nec.com/dam98quaternions.html

Colisiones y Contactos en Cuerpos Colisiones y Contactos en Cuerpos RígidosRí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 1994. pp 23-34.

GAMMA Group.University of North Carolina.www.cs.unc.edu/~geom

Determinación del Tiempo Exacto de Colisión

Determinación de la Información de Contacto (puntos de contacto, normales de colisión)

http://www.cs.unc.edu/~geom

http://www.cs.unc.edu/~geom

RestriccioneRestriccioness

Cuerpos Cuerpos DeformablesDeformables

Terzopoulos. Platt. Barr. Fleischer.Elastically Deformable Bodies.

Proceedings of ACM Siggraph 1987.

Deformación de Forma Libre

Método de Elementos Finitos

Simulación de Simulación de FluidosFluidos

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, 23-30 (2001).

Foster, N. and Fedkiw, R.Practical Animation of Liquids.Siggraph 2001 Annual Conference, 15-22 (2001).

Ecuaciones de Navier-Stokes

Comentarios Comentarios FinalesFinales

Bibliotecas de Simulación Bibliotecas de Simulación FísicaFísica

OpenDinamicsEngine (ODE)

http://www.q12.org

Freeware

Novodex SDK

http://www.novodex.com

Havok

http://www.havok.com

http://www.q12.org/

http://www.novodex.com/

http://www.havok.com/

TridiuTridiumm

Franco, Mauricio. Villamizar, Henry.Biblioteca en C++ para la Simulación de Ambientes Virtuales en Tiempo Real.Universidad Tecnológica de Bolívar. 2002.

• 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 Simulador del Puerto de CartagenaCartagena

BibliografíBibliografíaa

Hecker, Chris. Behind the Screen Columns. Game Developer Magazine. October 1996 - June 1997. Also available on http://www.d6.com

Baraff, David. Witkin, Andrew. Physically Based Modeling: Principles and Practice Course Notes.Siggraph ’01 course notes. 2001.http://www.pixar.comFoley, James. Van Dam, Andries. Feiner, Steven. Hugues, John. Computer Graphics: Principles and Practice. Addison-Wesley. 1990.OpenGL Architecture Review Board. OpenGL Programming Guide and Reference Manual. Addison-Wesley. 1992.Press. Flannery. Teukolsky. Vetterling. Numerical Recipes in C. Cambridge University Press, Cambridge, England, 1988.

http://www.d6.com/

http://www.d6.com/

http://www.d6.com/

http://www.d6.com/

http://www.pixar.com/






Eso es todo Eso es todo Amigos!!Amigos!!

[email protected]

Documents

Simulación Física para Realidad Virtual