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


2/102

2


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.


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.3. Havok. ...................................................................................................... 27

2.3.1. Caractersticas. .................................................................................. 27


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


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


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


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/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


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.


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.


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


12/102

12


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.


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.


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.


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.


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:


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


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


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.


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.


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


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


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


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/


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


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.


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.


29/102

29


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


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


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.


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.


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


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


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.


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:


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) = =


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.


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.


40/102

40

Si se cumple que


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.


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


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


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)


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(+ + )


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 )


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.


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


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


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)


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) = +


52/102

52


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


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.


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


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:


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:


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:


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


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


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*/


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


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*/


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.


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


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


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.


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


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.


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


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

Proyecto de Sistemas Final)

Documents

Transcript of Proyecto de Sistemas Final)