Proyecto de Sistemas Final)
-
Upload
gerardo-aguilar -
Category
Documents
-
view
221 -
download
0
Transcript of Proyecto de Sistemas Final)
-
8/3/2019 Proyecto de Sistemas Final)
1/102
PROYECTO DE SISTEMAS INFORMTICOS
FACULTAD DE INFORMTICA
UNIVERSIDAD COMPLUTENSE DE MADRID
CURSO 2009/2010
MOTOR DE FSICA MULTIFUNCIONAL
PROFESOR DIRECTOR: Dr. Segundo Esteban San Romn
AUTORES:
Jaime Snchez-Valiente Blzquez
Santiago Riera Almagro
Matas Salinero Delgado
-
8/3/2019 Proyecto de Sistemas Final)
2/102
2
-
8/3/2019 Proyecto de Sistemas Final)
3/102
3
Resumen.
Tanto la industria de los videojuegos como la de la animacin requieren
motores fsicos que permitan reproducir fielmente el comportamiento de los
elementos presentes en una escena. El papel de estos motores es esencial para que el
trabajo final muestre un resultado realista.
El objetivo de este proyecto es el desarrollo e implementacin de un motor
fsico multifuncional, modular y ampliable que pueda ser usado en diferentes campos,
como los videojuegos y la simulacin de sistemas fsicos.
Este proyecto implementa los conceptos de dinmica de slidos rgidos y
dinmica de partculas. Adems se han introducido otras funcionalidades derivadas del
tratamiento de estos cuerpos como son las colisiones de slidos rgidos y las uniones
elsticas.
El motor se realizar sobre el lenguaje C++, siendo el lenguaje ms comn en la
realizacin de este tipo de aplicaciones y permitiendo as su fcil acoplamiento en los
campos anteriormente mencionados.
Abstract.
Both the video game industry such as animation industry requires physics
engines that allow to faithfully reproducing the behavior of the elements present in a
scene. The role of these motors is essential for the final work to show a realistic
outcome.
The aim of this project is the development and implementation of a multi-
physics engine, modular and expandable, that can be used in different fields, such as
video games and simulation of physical systems.
This project implements the concepts of rigid bodies and particle dynamics. We
have also introduced other features resulting from the processing of such bodies as are
collisions of rigid bodies and elastic joints.
The engine will be made on the language C++, being the most common
language in this type of application, thus allowing easy coupling in the fields
mentioned above.
Palabras clave: slido rgido, partcula, motor fsica, colisiones, unin, videojuegos,
simulacin, animacin, OpenGL, Euler.
-
8/3/2019 Proyecto de Sistemas Final)
4/102
4
Contenido
Resumen. .............................................................................................................. 3
1. Introduccin. ..................................................................................................... 7
1.1. Desarrollo de los motores de fs ica............................................................ 7
1.2. Funcin de un motor de Fsica. .................................................................. 9
1.3. Objetivos. ................................................................................................. 10
1.4. Planificacin. ............................................................................................ 11
1.4.1. Tareas a desarrollar........................................................................... 11
2. Estado del arte y motores comerciales........................................................... 13
2.1. ODE........................................................................................................... 13
2.1.1. Caractersticas. .................................................................................. 14
2.1.2. Conceptos. ........................................................................................ 15
2.1.3. Juegos en los que se usa. .................................................................. 22
2.2. Physx. ....................................................................................................... 22
2.2.1. Caractersticas. .................................................................................. 23
2.2.2. Juegos en los que se usa. .................................................................. 24
2.3. Havok. ...................................................................................................... 27
2.3.1. Caractersticas. .................................................................................. 27
2.3.2. Juegos en los que se usa. .................................................................. 29
3. Fundamentos fsicos tericos. ........................................................................ 31
3.1. Dinmica de partculas............................................................................. 31
3.1.1. Sistemas de partculas bsicos.......................................................... 31
3.1.2. Fuerzas. ............................................................................................. 32
3.2 . Dinmica de slido rgido........................................................................ 34
3.2.1. Posicin y orientacin. ...................................................................... 34
3.2.2. Velocidad lineal. ................................................................................ 35
3.2.3. Velocidad angular. ............................................................................ 36
3.2.4. Masa del slido rgido. ...................................................................... 36
3.3. Springs. ..................................................................................................... 38
-
8/3/2019 Proyecto de Sistemas Final)
5/102
5
3.4. Deteccin de colisiones............................................................................ 39
3.4.1. Deteccin de colisiones esfera-esfera. ............................................. 39
3.4.2. Deteccin de colisiones paraleleppedo-paraleleppedo................. 40
3.4.3. Deteccin de colisiones vrtice-plano. ............................................. 40
3.4.4. Deteccin de colisiones arista-plano. ............................................... 41
3.5. Respuesta a las colisiones. ....................................................................... 42
3.5.1. Velocidades relativas. ....................................................................... 42
3.5.2. Concepto de impulso. ....................................................................... 43
4. Resolucin de Ecuaciones Diferenciales Ordinarias. .................................. 47
4.1. Problemas de valor inicial. ....................................................................... 47
4.2. Soluciones numricas. ............................................................................. 48
4.2.1. Mtodo de Euler. .............................................................................. 48
4.2.2. Mtodo del punto medio. ................................................................. 50
4.2.3. Runge-Kutta de cuarto orden. .......................................................... 51
5. Arquitectura del motor. .................................................................................. 53
5.1. Diagrama de clases. ................................................................................. 53
5.2. Mundo. ..................................................................................................... 54
5.2.1. Clase CWorld. .................................................................................... 54
5.3. Sistemas de partculas.............................................................................. 61
5.3.1. Clase CParticleSystem (clase abstracta)............................................ 61
5.3.2. Clase CPSExplosion............................................................................ 64
5.3.3. Clase CPSLluvia. ................................................................................. 65
5.3.4. Clase CPSEmpty................................................................................. 66
5.3.5. Clase CParticleSpring......................................................................... 66
5.4. Slidos rgidos .......................................................................................... 67
5.4.1. Clase CRigidBody. .............................................................................. 67
5.4.2. Clase CGeoBox. ................................................................................. 70
5.5. Mdulo de simulacin.............................................................................. 71
5.5.1. Clase CSimulator (abstracta, permite distintos simuladores). ......... 71
5.5.2. Clase CEulerSimulator (extiende CSimulator) . ................................. 72
-
8/3/2019 Proyecto de Sistemas Final)
6/102
6
5.6. Muros. ..................................................................................................... 72
5.6.1. Clase CWall........................................................................................ 72
5.7. Springs. ..................................................................................................... 73
5.7.1. Clase CWorldSpring........................................................................... 73
5.7.2. Clase CBodySpring............................................................................. 74
5.8. Fuerzas. .................................................................................................... 74
5.8.1. Clase CForce (clase abstracta). ......................................................... 75
5.8.2. Clase CWind(Extiende CForce).......................................................... 76
6. Implementacin del motor de colisiones. ...................................................... 77
6.1. Deteccin de colisiones............................................................................ 77
6.1.1. Algoritmo de comprobacin de colisiones. ...................................... 78
6.1.2. Puntos de contacto. .......................................................................... 79
6.1.3. Colisin Objetos Muros. ................................................................. 79
6.1.4. Colisin entre objetos. ...................................................................... 80
6.2. Respuesta a las colisiones. ....................................................................... 83
6.2.1. Resolutor de colisiones. .................................................................... 83
7. Ejemplificacin del bucle de simulacin. ........................................................ 85
8. Integracin del motor en una aplicacin. ....................................................... 87
9. Conclusiones. .................................................................................................. 91
9.1. Futuras Mejoras y ampliaciones. ............................................................. 93
10. Ejemplos de pruebas .................................................................................... 95
11. Bibliografa. ................................................................................................... 99
-
8/3/2019 Proyecto de Sistemas Final)
7/102
7
1. Introduccin.
Un motor de fsica se puede definir como un software informtico que permitesimular sistemas fsicos como slidos rgidos, fluidos y sistemas de partculas entre
otros.
El proyecto propone implementar un motor fsico que pueda ser empleado en
el desarrollo de simuladores, videojuegos u otras aplicaciones que requieran el clculo
de sistemas fsicos.
1.1. Desarrollo de los motores de fsica.
La evolucin de estos motores ha ido de la mano con la de los videojuegos. Se
puede considerar el inicio de la fsica en videojuegos en videojuegos antiguos como
PONG (1972) u otros posteriores en los que simplemente se calculaba la trayectoria de
un proyectil con la nica restriccin de la gravedad. A medida que los consumidores
demandaban ms realismo, estos motores deban ser ms precisos. Una mejora grfica
y sonora quedara deslucida sin un consecuente comportamiento fsico realista delentorno.
Figura 1.1 Pong (1972)
La principal traba en la evolucin tanto de la calidad grfica as como del
comportamiento fsico realista ha sido el manejo de recursos. En un principio
renderizado, comportamiento fsico, sonido recaan en la C PU. Con la mejora de los
-
8/3/2019 Proyecto de Sistemas Final)
8/102
8
grficos la CPU se vea saturada, por lo que una solucin sera liberar a esta de los
procesos grficos, estrategia utilizada posteriormente para otros aspectos de la
aplicacin. Para satisfacer la demanda de los consumidores de una mayor calidad se
utilizaron las tarjetas graficas llamadas aceleradores grficos para liberar de esta cargaa la CPU. Las generaciones sucesivas de estas tarjetas fueron las tarjetas 3D. Con el
aumento de la complejidad de modelos as como de las tasas de renderizado vino la
evolucin de estas tarjetas grficas. La ltima generacin de estas tarjetas incorpor
un modulo llamado GPU (Graphic Processing Unit) que manejaba todos los procesos
relacionados con los grficos. Una mejora en estas tarjetas lleg en 1997 con el
lanzamiento al mercado de la tarjeta Voodoo 1 de la compaa 3Dfx.
Figura 1.2 Voodoo 1 de la compaa 3Dfx.
Con la evolucin de las CPUs y las GPUs, la tecnologa fue suficientemente
capaz como para proporcionar un entorno convincente. Pero la carrera por la
simulacin no deba acabarse ah. Adelantndose a los acontecimientos, una compaa
llamada MathEngine empez a desarrollar lo que llamo un motor fsico. En principio el
resultado fue bueno, pero mostraba irregularidades como la no estabilizacin de los
objetos en la superficie. La estabilidad es un requisito importante, por no decir
esencial, en un motor, pero tambin lo es la robustez. Otra compaa que lanz un
producto de gran calidad por entonces fue Telekinesis, llamando a su motor Havok.
Con el tiempo este motor se convertira en uno de los mejores del mercado, como se
resear ms adelante en el estudio de motores comerciales en la actualidad.
Actualmente la mejora tecnolgica de las CPUs y tarjetas grficas ha trado
consigo la consecucin de un realismo enorme. Pero otro factor ha ayudado
sustancialmente en ello: la integracin de PPUs (Physics Processing Unit) en las
tarjetas grficas. Siguiendo con la estrategia de liberar al procesador de clculos para
-
8/3/2019 Proyecto de Sistemas Final)
9/102
9
conseguir mayor rendimiento, estos mdulos concentran gran parte de los clculos
fsicos realizados en las aplicaciones. Ageia en su motor Physx ha sido uno de los
primeros en incorporar este dispositivo en sus tarjetas.
Figura 1.3 Esquema de distribucin de tareas.
Como conclusin se advierte que la evolucin de los motores de fsica ha ido
ligada, as como a su propio desarrollo, a la tecnologa que los soporta. Esta evolucin
esta inevitablemente ligada a la demanda del usuario de mayor realismo en los
entornos, que se aplica no slo en los videojuegos, sino tambin en otras industrias
como la animacin y la simulacin.
1.2. Funcin de un motor de Fsica.
La funcionalidad de un motor de fsica se puede explicar como la de hacer los
clculos correspondientes para dar como resultado un comportamiento real en el
entorno en el que se le proponen dichos clculos. Adems de hacer ecuaciones
diferenciales que prevean el comportamiento de sistemas fsicos, debe manejar elcomportamiento independientemente del entorno, es decir, que el cdigo pueda ser
reusable en diferentes situaciones y, dados unos parmetros, manejar su
comportamiento.
Para ello debe manejar conceptos fsicos como cinemtica y dinmica de
slidos rgidos y blandos, manejo de colisiones, fluidos, integracin de ecuaciones
diferenciales y otros conceptos.
-
8/3/2019 Proyecto de Sistemas Final)
10/102
10
1.3. Objetivos.
El objetivo principal del proyecto es la construccin de un Motor de Fsica
multifuncional, sobre el cual simularemos la dinmica de las partculas, as como el
comportamiento de los slidos rgidos, y su interaccin con el entorno.
Adems del ncleo del Motor, se debe generar una API que facilite su uso en
aplicaciones externas y permita visualizarlo de manera sencilla.
Los principales problemas que debemos resolver en la implementacin son:
1. Dinmica de partculas. El sistema debe permitir la simulacin desistemas de partculas, que permitirn al usuario final crear diversos
efectos.
2. Dinmica de Slidos Rgidos. El sistema debe responder de manerarealista a las distintas fuerzas externas que acten sobre los distintos
slidos creados en el mundo durante la simulacin.
3. Dinmica de Colisiones. Se debe intentar que el sistema responda demanera eficaz y realista a los choques generados por la interaccin de
los slidos con el entorno.4. Uniones elsticas entre slidos. El sistema debe permitir la unin de
slidos mediante tensores y simular su comportamiento fsico.
Para comprobar el correcto funcionamiento del motor se ha de crear una
batera de pruebas visibles sobre la plataforma grfica OpenGL.
Toda la implementacin ser sobre la CPU, sin el empleo de GPUs, con lo cual
se conseguir que esta herramienta pueda ser utilizada ampliamente en cualquierordenador personal. El lenguaje de programacin ser en C++, sobre la utilidad Visual
Studio 2008.
-
8/3/2019 Proyecto de Sistemas Final)
11/102
11
1.4. Planificacin.
El desarrollo de este proyecto empez en el verano de 2009, con la imparticin
de tutoras que nos mostraban los fundamentos a seguir en el desarrollo de esteproyecto. La planificacin que se propuso se cumpli (en mayor o menor medida)
siguiendo el siguiente esquema, significando cada nmero uno de los componentes del
grupo:
1.4.1. Tareas a desarrollar.
1. Realizar un estudio del estado actual de los motores de fsicacomerciales.
2. Proponer una arquitectura para el Motor y sus APIs.3. Implementacin del Ncleo del Motor.4. Implementacin del Visualizador.5. Implementacin del Demostrador.6. Documentacin.7. Presentacin.
Tar Ago Sep Oct Nov Dic Ene Feb Mar Abr May Jun Jul
1 123
2 123
3 123 123 123
4 12
5 3 123
6 123 123 123 123 123 123
7 123
-
8/3/2019 Proyecto de Sistemas Final)
12/102
12
-
8/3/2019 Proyecto de Sistemas Final)
13/102
13
2. Estado del arte y motores comerciales.
En la actualidad existen mltiples motores de fsica, destinados en su mayora alos videojuegos o a la simulacin. Se ha centrado este estudio en tres motores
pretendiendo ejemplificar el estado actual de este mercado. Estos motores son ODE,
PhysX y, por ltimo, Havok.
Physx y Havok al ser motores privados no facilitan su implementacin interna,
aunque proporcionan gratuitamente herramientas que permiten construir ejemplos
para ver sus funcionalidades. ODE en cambio al ser un motor de cdigo abierto facilita
su implementacin interna as como una completa gua de usuario que adems deincluir instrucciones sobre su funcionamiento e instalacin contiene nociones tericas
y prcticas sobre los conceptos utilizados en este motor, como por ejemplo slidos
rgidos, uniones y su integrador.
Por ello nuestro proyecto se basa en una estructura parecida a la de ODE, por
simpleza y recursos biogrficos. Adems se hace un estudio ms exhaustivo que
permita comprender mejor ODE y, por lo tanto, explicar ciertos fundamentos comunes
del nuestro.
2.1. ODE.
ODE (Open Dynamics Engine) es una librera de software libre, de calidad
profesional, dirigida a la simulacin de cuerpos rgidos articulados. Las aplicaciones
probadas sobre este motor incluyen la simulacin de vehculos, criaturas bpedas y
dems cuerpos sobre un entorno de realidad virtual. Entre sus caractersticas tambinincluye la deteccin de colisiones integrada.
Su autor es Russell Smith, con la ayuda de diferentes colaboradores, dando
comienzo el proyecto en 2001.
-
8/3/2019 Proyecto de Sistemas Final)
14/102
14
Figura 2.1Simulacin sobre ODE.
Al ser una librera de software libre, hay gran cantidad de bancos de pruebas ymanuales, estando en continuo proceso de evolucin y mejora.
2.1.1. Caractersticas.
ODE est enfocado a la simulacin tanto en tiempo real como interactiva de
estructuras articuladas, las cuales consisten en cuerpos rgidos de diferen te forma
conectados entre s mediante conexiones de diferentes tipos. Se incluyen gran
cantidad de conexiones, pudiendo manejar una extensa variedad de giros y
desplazamientos entre los cuerpos unidos.
Este motor prioriza velocidad y estabilidad a costa de precisin fsica, lo cual lo
hace robusto y fiable, pero tambin poco preciso respecto a otros motores del
mercado. Pero la ventaja es la gran capacidad de personalizacin del entorno
(colisiones, etc.) incluso durante la simulacin s in la aparicin de errores.
Respecto al tratamiento de colisiones, ODE utiliza colisiones duras, lo cual
quiere decir que hay impuestas restricciones especiales cuando dos cuerpos entran en
contacto. En otros motores se utilizan otras alternativas, siendo sin embargo ms
complicadas y ms difciles de implementar libres de errores.
La interfaz original fue implementada en C, aunque est escrito
mayoritariamente en C++ y se ha implementado una interfaz en C++ sobre la original.
-
8/3/2019 Proyecto de Sistemas Final)
15/102
15
2.1.2. Conceptos.
Caractersticas de los slidos rgidos.
Los slidos rgidos tienen varias caractersticas desde el punto de vista de la
simulacin. Algunas de estas cambian durante la simulacin:
Vector de posicin(x,y,z) del punto de referencia del cuerpo. En ODE elpunto de referencia corresponde con el centro de masas.
Velocidad lineal del punto de referencia, representada por un vector(vx,vy,vz).
Orientacin: representada por un quaternion(qs,qx,qy,qz) o una matriz dedimensin 3x3.
Vector de velocidad angular (wx,wy,wz) que describe como cambia laorientacin a lo largo del tiempo.
Otras propiedades permanecen constantes:
Masa. Posicin del centro de masas respecto al punto de referencia, en ODE estos
dos puntos coinciden.
Matriz de inercia: matriz de 3x3 que describe como la masa est distribuidaalrededor del centro de masas.
Conceptualmente cada cuerpo tiene un eje de coordenadas dentro de, que se
mueve junto al cuerpo, como se muestra en la figura. El origen de este eje es el punto
de referencia. En ODE algunos valores tales como vectores y matrices utilizan estos
ejes de coordenadas y otros utilizan el eje de coordenadas global.
Figura 2.2 Eje de coordenadas de los cuerpos.
-
8/3/2019 Proyecto de Sistemas Final)
16/102
16
Un hecho importante es que la forma del objeto no es una propiedad dinmica.
La deteccin de colisiones es la parte del motor que se ocupa de manera detallada de
ello.
Islas y cuerpos desactivados.
Los cuerpos estn conectados unos a otros por uniones. Una isla es un grupo
de cuerpos que no pueden ser separados. En otras palabras, cada cuerpo est
conectado de alguna manera con cada otro cuerpo de la isla.
Cada isla es tratada por separado en cada paso de simulacin, por lo que si hay
N islas similares, el coste de cada paso ser O(N). Una manera de disminuir este coste
sera desactivando cuerpos irrelevantes para ciertos pasos de la simulacin, ya que
estos no son actualizados durante estos pasos.
Integracin
El proceso que simula el sistema de slidos rgidos a lo largo del tiempo se
llama integracin. Con cada paso de integracin se avanza desde el tiempo actual al
tiempo correspondiente, siendo este la suma del actual mas el paso de integracin
dado. El motor calcula el estado correspondiente de los cuerpos en ese momento. Por
lo que hay que considerar:
Precisin: cuanto se aproxima el motor a la vida real . Estabilidad: cuanto aguantara el motor sin producir errores de clculo.
ODE es un motor estable, pero no muy preciso, a menos que el paso de
integracin sea pequeo. Aunque, excepto para simulaciones de alto nivel, este motor
parece fsicamente perfecto.
Acumuladores de fuerzas.
Entre paso y paso, el usuario puede llamar a funciones que apliquen fuerzas a
los cuerpos, sumndose estas en los acumuladores de fuerzas. En el siguiente paso de
simulacin estas sern consideradas, y los movimientos se harn consecuentemente.
Despus de cada paso de integracin los acumuladores de fuerzas son puestos a cero.
-
8/3/2019 Proyecto de Sistemas Final)
17/102
17
Uniones.
Las uniones, como su propio nombre indica, sirven para conectar dos cuerpos.
Se pueden entender tambin como la relacin entre las posiciones de dos cuerpos,
definiendo esta relacin las posiciones y orientaciones posibles entre los dos. Tresejemplos de uniones son:
Bola y cuenca: la bola del primer cuerpo tiene que ir unida alengranaje del segundo objeto, permitiendo un movimiento ms o menos
orbital alrededor de la unin.
Bisagra: esta unin permite un movimiento similar al de una bisagra de unapuerta.
Pistn: los cuerpos deben estar alineados, adems de tener la mismaorientacin.
Figura 2.3 Tres tipos de uniones: bola, bisagra y pistn.
Grupos de uniones.
Los grupos de uniones son contenedores que almacenan a estas. Las uniones
pueden ser aadidas a un grupo de una en una y ser destruidas con una llamada a una
funcin. Pero no pueden ser destruidas de una en una, tienen que ser destruidas
simultneamente.
Esto es muy til para las uniones de contacto, que son aadidas y quitadas del
mundo en cada paso de simulacin.
Error de unin y parmetro de reduccin de error(ERP).
Cuando se produce una unin, los cuerpos deben estar uno con respecto al
otro de tal manera que la unin permita esta situacin. Pero puede ser que esto no sea
as. Esto puede suceder por dos causas:
-
8/3/2019 Proyecto de Sistemas Final)
18/102
18
El usuario coloca un cuerpo sin tener en cuenta la posicin/orientacin delotro.
Por errores surgidos durante la simulacin, que los apartan de lasposiciones deseadas.
Existe un mecanismo para reducir este tipo de situaciones: durante cada paso
de simulacin cada unin aplica una fuerza especial para colocar los cuerpos en la
posicin y/o orientacin deseada.
Figura 2.4 Ejemplo de error en la unin.
Esta fuerza est controlada por el parmetro ERP, cuyo valor puede oscilar
entre 0 y 1.
El ERP indica que proporcin de errores de unin va a ser arreglada durante el
siguiente paso de simulacin. Si este valor es 0 no se corregir ningn error, mientras
que si el valor es 1 se corregirn todas las uniones errneas. Un valor de 1 tampoco es
recomendado, debido a que no todas las uniones se corregirn debido a
aproximaciones internas. Un valor entre 0.1 y 0.8 es el recomendado (0.2 por defecto).
Un valor global de ERP puede ser introducido de tal manera que afecte a la
mayora de uniones, pero tambin se puede introducir un valor local para que controle
solo a ciertas uniones.
Restricciones suaves.
Muchas restricciones son por naturaleza duras. Esto significa que estas
restricciones nunca son violadas. En la prctica estas restricciones pueden ser violadas
-
8/3/2019 Proyecto de Sistemas Final)
19/102
19
por errores no intencionados introducidos en el sistema, pero el ERP puede ser
configurado para solventarlos.
No todas las restricciones son duras, algunas restricciones blandas son
asignadas para poder ser violadas. Por ejemplo, las restricciones de contacto asignadas
a las colisiones son duras, como si los objetos fueran de metal, pero pueden ser
configuradas como blandas para simular materiales ms blandos, permitiendo algo de
penetracin entre estos cuerpos cuando entran en contacto.
Esta distincin entre restricciones duras y blandas es controlada mediante dos
parmetros: el ERP mencionado anteriormente y el Constraint Force Mixing(CFM),
descrito a continuacin.
A continuacin se expone una descripcin tcnica del significado del CFM.
Usualmente la ecuacin de la restriccin para cualquier unin tiene la forma:
= Donde v es el vector de velocidad de los cuerpos envueltos, J es una matriz
Jacobiana con una fila para cada grado de libertad que la matriz quita del sistema, y c
es un vector de restricciones. En el siguiente paso, un vector lambda es calculado (del
mismo tamao que c) con lo que las fuerzas aplicadas a los cuerpos son
= ODE le da una nueva perspectiva. La ecuacin de restriccin de ODE tiene la
forma:
= + Donde CFM es una matriz cuadrada diagonal. El CFM mezcla la fuerza restrictiva
resultante con la restriccin que la produce. Un valor no nulo(positivo) del CFM
permite que la ecuacin de restriccin original sea violada por una cantidad
-
8/3/2019 Proyecto de Sistemas Final)
20/102
20
proporcional a CFM veces la fuerza reparadora que es necesaria para restaurar la
restriccin. Solucionando para :
( 1 + /) = /De esta manera CFM simplemente se aade a la diagonal de la matriz del
sistema original. Usar un valor positivo del CFM tiene el beneficio adicional de evitar al
sistema ninguna particularidad y as mejorar la precisin de la factorizacin.
Cmo usar ERP y CFM?
ERP y CFM pueden ser independientemente configuradas en muchas uniones,
como en uniones de contacto, limites de uniones, etc. Para controlar las caractersticas
de la unin(o el lmite).
Con el valor de CFM a cero, la restriccin ser dura. En cambio con valor
positivo ser posible violar la restriccin. En otras palabras, la restriccin ser blanda
en proporcin a CFM, esta podr ser violada una cantidad proporcional a CFM veces la
fuerza restauradora que es necesaria para restaurar la restriccin. Con valores
negativos de CFM se obtendran resultados inesperados.
Con valores de CFM y ERP apropiados se pueden obtener varios efectos, tales
como esponjosidad, oscilacin, etc. De hecho ERP y CFM pueden ser configuradas para
tener el mismo efecto que cualquier muelle con el damping deseado. Si se tiene una
constante de muelle kp y una constante de damping kd, entonces las constantes
correspondientes de ODE son:
= / ( + ) = 1 / ( + )Donde h es el tamao del paso. Estos valores darn el mismo efecto que un
sistema con muelles y damping, con integracin de primera orden implcita.
Incrementando CFM , especialmente su valor global, reducira errores numricos.
-
8/3/2019 Proyecto de Sistemas Final)
21/102
21
Manejo de colis iones.
Las colisiones entre cuerpos entre s mismos o entre el entorno esttico son
manejadas como se explica a continuacin:
Antes de cada paso de simulacin, el usuario llama a las funciones dedeteccin de colisiones para determinar que cuerpos estn en contacto,
devolviendo una lista de puntos de contacto. Cada punto de contacto
especifica una posicin en el espacio, una normal de superficie y la
profundidad de penetracin.
Una unin especial de contacto es creada para cada punto de contacto.A la unin se le proporciona informacin acerca del contacto, como por
ejemplo la friccin presente en la superficie de contacto, como es de
suave, etc. Las uniones de contacto son recogidas en un grupo de uniones, que les
permite ser aadidas y quitadas del sistema rpidamente. La velocidad
de simulacin decrece a medida que el nmero de contactos crece, pero
existen varias estrategias para disminuir el nmero de uniones.
Cdigo de simulacin tpico.
Este cdigo procedera de la siguiente forma:
Creacin del mundo. Creacin de cuerpos en el mundo. Establecer estado (posicin, etc.) de todos los cuerpos. Crear uniones en el mundo. Conectar las uniones a los cuerpos. Fijar los parmetros de todas las uniones. Crear el mundo de colisiones y la geometra de colisiones, si es necesario. Crear un grupo de uniones para contener las uniones de contacto. Bucle:
o
Aplicar fuerzas a los cuerpos si es necesario.o Ajustar los parmetros de las uniones si es necesario.o Llamar a la deteccin de colisiones.o Crear una unin de contacto para cada punto de colisin, y poner a
esta unin en el grupo de unin de contacto.o Dar un paso de simulacin.o Quitar todas las uniones en el grupo de uniones de contacto.o Destruir el mundo dinmico y de colisiones.
-
8/3/2019 Proyecto de Sistemas Final)
22/102
22
2.1.3. Juegos en los que se usa.
Ha sido utilizado en diferentes videojuegos de distintas plataformas. Algunos de
los videojuegos que han utilizado la fsica de ODE:
BloodRayne 2 Call of Juarez Call of Juarez: Bound in Blood S.T.A.L.K.E.R and Clear Sky Resident Evil 4 Resident Evil: The Umbrella Chronicles World of Goo
Figura 2.5: World of Goo yCall of Juarez
2.2. Physx.
La PPU (Unidad de Procesamientos de Fsica) PhysX es un chip y un kit de
desarrollo diseados para llevar a cabo clculos fsicos muy complejos. Conocido
anteriormente como la SDK de NovodeX, fue originalmente diseada por AGEIA y tras
la adquisicin de AGEIA, es actualmente desarrollado por Nvidia e integrado en suschips grficos ms recientes.
El 20 de julio de 2005 Sony firm un acuerdo con AGEIA para usar la SDK de
Novodex en la consola Playstation 3. Esto provoc que muchos desarrolladores
empezaran a crear juegos muy complejos gracias a esta tecnologa. AGEIA afirm que
el PhysX era capaz de realizar estos procesos de clculos fsicos cien veces mejor que
cualquier CPU creada anteriormente.
http://en.wikipedia.org/wiki/BloodRayne_2http://en.wikipedia.org/wiki/Call_of_Juarezhttp://en.wikipedia.org/wiki/S.T.A.L.K.E.Rhttp://en.wikipedia.org/wiki/Resident_Evil_4http://en.wikipedia.org/wiki/Resident_Evil:_The_Umbrella_Chronicleshttp://en.wikipedia.org/wiki/World_of_Goohttp://en.wikipedia.org/wiki/World_of_Goohttp://en.wikipedia.org/wiki/Resident_Evil:_The_Umbrella_Chronicleshttp://en.wikipedia.org/wiki/Resident_Evil_4http://en.wikipedia.org/wiki/S.T.A.L.K.E.Rhttp://en.wikipedia.org/wiki/Call_of_Juarezhttp://en.wikipedia.org/wiki/BloodRayne_2 -
8/3/2019 Proyecto de Sistemas Final)
23/102
23
Figura 2.6 PPU Physx.
2.2.1.Caractersticas.
Las caractersticas incluyen:
Complex rigid body object physics system
La componente dinmica de los cuerpos rgidos le permite simular objetos con
un alto grado de realismo. Hace uso de conceptos fsicos como marcos de referencia,
posicin, velocidad, aceleracin, movimiento, fuerzas, el movimiento de rotacin, la
energa, la friccin, el impulso, las colisiones, las limitaciones, y as sucesivamente con
el fin de darle un kit de construccin con los que se pueden construir una amplia
variedad de tipos de dispositivos mecnicos. Esta caracterstica incluye:
Colisiones primitivas (esfera, caja, cpsula) Varios tipos de articulaciones (esfrica, de revolucin, prismticos,
cilindros, fijo)
Ragdoll avanzada, con las articulaciones. Creacin y edicin.Materiales y el modelo de friccin en la superficie de apoyo de la
colisin.
Colisin de apoyo continuo para una rpida deteccin de objetos enmovimiento.
Ray-cast y la dinmica del vehculo articulado.
NVIDIA PhysX SDK tiene la capacidad de simular los vehculos que nos
encontramos en la vida real:
Coches Raycast - cuerpo rgido Rueda de formas esfricas - sofisticado modelo de friccin del
neumtico
-
8/3/2019 Proyecto de Sistemas Final)
24/102
24
Unin basada en la suspensin - direccin y suspensin de geometrascomplejas
Multi-threaded/Multi-platform/PPU habilitado
PhysX est optimizada para el PC de un solo ncleo y multi-ncleo, Xbox 360,
PLAYSTATION 3.
Reaccin de lquidos y su simulacin
Los fluidos permiten la simulacin de lquidos y gases mediante un sistema de
partculas y emisores con la posibilidad de que el usuario pueda controlar la simulacin
de cada uno. Tambin permite la simulacin de explosiones y efectos de los desechos
Simulacin de tejidos.
La caracterstica de tela del SDK PhysX de NVIDIA permite la simulacin de
artculos hechos de tela, tales como banderas, ropa, etc.
Cuerpos Blandos
La funcin de cuerpo blando del SDK PhysX de NVIDIA permite la simulacin de
objetos deformables. Tambin se puede utilizar para artculos que no se suelen
considerar como cuerpos blandos, tales como las plantas o varias capas de tela.
Simulacin de campos de fuerzas
Los campos de fuerza son objetos SDK similar a los actores, que afectan a los
tejidos, elementos de cuerpo suave, fluido y rgido que entran en su rea de influencia.
Estos campos de fuerza permiten poner en prctica las rfagas de viento, aspiradoras ozonas con fuerzas gravitatoria.
2.2.2. Juegos en los que se usa.
2 Days to Vegas Adrenalin 2: Rush Hour Age of Empires III Age of Empires III: The WarChiefs
http://www.steelmonkeys.com/en/projects/2dtv_gamehttp://gaijinent.com/projects/adrenalin_2.htmhttp://www.destineerstudios.com/macsoftgames/products/aoe3/aoe3.htmlhttp://www.destineerstudios.com/macsoftgames/products/aoe3wc/aoe3_wc.htmlhttp://www.destineerstudios.com/macsoftgames/products/aoe3wc/aoe3_wc.htmlhttp://www.destineerstudios.com/macsoftgames/products/aoe3/aoe3.htmlhttp://gaijinent.com/projects/adrenalin_2.htmhttp://www.steelmonkeys.com/en/projects/2dtv_game -
8/3/2019 Proyecto de Sistemas Final)
25/102
25
Alpha Prime Auto Assault B.A.S.E. Jumping Bet on Soldier: Blackout Saigon Bet on Soldier: Blood of Sahara Bet on Soldier: Blood Sport Cellfactor: Combat Training Cellfactor: Revolution City of Villains Crazy Machines II Cryostasis Desert Diner Dragonshard Dusk 12 Empire Above All Empire Earth III Entropia Universe Fallen Earth Fury Gears Of War Gluk'Oza: Action GooBall Gothic 3 Gunship Apocalypse Heavy Rain Hero's Jorney Hour of Victory Hunt, The Huxley Infernal Inhabited island: Prisoner of Power Joint Task Force Magic ball 3 Mass Effect Medal of Honor: Airborne Metro 2033 Mobile Suit Gundam: Crossfire Monster Madness: Battle for Suburbia Monster Truck Maniax
http://www.autoassault.com/http://www.d3company.com/rozov_base.htmlhttp://www.bos-game.com/http://www.bos-game.com/http://www.bos-game.com/http://www.cellfactorgame.com/cfct.htmlhttp://www.action-forms.com/games/cryostasis/cryostasis.htmhttp://www.tarsier.se/desertdinerhttp://www.empireearth.com/us/index.htmhttp://www.gothic3.com/http://www.alawar.ru/games/magic-ball-3http://masseffect.bioware.com/http://masseffect.bioware.com/http://www.alawar.ru/games/magic-ball-3http://www.gothic3.com/http://www.empireearth.com/us/index.htmhttp://www.tarsier.se/desertdinerhttp://www.action-forms.com/games/cryostasis/cryostasis.htmhttp://www.cellfactorgame.com/cfct.htmlhttp://www.bos-game.com/http://www.bos-game.com/http://www.bos-game.com/http://www.d3company.com/rozov_base.htmlhttp://www.autoassault.com/ -
8/3/2019 Proyecto de Sistemas Final)
26/102
26
Myst Online: URU Live Red Steel Rise Of Nations: Rise Of Legends Roboblitz Sacred 2 Sherlock Holmes: The Awakened Showdown: Scorpion Silverfall Sovereign Symphony Sonic and the Secret Rings Speedball 2 Stalin Subway, The Stoked Rider: Alaska Alien Switchball Tension Tom Clancy's Ghost Recon Advanced Warfighter Tom Clancy's Ghost Recon Advanced Warfighter 2 Tom Clancy's Rainbow Six Vegas Tom Clancy's Splinter Cell: Double Agent (multiplayer) Tortuga: Two Treasures Two Worlds Ultra Tubes Unreal Tournament 3 Warfare Warmonger: Operation Downtown Destruction W.E.L.L. Online Winterheart's Guild
Figura 2.8Unreal Tournament 3
http://www.gametap.com/home/myst/gameinfo.htmlhttp://www.sega.com/gamesite/sonicrings/index.phphttp://www.tension-game.com/index.htmlhttp://www.ascaron.com/gb/gb_tortuga2/news/index.htmlhttp://www.gfi.su/index1.php?langid=2&idt=99&categ_id=38&men_id=11http://www.gfi.su/index1.php?langid=2&idt=99&categ_id=38&men_id=11http://www.ascaron.com/gb/gb_tortuga2/news/index.htmlhttp://www.tension-game.com/index.htmlhttp://www.sega.com/gamesite/sonicrings/index.phphttp://www.gametap.com/home/myst/gameinfo.html -
8/3/2019 Proyecto de Sistemas Final)
27/102
27
2.3. Havok.
Havok Game Dynamics SDK es un motor fsico (simulacin dinmica) utilizada
en videojuegos que recrea las interacciones entre objetos y personajes del juego. Por
lo que detecta colisiones, gravedad, masa y velocidad en tiempo real llegando a
recrear ambientes realistas y naturales.
Figura 2.9 Simulacin sobre Havok.
El motor Havok fue comprado por Intel para hacer competencia a su principal
rival, Physx.
2.3.1. Caractersticas.
En sus ltimas versiones se ejecuta por entero por hardware mediante el uso
de la GPU, liberando as de dichos clculos a la CPU. Este se apoya en las libreras
Direct3D y OpenGL compatibles con ShaderModel 3.0.
Havok Physics ofrece un gran rendimiento en el tiempo de deteccin de
colisiones y simulacin real de soluciones fsicas. Ofrece rapidez y robustez por lo que
se ha convertido en referencia dentro de la industria de los videojuegos. Tambin ha
sido elegido por los principales desarrolladores de juegos en ms de 200 ttulos enmarcha y otros en desarrollo.
-
8/3/2019 Proyecto de Sistemas Final)
28/102
28
Continuous Physics
La robustez es la exigencia ms importante de este motor. Utilizando tcnicas
innovadoras propiedad de la empresa, ofrece una fsica sin fallos que le permite
eliminar las restricciones de diseo imponer otras soluciones.
Multiplataforma
Es ampliamente utilizado en todos los juegos de plataformas de hoy en da:
Microsoft Xbox 360 , Sony PlayStation 3, Nintendo Wii , Microsoft Xbox PlayStation
2, PSP y PC.
Battle Tested (Testeo de usuario)
La documentacin de ayuda, herramientas de creacin de contenidos,
depuracin y personalizacin han hecho de este motor un motor de referencia en este
mercado. Todo ello sumado a los informes de los consumidores han conseguido hacer
una herramienta madura y de confianza para los desarrolladores de video juegos.
Flexible y fcil de usar
Havok Physics se ha utilizado en todos los gneros de juegos, y ha evolucionado
para satisfacer las necesidades de la mayora de los equipos exigentes de la industria.
Se integra fcilmente en cualquier proceso de desarrollo de juegos, tanto comerciales
como domsticos. Basado exclusivamente en las necesidades del cliente, slo se
refiere a las plataformas hardware que los clientes necesitan, y como resultado no
impone las rigideces innecesarias y es totalmente abierto en su arquitectura.
Destacados
Havok Physics proporciona un completo apoyo a las siguientes reas:
Deteccin de colisiones. Dinmica y solucin de restricciones. Control de personajes. Herramientas de creacin de contenido para 3ds Max , Maya y XSI . Depurador visual y de memoria as como herramientas de rendimiento. Solucin integrada de vehculos. SDK de reflexin y la materializacin de clases.
Havok Physics es totalmente multiproceso y multi-plataforma.
-
8/3/2019 Proyecto de Sistemas Final)
29/102
29
2.3.2. Juegos en los que se usa.
Age of Empires III Alone in the dark 5 Amped 3 Armed and Dangerous Assassin's Creed BioShock Brute Force Call of Duty 4: Modern Warfare Company of Heroes Counter-Strike: Source Crackdown Crash Nitro Kart Day of Defeat: Source Dead Rising Demon's souls Destroy All Humans! Deus Ex: Invisible War Diablo III Disaster: Day of Crisis Evil Dead Regeneration F.E.A.R. MadWorld From Russia with Love Full Spectrum Warrior Grand Theft Auto IV Half-Life: Source Half-Life Deathmatch: Source Halo 2 Halo 3 Max Payne 2: The Fall of Max Payne Medal of Honor: Pacific Assault Mercenaries: Playground of Destruction Middle-earth Online Motorstorm Painkiller Perfect Dark Zero
-
8/3/2019 Proyecto de Sistemas Final)
30/102
30
Pitfall: The Lost Expedition Psi-Ops: The Mindgate Conspiracy Red Faction 2 Robotech: Invasion Resident Evil 5 Resident Evil: The Darkside Chronicles Silent Hill 5 Sonic the Hedgehog (2006 next-generation game) Sonic Unleashed Spider-Man 2 StarCraft II Star Wars: The Force Unleashed Super Smash Bros. Brawl Swat 4 Test Drive Unlimited The Matrix: Path of Neo The Punisher Thief: Deadly Shadows Top Spin 3 Tom Clancy's Ghost Recon 2 Torque: Savage Roads Tribes: Vengeance Uru: Ages Beyond Myst WWE Crush Hour Syphon Filter Dark Mirror Syphon Filter Logan's Shadow Killzone Liberation Killzone 2 WWE SmackDown vs. Raw 2010 Halo 3: ODST
-
8/3/2019 Proyecto de Sistemas Final)
31/102
31
3. Fundamentos fsicos tericos.
Para poder entender de manera correcta el comportamiento de los objetos ysobre todo su interaccin fsica con el entorno, es necesario introducir algunos
conceptos fsicos sobre los que hemos basado nuestra implementacin.
A continuacin se explican ciertos conceptos que se utilizan en el motor.
Primero se explicarn las partculas para luego introducir los slidos rgidos, que se
pueden considerar como un caso complejo de las primeras. Luego se explicaran otros
dos conceptos que nos permitirn actuar con los slidos rgidos y las partculas como
son los springs y las colisiones.
3.1. Dinmica de partculas.
Las partculas son objetos que tienen masa, posicin, velocidad y respuesta a
las fuerzas, pero no ocupan un volumen en el espacio. Ya que son simples, las
partculas son con diferencia los objetos ms fciles de simular. A pesar de su
simplicidad, pueden exhibir una gran variedad de comportamientos interesantes. Por
ejemplo, una amplia variedad de estructuras no rgidas pueden ser construidas con la
conexin entre partculas.
El movimiento de una partcula est gobernado por la formula = o,escrito de otra manera, =/. El problema de esta ecuacin deriva en quecontiene a una segunda derivada, por lo que se convierte en una ecuacin diferencial
de segundo orden. Para poder manejar este concepto, lo convertimos en una ecuacin
de primer orden introduciendo variables adicionales. Se crea una variable pararepresentar la velocidad, dndonos dos ecuaciones diferenciales,
=
/
y
=
.
3.1.1. Sistemas de partculas bsicos.
Una simulacin de partculas incluye dos partes principales: las partculas en s
mismas y las entidades que aplican fuerzas a estas. Vamos a considerar las partculas
sin fuerzas aplicadas a ellas primero, para poder explicar cmo representarlas.
-
8/3/2019 Proyecto de Sistemas Final)
32/102
32
Las partculas constan de masa, posicin, velocidad y adems pueden ser
objeto de fuerzas. Para poder manejar los sistemas de partculas se deben aplicar los
mismos conceptos de dinmica que a los slidos rgidos, nicamente teniendo en
cuenta que estas no tienen forma ni volumen por lo que se descartan conceptos comorotacin, matriz de inercia y dems conceptos relacionados con el volumen.
Figura 3.1: Ejemplo de sistema de partculas
3.1.2. Fuerzas.
Se pueden considerar a todas las partculas iguales al contrario que a los
objetos que al estar influenciados por fuerzas externas reaccionan dependiendo de su
forma y masa.
Figura 3.2: Estructura de las partculas.
Siendo
la posicin de la partcula,
la velocidad (cuya unin dara como
resultado el espacio de fase), el acumulador de fuerzas y la masa.
-
8/3/2019 Proyecto de Sistemas Final)
33/102
33
Las fuerzas se pueden clasificar en tres tipos:
Fuerzas unarias, como la gravedad, que actan independientemente encada partcula, ejerciendo sobre ellas una fuerza constante, o una fuerza
que depende de la posicin, velocidad o tiempo de una o ms partculas. Fuerzas n-arias, como las uniones: aplican fuerzas a un conjunto concreto
de partculas.
Fuerzas de interaccin espacial, como la atraccin y la repulsin: puedenactuar en cualquier conjunto de partculas, dependiendo de su posicin.
3.1.2.1. Fuerzas unarias.
El ejemplo mas claro es la gravedad, que se rige por = , donde es unvector, cuya magnitud es la constante gravitacional. Si todas las partculas estn
sujetas a esta fuerza, para simularla se recorren las partculas aadiendo al
acumulador de fuerzas de cada una dicha fuerza.
3.1.2.2 .Fuerzas n-arias.
Un ejemplo de fuerza n-aria, siendo n= 2, es la ley de muelles de Hooke. En una
simulacin bsica de masa y muelle, los muelles son el elemento estructural que
mantiene todo unido. Las fuerzas entre dos partculas en posiciones y son: = + , =
Donde y son las fuerzas sobre y , respectivamente, = , es ladistancia en reposo, es la constante elstica del muelle y, para solucionar elproblema que hara que estas uniones oscilaran infinitamente, la constante de
Damping . es la derivada de , que es la diferencia entre velocidades delas dos partculas.
En la ecuacin anterior la fuerza del muelle es proporcional a la diferencia entre
la longitud actual y la longitud en reposo, mientras que
es proporcional a la
-
8/3/2019 Proyecto de Sistemas Final)
34/102
34
velocidad de acercamiento entre y . Fuerzas iguales y opuestas actan en cadapartcula, as como el muelle que las une.
3.1.2.3. Fuerzas de interaccin espacial.
Un muelle aplica fuerzas a dos partculas en concreto. En cambio, las fuerzas de
interaccin espacial pueden actuar en cualquier conjunto (pudiendo ser este conjunto
de cualquier tamao) de partculas. Para fuerzas de interaccin local, las partculas
empiezan a interactuar cuando se acercan y dejan de hacerlo cuando se alejan. Estos
modelos de interaccin entre partculas se pueden usar para simular fluidos.
3.2 . Dinmica de slido rgido.
Se define como solido rgido a una idealizacin de de los slidos, es decir,
cuerpos en los que se ignoran las deformaciones y en los que la distancia entre dos
puntos cualquiera del cuerpo permanecen constantes.
3.2.1. Posicin y orientacin.
La localizacin de una partcula en el espacio en un instante puede describirsecomo un vector (), que describe la traslacin de una partcula desde el origen. Losslidos rgidos son ms complicados, ya que adems hay que considerar su rotacin.
Para localizar un slido rgido en el espacio, se debe usar un vector (), que describela traslacin del cuerpo, tambin se debe describir la rotacin del cuerpo, usando una
matriz de rotacin de 3x3 (
(
)). Estas son las llamadas variables espaciales de un
cuerpo rgido.
Un slido rgido, a diferencia de una partcula, ocupa un volumen de espacio y
tiene una forma particular. Ya que en un slido rgido se tiene rotacin y traslacin, la
forma de este, se define como un espacio constante llamado espacio del cuerpo.
Dada una descripcin geomtrica del cuerpo en el espacio del cuerpo, se usa
() y () para transformar el espacio del cuerpo en el espacio del mundo. Parasimplificar ciertas ecuaciones, se requerir que nuestra descripcin del solido rgido en
-
8/3/2019 Proyecto de Sistemas Final)
35/102
35
el espacio del cuerpo ser tal que el centro de masas del cuerpo estar emplazado en
el origen (0,0,0). Se puede considerar que el centro de masa coincide con el centro
geomtrico del cuerpo. Para describir la forma del cuerpo requerimos que este centro
geomtrico este en el punto (0,0,0) en el espacio del cuerpo. Si () especifica larotacin del cuerpo sobre el centro de masas, entonces un vector r del espacio delcuerpo ser rotado al espacio del mundo ()en el tiempo t. As, si 0 es un puntoarbitrario en el slido rgido, en el espacio del cuerpo, entonces la rotacin del espacio
del mundo de 0 es el resultado de primero rotar p0 sobre el origen y luegotrasladarlo:
= + ()Como el centro de masas esta en el origen, la localizacin en el espacio del
mundo del centro de masas es dada directamente por (). Esto permite dar unsignificado a () diciendo que () es la localizacin del centro de masas en elespacio del mundo en el tiempo .
3.2.2. Velocidad lineal.
Es necesario saber cmo varan la posicin y la orientacin a lo largo del
tiempo. Para ello necesitamos saber la derivada de () y de () . Si () es laposicin del centro de masas en el espacio del mundo, su derivada es la velocidad del
centro de masas en el espacio del mundo:
= ()Si imaginamos que la orientacin del cuerpo esta fija, entonces el nico
movimiento que el cuerpo puede hacer es una translacin. () da la velocidad deeste movimiento.
Figura 3.3: Slido rgido con velocidad angular y lineal.
-
8/3/2019 Proyecto de Sistemas Final)
36/102
36
3.2.3. Velocidad angular.
Para representar un giro se utiliza el vector de velocidad angular
. Su modulo
representa la rapidez de giro mientras que su direccin indica alrededor de que eje
gira.
Mientras que () y () estn relacionados por () = (), para R(t) y w(t)no es tan simple ya que R(t) no puede ser w(t) ya que R(t) es una matriz y w(t) es un
vector. La expresin viene dada por:
= Donde:
= 0 0
0
3.2.4. Masa del slido rgido.
La masa de un slido rgido es importante en el estudio de los
comportamientos de estos cuerpos ya que influye en el clculo de las velocidades
tanto angular como lineal.
La masa se define como la resistencia que ofrece un cuerpo a ser desplazado.
Aunque la masa de un cuerpo se puede calcular como la suma de todas las partculas
elementales que lo componen, en nuestro motor estas se suponen dadas por el
usuario.
El centro de masas de un slido rgido es el punto alrededor del cual se
encuentra la masa uniformemente distribuida. El centro de masas en el espacio delmundo se definira:
-
8/3/2019 Proyecto de Sistemas Final)
37/102
37
CM= ()
Donde es la masa de cada de las partculas que la componen, es laposicin actual de cada particula y es la masa total del cuerpo. Tambien se obtieneque en las coordenadas del cuerpo:
= 0 = 000
El momento de inercia indica la distribucin radial de la masa de un cuerpo a lolargo de un eje. Este atributo indica la resistencia de un cuerpo a sufrir una rotacin,
pero dependiendo de qu eje se coja como referencia. Se puede expresar el momento
de inercia como un tensor, que es un elemento matemtico que tiene magnitud y
direccin. El momento de inercia se puede formular como un tensor de segundo
orden, en forma de matriz 3x3:
=
Donde:
= (2 + 2) = =
= (2 + 2) = = = (2 + 2) = =
-
8/3/2019 Proyecto de Sistemas Final)
38/102
38
3.3. Springs.
Los Springs son uniones elsticas que simulan el comportamiento de resortes, y
se rigen por la ley de elasticidad de Robert Hooke. En fsica, la ley de elasticidad de
Hooke o ley de Hooke, originalmente formulada para casos del estiramiento
longitudinal, establece que el alargamiento unitario que experimenta un material
elstico es directamente proporcional a la fuerza aplicada F:
= = La forma ms comn de representar matemticamente la Ley de Hooke es
mediante la ecuacin del muelle o resorte, donde se relaciona la fuerza F ejercida
sobre el resorte con la elongacin o alargamiento producido:
= Donde kse llama constante elstica del resorte y
es su elongacin o variacin
que experimenta su longitud, en nuestro caso la longitud del vector que une susextremos. sta frmula es suficiente para resolver el problema pues aplicando sta
fuerza a los puntos de unin conseguimos simular la unin elstica entre cuerpos de
una manera realista y precisa.
Figura 3.4: Spring entre cuerpos.
-
8/3/2019 Proyecto de Sistemas Final)
39/102
39
3.4. Deteccin de colisiones.
Para simular el comportamiento de las colisiones de los slidos, el primer paso
es determinar si existen colisiones en un estado del mundo determinado comparando
los objetos dos a dos para seguidamente dar la respuesta adecuada en los casos
positivos. Hay muchos mtodos de deteccin de colisiones que se diferencian en
complejidad y tiempo de clculo, siendo unos adecuados solo para determinadas
geometras y otros genricos que pueden ser utilizados con cualquier objeto.
La deteccin de colisiones es un problema muy costoso en tiempo de clculo,
ya que segn el algoritmo utilizado puede llegar a necesitar comparar todos los
vrtices de un objeto con todos los vrtices del otro, por ste motivo es frecuente
establecer varios niveles de profundidad a la hora de detectar una colisin, de forma
que primero se aplican los test ms gruesos, que requieren menos tiempo de ejecucin
a modo de filtro, y luego se aplican los tests ms precisos y que requieren una mayor
cantidad de clculos con los objetos que no fueron descartados en niveles anteriores.
Es importante destacar que los mtodos de deteccin de colisiones utilizan
solamente conceptos geomtricos y no tienen en cuenta las caractersticas dinmicas
del objeto como la velocidad o masa sino que solo tiene en cuenta su localizacin en el
espacio y su geometra o forma.
3.4.1. Deteccin de colisiones esfera-esfera.
sta es la deteccin ms sencilla de realizar y por tanto la que menos clculos
necesita. Basta con comprobar que la distancia entre los centros de las esferas es
menor que la suma de sus radios para determinar que existe colisin entre ellas.
Figura 3.5: Colisin esfera-esfera.
-
8/3/2019 Proyecto de Sistemas Final)
40/102
40
Si se cumple que
-
8/3/2019 Proyecto de Sistemas Final)
41/102
41
Figura 3.7: Colisin vrtice-esfera.
Con este test, podemos comprobar que un vrtice de un objeto est dentro de
todos los planos del otro, lo que significa penetracin
3.4.4. Deteccin de colisiones arista-plano.
En este caso, lo primero que se tiene que comprobar es que las rectas que
contienen las aristas de un objeto, interseccionan con los planos de las caras del otro,
entrando en juego ms conceptos geomtricos. Es una comprobacin bastante
costosa.
Figura 3.8: Colisin vrtice-esfera.
-
8/3/2019 Proyecto de Sistemas Final)
42/102
42
Los puntos obtenidos de corte, se pasan al test de vrtice-plano que es el
encargado de detectar la colisin,
3.5. Respuesta a las colisiones.
Antes de definir el concepto de impulso que es al fin y al cabo el encargado de
dar respuesta a las colisiones se debe introducir el concepto de velocidad relativa de
un choque.
3.5.1. Velocidades relativas.
La velocidad relativa entre los objetos implicados en un choque, se define como
el producto escalar de la normal del choque y la diferencia de las velocidades de los
objetos (Velocidad cuerpo A Velocidad cuerpo B). Tomando por convenio que en el
punto de choque, la normal siempre va de B hacia A, en funcin del valor de la
velocidad relativa se concluye:
Vrel > 0: Los objetos se estn alejando luego ya se ha dado respuesta a lacolisin.
Vrel = 0: Cuerpos en contacto estable, se procede a dormirlos. Este valor esidlico y se necesita un pequeo umbral de valores sobre el que poderdecidir.
Vrel < 0: Los cuerpos se estn acercado luego la respuesta se dar solo eneste caso.
Figura 3.9: Significado de la velocidad relativa en funcin de su valor
-
8/3/2019 Proyecto de Sistemas Final)
43/102
43
3.5.2. Concepto de impulso.
El impulso J, se puede considerar como una gran fuerza que acta durante un
corto periodo de tiempo. Como explicamos antes, la velocidad tiene una componente
lineal y otra angular, por cual vamos a explicar cmo se produce el cambio en cada
componente.
El cambio en la velocidad lineal que produce J, si se aplica a un cuerpo de masa
M es:
=
Esto equivale a que el cambio del momento lineal es P = J. Al ser aplicado en
un punto p, al igual que las fuerzas, produce un torque . Su valor es: = ()
produce a su vez en cambio en el momento angular: L= . Este cambio afecta a la velocidad angular en el momento 0: = 1(0)
Cuando dos objetos colisionan, les aplicamos un impulso que cambia sus
velocidades, por lo que podemos escribir el impulso con magnitudj, y con direccin de
la normal de la colisin como:
=(0)Por lo cual, el impulso acta de manera positiva sobre el objeto A y de manera
negativa sobre el objeto B
-
8/3/2019 Proyecto de Sistemas Final)
44/102
44
Figura 3.10: Impulso.
Segn las leyes empricas de colisin sin friccin se tiene que:
+ = Siendo
+ la velocidad relativa obtenida despus de aplicar el impulso,
la
velocidad relativa de antes del impulso y el coeficiente de restitucin, el cul tomavalores entre 0 1. Para calcular el impulso que tenemos que aplicar tendremosque calcular el valor de j, para ello expresaremos + en funcin de y de j, parapoder despejarlo con facilidad.
+ = + + +
Donde
= (0)Por tanto
+ =
+
=
+
(
0)
-
8/3/2019 Proyecto de Sistemas Final)
45/102
45
+ = + = + 1(0) = + 1 (0)( (0))Sustituyendo
+ = + (0) + ( + 10 0)
= + +(0) + (10 0)
= +(0 + 10 0 )Realizamos los mismos clculos para la velocidad del punto de B, pero teniendo
en cuenta que el impulso tiene el signo contrario:
+
= (0
+ 1
0 0)Calculamos la resta de las velocidades relativas
+ + = +(0 + 0 + (10 0)+ (10 0) )
Calculamos + , teniendo en cuenta que 0 tiene mdulo 1, con lo cul0. 0 = 1+ = 0(+ + )
-
8/3/2019 Proyecto de Sistemas Final)
46/102
46
+ = 0( +0
+
0
+ (10 0)
+ (10 0) )
+ = + 1 + 1 + (10 0) + (10 0)Sabiendo que
+ =
y sustituyendo obtenemos la magnitud del
impulso:
= (1 + )(1 + 1 + 10 0 + 10 0 )
-
8/3/2019 Proyecto de Sistemas Final)
47/102
47
4. Resolucin de Ecuaciones Diferenciales
Ordinarias.
Los motores de fsica requieren la resolucin de ecuaciones diferenciales, ya
que necesitan saber los valores de magnitudes derivadas como la velocidad y
aceleracin.
Hay una gran variedad de resolutores numricos para las ecuaciones
diferenciales como pueden ser el mtodo del punto medio, mtodo de Runge-Kutta 4
o el mtodo de Euler, siendo este ltimo el que se implemento por su sencillez.
4.1. Problemas de valor inicial.
Las ecuaciones diferenciales describen la relacin entre una funcin
desconocida y sus derivadas. Resolver una ecuacin diferencial es encontrar una
funcin que satisface esta relacin, cumpliendo algunas condiciones adicionales. Este
motor se ocupa principalmente de un tipo particular de problemas, llamado problemas
de valor inicial. En un problema de valor inicial cannico, el comportamiento del
sistema se describe mediante una ecuacin diferencial ordinaria (EDO) de la forma
=( , )En dos dimensiones () dibuja una curva que describe el movimiento de un
punto en el plano. En cualquier punto de la funcin puede ser evaluado paraproporcionar un vector de dos dimensiones, por lo que fdefine un campo de vectores
en el plano (ver figura 1). El vector en
es la velocidad que el punto mvil p en
movimiento debe tener si es que se mueve a travs dex
(si se mueve, aunque podrapermanecer inmvil). El futuro movimiento estar definido por . La trayectoriadescrita por a travs deforma la curva integral del campo vectorial.
-
8/3/2019 Proyecto de Sistemas Final)
48/102
48
Figura 4. 1. Curvas solucin a un problema de valor inicial.
Se describi como una funcin tanto de y , pero la funcin derivada puedeo no puede depender directamente del tiempo. Si lo hace, entonces no slo el punto se mueve, el campo vectorial del mismo se mueve, de modo que la velocidad no slo
depende de dnde est, s ino tambin de cuando llegue all. En ese caso, la derivada depende en el tiempo de dos formas: en primer lugar, los vectores derivados se
mueven, y en segundo lugar, el punto , porque se mueve en una trayectoria(), vediferentes vectores derivados en diferentes momentos. Esta dualidad en el tiempo no
debe llevar a confusin si se toma como referencia el dibujo de una partcula flotando
a lo largo de un campo vectorial ondulado.
4.2. Soluciones numricas.
El motor se centra exclusivamente en la resolucin numrica, en la cual se
toman pasos discretos tomando como inicio (0) . Para tomar un paso se utiliza lafuncin derivada para calcular un cambio aproximado en , , a lo largo de unintervalo de tiempo , para luego incrementar en para obtener un nuevo valorde
. Para calcular la solucin numrica, la funcin derivada
es considerada como
una caja negra: se proporcionan valores numricos para y , recibiendo a cambio unvalor numrico para . Los mtodos numricos operan haciendo una o ms de estasevaluaciones en cada paso.
4.2.1. Mtodo de Euler.
El mtodo numrico ms simple se llama el mtodo de Euler. Llamaremos anuestro valor inicial para , como 0 = 0y una estimacin de a un instante
-
8/3/2019 Proyecto de Sistemas Final)
49/102
49
posterior 0 + como (0 + ) donde es un parmetro de paso. El mtodo deEuler simplemente calcula tomando un paso en la derivacin,
0 + = 0 + (0)Se puede utilizar un campo vectorial de dos dimensiones para visualizar el
mtodo de Euler. En lugar de la curva integral real, se sigue un camino poligonal,cada lado del cual se determina mediante la evaluacin del vector al principio eincrementndolo por . Vase la figura 4. 2.
-Pasos de tiempo discretos.
-A mayor tamao de paso mayor
error.
+
=
+
(
,
)
Figura 4.2 .En vez de la curva integral real, la solucin aproximada sigue un camino
poligonal, obtenido al evaluarse la derivada al inicio de cada rama. Aqu se muestra
como la precisin de la solucin empeora con el incremento del paso .
Aunque simple, el mtodo de Euler no es exacto. Consideremos el caso de una
funcin de dos dimensiones cuyas curvas integrales son crculos concntricos. Unpunto
regido por
se supone que siempre tiene que orbitar en el mismo circulo que
empez. En cambio, con cada paso de Euler, se mover en lnea recta a un crculo demayor radio, de modo que su trayectoria siga una espiral hacia afuera. La disminucinde la amplitud de paso se reduce la tasa de esta deriva hacia el exterior, pero nunca la
eliminara completamente.
Por otra parte, el mtodo de Euler puede ser inestable. Se considera una
funcin de una dimensin = , que debera disminuir exponencialmente el punto
a cero. Para amplitudes de paso suficientemente pequeas se obtiene un
comportamiento razonable, pero cuando > 1/, tenemos que|| > ||, por lo que
-
8/3/2019 Proyecto de Sistemas Final)
50/102
50
la solucin oscila alrededor de cero. Ms all de la oscilacin diverge y el sistema se
colapsa. Vase la figura 4.
Figura 4.3 Poca precisin: El error convierte a x(t) en una espiral de nuestra eleccin
en vez de en un crculo.
El mtodo de Euler no es eficaz. La mayora de los mtodos de solucin
numrica pasan casi todos su tiempo de realizando las evaluaciones derivadas, por loque el coste computacional por paso est determinado por el nmero de evaluaciones
por paso. Aunque el mtodo de Euler slo requiere de una evaluacin cada paso, la
verdadera eficacia de un mtodo depende del tamao del tamao del paso que este le
permite dar(preservando precisin y estabilidad) as como el coste por paso.
4.2.2. Mtodo del punto medio.
El mtodo del punto medio es un mtodo de segundo orden del algoritmoRunge-Kutta. El valor inicial es (0,0).Las aproximaciones sucesivas ( ,).para > 0son generadas por:
1 = ( ,)2 = ( + 2 , + 1/2)
-
8/3/2019 Proyecto de Sistemas Final)
51/102
51
+1 = + 2)
(
+1) =
+
4.2.3. Runge-Kutta de cuarto orden.
El mtodo de Runge-Kutta de cuarto orden tienes una precisin elevada. El
valor inicial es (0,0). Sucesivas aproximaciones ( , ) para > 0 estn generadaspor:
1 = ( ,)2 = ( +
2, + 1/2)
3 = ( + 2 , + 2/2)
4 = ( + , + 3)+1 = + 6 (1 + 22 + 23 +4)(+1) = +
-
8/3/2019 Proyecto de Sistemas Final)
52/102
52
-
8/3/2019 Proyecto de Sistemas Final)
53/102
53
5. Arquitectura del motor.
En este apartado para explicar la arquitectura del motor se muestra undiagrama de clases que permite ver la dependencia entre estas. Posteriormente se
explican los diferentes mdulos por separado.
5.1. Diagrama de clases.
El diagrama que se muestra a continuacin muestra, las principales clases que
forman nuestro motor y como se unen entre ellas. Se han obviado algunas clases quesirven de apoyo al proyecto, como las que implementan las operaciones matemticas
o la plantilla de las listas de objetos.
Figura 5.1: Diagrama de clases de la aplicacin
-
8/3/2019 Proyecto de Sistemas Final)
54/102
54
Para poder llevar a cabo simulaciones, necesitamos tener definido el estado del
mundo sobre el que operaremos para llegar al estado siguiente tras transcurrir un
tiempo determinado, la clase CWorld es la que define el estado, y la clase CSimulator
es la encargada de operar sobre el estado actual apoyndose de la claseCCollisionEngine para la deteccin y respuesta de colisiones.
La clase CWorld contendr todos los objetos que componen el mundo a
simular, estos objetos pueden ser del tipo:
CWall: Muros o paredes que delimitan el mundo. CRigidBody: Slidos rgidos. CWorldSpring: Uniones elsticas entre slidos y el mundo. CBodySpring: Uniones elsticas entre dos slidos. CParticleSystem: Sistemas de partculas. CForce: Fuerzas que actan sobre los objetos.
La clase CSimulator es la encargada de operar con el estado del mundo, hay
diferentes mtodos de simulacin que extienden esta clase, en nuestro caso hemos
utilizado el mtodo de integracin de Euler con la ayuda de la clase CEulerSimulator,
pero el sistema permite aadir distintos mtodos a utilizar que extiendan de la clase
CSimulator.
Por ltimo tenemos el mdulo de deteccin y respuesta a las colisiones que
denominamos CCollisionEngine y que contiene los mtodos que posibilita la deteccin
de colisiones entre distintos objetos del mundo y da la respuesta adecuada en caso de
deteccin. sta clase es utilizada por la clase CSimulator para la simulacin.
5.2. Mundo.
5.2.1. Clase CWorld.
La clase CWorld representa el mundo que se va a simular, es un contenedor
para todos los objetos y caractersticas del mismo y adems ofrece mtodos para la
modificacin y consulta del estado.
-
8/3/2019 Proyecto de Sistemas Final)
55/102
55
Un mundo se define por: El tamao para sus tres coordenadas (ancho, alto,
largo), el vector de gravedad y las listas de objetos que contiene (muros, rgidos,
springs, particlesystems y fuerzas).
Para crear un mundo basta con llamar a su constructor pasando comoparmetros las dimensiones que deseemos, esto crear un mundo vaco de las
dimensiones indicadas con un vector de gravedad nulo.
CWorld * pWorld = new CWorld(LongX, LongY, LongZ);
Para obtener el valor de las dimensiones podemos utilizar los siguientes
mtodos:
real WorldXLength = pWorld->GetWorldXLength();
real WorldYLength = pWorld->GetWorldYLength();
real WorldZLength = pWorld->GetWorldZLength();
Figura 5.2:Representacin del mundo
-
8/3/2019 Proyecto de Sistemas Final)
56/102
56
En la mayora de los casos querremos incluir una aceleracin en alguna
direccin que afecte a todos los objetos por igual, esto lo haremos cambiando el
GravityVector a travs del siguiente mtodo que recibe como parmetro el vector
deseado:
pWorld->SetGravityVector(vector_3(r(0),r(0),r(-10)));
Para obtener el valor del GravityVector utilizaremos:
vector_3 gravity = pWorld->GetGravityVector();
Se pueden aadir planos para delimitar el mundo, estos planos actan como
paredes, conteniendo a los cuerpos dentro del espacio que delimitan, para aadirlos se
utiliza el siguiente mtodo que recibe como parmetros la instancia del objeto CWall
que queremos aadir.
pWorld->AddWall(wall);
Para averiguar el nmero de muros que hay en el mundo:
unsignedint numMuros = pWorld->GetNumWalls();
Para eliminar el muro en la posicin i:
-
8/3/2019 Proyecto de Sistemas Final)
57/102
57
pWorld->RemoveWallPos(i);
Para eliminar un muro determinado (CWall* w):
pWorld->RemoveWall(w);
Podemos acceder al muro en la posicin i mediante
CWall* wall = pWorld->GetWall(unsignedint i);
Para agregar cuerpos rgidos al mundo haremos uso del siguiente mtodo que
recibe como parmetro la instancia de la clase CRigidBody que queremos aadir:
pWorld->AddBody(Body);
Para averiguar el numero de slidos que hay en el mundo
unsignedint numBodies = pWorld->GetNumBodies();
Para eliminar el slido en la posicin i:
-
8/3/2019 Proyecto de Sistemas Final)
58/102
58
pWorld->RemoveBody(i);
Para eliminar un slido determinado (CRigidBody* w):
pWorld->RemoveBody(w);
Podemos acceder al slido en la posicin i mediante
CRigidBody* body = pWorld->GetBody(unsignedint i);
Los WorldSprings son uniones elsticas entre un punto fijo del espacio y un
vrtice de un determinado cuerpo, para aadirlas o eliminarlas se utiliza el siguiente
mtodo que recibe como parmetro la instancia de la clase CWorldSpring que
queremos aadir o eliminar.
pWorld->AddWorldSpring(worldSpring);
Para averiguar el numero de WorldSprings que hay en el mundo
unsignedint numWSprings = pWorld->GetNumWorldSprings();
Para eliminar el WorldSpring en la posicin i:
-
8/3/2019 Proyecto de Sistemas Final)
59/102
59
pWorld->RemoveWorldSpring(i);
Para eliminar un WorldSpring determinado (CWorldSpring * w):
pWorld->RemoveWorldSpring(w);
Podemos acceder al WorldSpring en la posicin i mediante
CWorldSpring* ws = pWorld->GetWorldSpring(unsignedint i);
Los BodySprings son uniones elsticas entre dos slido. Los mtodos son
similares a los que tratan con los WorldSpring:
pWorld->AddBodySpring(bodySpring);
unsignedint numBSprings = pWorld->GetNumBodySprings();
pWorld->RemoveBodySpring(i);
pWorld->RemoveBodySpring(b);
CBodySpring* bs = pWorld->GetBodySpring(unsignedint i);
Los ParticleSprings son uniones elsticas entre dos partculas o una partcula y
un punto del espacio. Sus mtodos son:
pWorld->AddParticleSpring(particleSpring);
unsignedint numPSprings = pWorld->GetNumParticleSprings();
-
8/3/2019 Proyecto de Sistemas Final)
60/102
60
pWorld->RemoveParticleSpring(i);
pWorld->RemoveParticleSpring(b);
CParticlepring* bs = pWorld->GetParticleSpring(unsignedint i);
Para agregar/eliminar Sistemas de partculas haremos uso de los siguientes
mtodos que reciben como parmetro la instancia de la clase CParticleSystem que
queremos aadir o eliminar:
pWorld->AddParticleSystem(ps);
Para averiguar el numero de ParticleSystems que hay en el mundo
unsignedint numPs = pWorld->GetNumParticleSystems();
Para eliminar el ParticleSystem en la posicin i:
pWorld->RemoveParticleSystem (i);
Para eliminar un ParticleSystemdeterminado (CParticleSystem* ps):
pWorld->RemoveParticleSystem (ps);
Podemos acceder al ParticleSystem en la posicin i mediante
-
8/3/2019 Proyecto de Sistemas Final)
61/102
61
CParticleSystem* ps = pWorld->GetParticleSystem(unsignedint i);
5.3. Sistemas de partculas.
Figura 5.3: Clases correspondientes a partculas
5.3.1. Clase CParticleSystem (clase abstracta).
Clase contenedor de partculas, clase abstracta que ofrece los mtodos bsicos
para el manejo de sistemas de partculas. Sus atributos son los siguientes:
bool collisionCheckActive; /* Indica si se resuelven las
colisiones para este sistema*/
tLista *aParticles; /* Array de punteros a
partculas */
real Kvd; /* Viscous Drag constant */
real particlesMass; /* masa aproximada de las partculas*/
real varMass; /* masa de las partculas*/
-
8/3/2019 Proyecto de Sistemas Final)
62/102
62
int numMaxParticles; /* n maximo de partculas*/
eeal color[4]; /* Color de las particulas*/
real varColor[4]; /* Variacin del color de las particulas*/
real life; /* Vida de las particulas, -1 = no mueren*/
real varLife; /* Variacin de la vida */
real tam; /* Tamao de las particulas*/
real varTam; /* Variacin del tamao de las particulas*/
Los mtodos que ofrece son:
Constructor:
CParticleSystem(real mass,real varMass, real Kvd, int
numParticles,real color[4],real varColor[4],real life,real
varLife,real tam,real varTam);
Destructor:
virtual ~CParticleSystem();
Acceso y modificacin de atributos:
int GetNumParticles();
real GetKvd();
void SetCollisionCheckActive(bool v);
inlinebool GetCollisionCheckActive();
CParticle* GetParticle(int i);
void RemoveParticle(int i);
real GetLife();
-
8/3/2019 Proyecto de Sistemas Final)
63/102
63
Mtodos virtuales puros que deben implementar los distintos sistemas de
partculas que se creen.
Para controlar la accin a realizar en caso de una colisin se implementara el
siguiente mtodo pasando como parmetro la partcula que colisiona y su posicin en
la lista de partculas.
virtualvoid ParticleCollisionEvent(CParticle*p, int pos)=0;
Para controlar la accin a realizar para cada paso de simulacin se utiliza el
siguiente mtodo pasndole como parmetros la partcula a simular, su posicin en la
lista y el tiempo que hay que simular.
virtual bool SimulateStepParticle(CParticle*p, int pos,real
DeltaTime)=0;
5.3.1.1. Clase CParticle.
Clase interna a CParticleSystem, que implementa el comportamiento de las
partculas, sus atributos son:
real m; /* Masa */
vector_3 x; /* Posicin */
vector_3 v;/* Velocidad */
vector_3 f;/* Acumulador de fuerzas */
real l;/* Tiempo de vida restante*/
real tam;/* Tamao*/
real color[4];/* Color*/
-
8/3/2019 Proyecto de Sistemas Final)
64/102
64
Los mtodos que ofrece son:
Constructor:
CParticle(real m, vector_3 x,vector_3 v,real l,real tam,
real color[4]);
Acceso y modificacin de atributos:
vector_3 GetPos();
vector_3 GetVel();
void SetVel(vector_3 v);
vector_3 GetForce();
void SetForce(vector_3 f);
void AddForce(vector_3 f);
real GetLife();
real GetTam();
real GetColor();
real GetMass();
5.3.2. Clase CPSExplosion.
Sistema de partculas con las siguientes caractersticas adicionales:
Origen: punto en el que nacen todas las partculas. Velocidad mnima de las partculas. Variacin de la velocidad de cada partcula.
A partir de stos valores se crean las partculas con una velocidad de direccin
aleatoria y mdulo la velocidad mnima ms una variacin aleatoria de forma que
simulan explosiones ya que cada partcula es lanzada a una velocidad y direccin semialeatorias.
-
8/3/2019 Proyecto de Sistemas Final)
65/102
65
Figura 5.4: Ejemplos de sistemas de partculas
5.3.3. Clase CPSLluvia.
Sistema de partculas con las siguientes caractersticas adicionales:
Origen: localizacin del sistema en el mundo. Mrgenes: plano sobre el que nacen las partculas. Altura muerte: representa el suelo, punto en el que la partcula se
elimina para volver a crearse
Velocidad inicial: mdulo y direccin de la velocidad de las partculas.
Variacin de la velocidad: vector que indica cmo puede variar lavelocidad de cada partcula.
Con stos valores se parametrizan stos sistemas de partculas, creados para
dar soporte a efectos del tipo humo, lluvia, nieve, chorros de partculas.
Figura 5.5: Mas ejemplos de sistemas de partculas
-
8/3/2019 Proyecto de Sistemas Final)
66/102
66
5.3.4. Clase CPSEmpty.
Sistema de partculas neutro o vacio, es simplemente un contenedor de
partculas, utilizado para trabajar manualmente con ellas. A este contenedor se le
pueden aadir partculas para crear objetos complejos como slidos deformables y
telas.
Figura 5.6: Ejemplo de aplicacin de CPSEmpty
5.3.5. Clase CParticleSpring.
Un ParticleSpring es una unin elstica entre dos partculas. Hay dos
constructores para crear los dos tipos de ParticleSprings que existen.
ParticleSpring entre partculas: Se llama al constructor pasndole como
parmetros las dos partculas, la constante de Hooke que lo caracteriza , una constante
de amortiguacin y la longitud que tiene el Spring.
CParticleSpring(CParticle *p1,CParticle *p2,real Ks,real Kd,real
longitud);
ParticleSpring entre partcula y punto del mundo: Se llama al constructor
pasndole como parmetros la partcula, el punto del mundo al que se engancha, la
-
8/3/2019 Proyecto de Sistemas Final)
67/102
67
constante de Hooke que lo caracteriza , una constante de amortiguacin y la longitud
que tiene el Spring.
5.4. Slidos rgidos
Figura 5.7: Clases de Slidos Rgidos
5.4.1. Clase CRigidBody.
Para la simulacin de slidos rgidos se ha creado a clase CRigidBody, sta clase
tiene todos los datos necesarios para definir un slido y se apoya en una lista de
configuraciones (CConfig), cada configuracin se almacenan los datos del slido quevaran en cada simulacin de forma que se tienen varias configuraciones almacenadas
que deben de ser gestionadas por el resolutor. Por ejemplo, el resolutor de Euler solo
necesita dos configuraciones, anterior y presente. Tambin tienen un objeto de la
clase CGeoBox que define su geometra para ser utilizada por el motor de colisiones.
real Kdl; // factor de amortiguamiento lineal
real Kda; // factor de amortiguamiento angular
real OneOverMass; //inversa de la masa
matrix_3x3 InverseBodyInertiaTensor;//inversa del tensor de
inercia
real CoefficientOfRestitution;//coeficiente de rozamiento
tLista *aBodyBoundingVertices; //Array de vrtices que
componen el objeto tomando el origen como referencia
CGeoBox* boundingBox;//Estructura auxiliar que define la
geometra del objeto
bool inmovil,dormido;//valores booleanos de estado.
-
8/3/2019 Proyecto de Sistemas Final)
68/102
68
CConfig ** aConfigurations;//array de configuraciones.
Los mtodos que ofrece la clase CRigidBody son:
Constructor: Crea un slido con una geometra determinada:
CRigidBody(CGeoBox* box);
Destructor: Para destruir un slido:
~CRigidBody();
CalculateVertices: Mtodo que calcula los vrtices de la configuracinindicada segn su matriz de orientacin y el centro de masas.
void CalculateVertices(int ConfigurationIndex);
Acceso y modificacin de sus atributos:
real GetKdl(void){return Kdl;};
void SetKdl(real v){Kdl=v;};
real GetKda(void){return Kda;};
void SetKda(real v){Kda=v;};
bool GetInmovil(void);
bool GetDormido(void);
void SetInmovil(bool v);
void SetDormido(bool v);
real GetOneOverMass(void);
void SetOneOverMass(real v);
-
8/3/2019 Proyecto de Sistemas Final)
69/102
69
real GetCoefficientOfRestitution(void);
void SetCoefficientOfRestitution(real v);
matrix_3x3 GetInverseBodyInertiaTensor(void);
void SetInverseBodyInertiaTensor(matrix_3x3 m);
CConfig* GetConfiguration(int i);
void Integrate(real DeltaTime,int ConfIndex,int Target);
int GetNumberOfBoundingVertices( void);
vector_3 GetBodyBoundingVertice(int i);
void AddBodyBoundingVertice(vector_3 v);
CGeoBox* GetGeoBox();
5.4.1.1 .Clase CConfig,
La clase CConfig, es una clase interna de CRigidBody, contiene los datos de un
slido que pueden variar durante un paso de simulacin estos atributos son:
vector_3 CMVelocity; //velocidad del centro de masas.
vector_3 AngularMomentum; //momento angular del objeto.
vector_3 CMPosition; //posicin del centro de masas.
matrix_3x3 Orientation; //orientacin del objeto.
matrix_3x3 InverseWorldInertiaTensor; //inversa del tensor de
inercia
vector_3 AngularVelocity; //velocidad angular
vector_3 CMForce; //acumulador de fuerzas
vector_3 Torque; //acumulador de fuerzas de rotacin
tLista *aBoundingVertices; //lista de vrtices
tomando como referencia el centro de masas.
Los mtodos que ofrece la clase CConfig son todos los necesarios para permitir
el acceso y modificacin de todos sus atributos.
-
8/3/2019 Proyecto de Sistemas Final)
70/102
70
5.4.2. Clase CGeoBox.
Esta clase contiene la informacin de la geometra del objeto, la utiliza
principalmente el motor de colisiones. Sus atributos son:
float radio; //para una primera aproximacin
tLista* lCaras; //lista de caras del objeto
Los mtodos que ofrece la clase CGeoBox son todos los necesarios parapermitir el acceso y modificacin de todos sus atributos.
CGeoBox(float radio);
~CGeoBox();
void AddCara(QuadFace lv);
QuadFace GetCara(int index);
float GetRadio();
int GetNumCaras();
int GetNumAristas();
vector_3* GetArista(int i,tLista* lista);
Figura 5.8 y 5.9: Ejemplos de slidos rgidos
-
8/3/2019 Proyecto de Sistemas Final)
71/102
71
5.5. Mdulo de simulacin.
Figura 5.10: Clases para la simulacin
5.5.1. Clase CSimulator (abstracta, permite distintos simuladores).
Es la encargada de simular el comportam