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
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
El Proceso de El Proceso de RenderizaciónRenderizaciónEl Proceso de El Proceso de
RenderizaciónRenderizació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 El Proceso de RenderizaciónRenderizaciónEl Proceso de El Proceso de
RenderizaciónRenderizació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 El Proceso de RenderizaciónRenderizaciónEl Proceso de El Proceso de
RenderizaciónRenderizació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 El Proceso de RenderizaciónRenderizaciónEl Proceso de El Proceso de
RenderizaciónRenderizació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
RenderizadorTransformación
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
RenderizadorTransformació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í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
InterpenetracióInterpenetraciónnInterpenetracióInterpenetraciónn
1t
d
InterpenetracióInterpenetraciónnInterpenetracióInterpenetraciónn
2t
d
InterpenetracióInterpenetraciónnInterpenetracióInterpenetraciónn
3t
d
InterpenetracióInterpenetraciónnInterpenetracióInterpenetraciónn
?t
InterpenetracióInterpenetraciónnInterpenetracióInterpenetraciónn
3t
d
InterpenetracióInterpenetraciónnInterpenetracióInterpenetraciónn
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();
}
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();
}
void ParticleSystem::applyForces() {
// aplica las fuerzas del sistema for (int i = 0; i<100; i++) { forces[i].applyForce(); }
}
Halla para cada partícula. f
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();
}
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
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();
}
Halla para cada partícula:
m
fa
dtav .
dtvx .
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();
}
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
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();
}
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.
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)
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
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.
Eso es todo Eso es todo Amigos!!Amigos!!
Top Related