mrq/reactphysics3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: https://reactphysics3d.googlecode.com/svn/trunk@275 92aac97c-a6ce-11dd-a772-7fcde58d38e6

Browse Source
This commit is contained in:
chappuis.daniel 2010-02-11 11:31:28 +00:00
parent c1f25eed31
commit 9930d25424
4 changed files with 0 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
sources/reactphysics3d/engine/CollisionEngine.cpp
View File

@ -1,85 +0,0 @@
/***************************************************************************
* Copyright (C) 2009 Daniel Chappuis *
****************************************************************************
* This file is part of ReactPhysics3D. *
* *
* ReactPhysics3D is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* ReactPhysics3D is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with ReactPhysics3D. If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
// Libraries
#include "CollisionEngine.h"
#include <cfloat>
#include <GL/freeglut.h> // TODO : Remove this in the final version
#include <GL/gl.h> // TODO : Remove this in the final version
// We want to use the ReactPhysics3D namespace
using namespace reactphysics3d;
// Constructor
CollisionEngine::CollisionEngine(PhysicsWorld* world, const Time& timeStep)
:DynamicEngine(world, timeStep) {
}
// Destructor
CollisionEngine::~CollisionEngine() {
}
// Update the physics simulation
void CollisionEngine::update() {
// While the time accumulator is not empty
while(timer.getAccumulator() >= timer.getTimeStep().getValue()) {
// Remove all old collision contact constraints
world->removeAllContactConstraints();
// Compute the collision detection
if (collisionDetection.computeCollisionDetection(world)) {
// TODO : Delete this ----------------------------------------------------------
for (std::vector<Constraint*>::const_iterator it = world->getConstraintListStartIterator(); it != world->getConstraintListEndIterator(); ++it) {
RigidBody* rigidBody1 = dynamic_cast<RigidBody*>((*it)->getBody1());
RigidBody* rigidBody2 = dynamic_cast<RigidBody*>((*it)->getBody2());
rigidBody1->setIsMotionEnabled(false);
rigidBody2->setIsMotionEnabled(false);
}
// -----------------------------------------------------------------------------
}
// For each body in the dynamic world
for(std::vector<Body*>::const_iterator it = world->getBodyListStartIterator(); it != world->getBodyListEndIterator(); ++it) {
// If the body is a RigidBody and if the rigid body motion is enabled
RigidBody* rigidBody = dynamic_cast<RigidBody*>(*it);
if (rigidBody && rigidBody->getIsMotionEnabled()) {
// Update the state of the rigid body with an entire time step
updateBodyState(rigidBody, timer.getTimeStep());
}
}
// Update the timer
timer.update();
}
// For each body in the the dynamic world
for(std::vector<Body*>::const_iterator it = world->getBodyListStartIterator(); it != world->getBodyListEndIterator(); ++it) {
// If the body is a RigidBody and if the rigid body motion is enabled
RigidBody* rigidBody = dynamic_cast<RigidBody*>(*it);
if (rigidBody && rigidBody->getIsMotionEnabled()) {
// Update the interpolation factor of the rigid body
// This one will be used to compute the interpolated state
rigidBody->setInterpolationFactor(timer.getInterpolationFactor());
}
}
}

50
sources/reactphysics3d/engine/CollisionEngine.h
View File

@ -1,50 +0,0 @@
/***************************************************************************
* Copyright (C) 2009 Daniel Chappuis *
****************************************************************************
* This file is part of ReactPhysics3D. *
* *
* ReactPhysics3D is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* ReactPhysics3D is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with ReactPhysics3D. If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifndef COLLISIONENGINE_H
#define COLLISIONENGINE_H
// Libraries
#include "DynamicEngine.h"
#include "../collision/CollisionDetection.h"
// ReactPhysics3D namespace
namespace reactphysics3d {
/* -------------------------------------------------------------------
Class CollisionEngine :
This class implements the physics engine where bodies can
collide. This class inherits from the class DynamicEngine.
-------------------------------------------------------------------
*/
class CollisionEngine : public DynamicEngine {
private :
CollisionDetection collisionDetection; // Collision detection
// ConstraintSolver constraintSolver; // Constraint solver
public :
CollisionEngine(PhysicsWorld* world, const Time& timeStep); // Constructor
virtual ~CollisionEngine(); // Destructor
virtual void update(); // Update the physics simulation
};
} // End of the ReactPhysics3D namespace
#endif

104
sources/reactphysics3d/engine/DynamicEngine.cpp
View File

@ -1,104 +0,0 @@
/****************************************************************************
* Copyright (C) 2009 Daniel Chappuis *
****************************************************************************
* This file is part of ReactPhysics3D. *
* *
* ReactPhysics3D is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* ReactPhysics3D is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with ReactPhysics3D. If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
// Libraries
#include "DynamicEngine.h"
#include "../integration/RungeKutta4.h"
#include "../integration/ExplicitEuler.h"
#include "../integration/SemiImplicitEuler.h"
// We want to use the ReactPhysics3D namespace
using namespace reactphysics3d;
// Constructor
DynamicEngine::DynamicEngine(PhysicsWorld* world, const Time& timeStep)
:PhysicsEngine(world, timeStep) {
// Check if the pointer to the world is not NULL
if (world == 0) {
// Throw an exception
throw std::invalid_argument("Exception in PhysicsEngine constructor : World pointer cannot be NULL");
}
// Creation of the Semi-Implicit Euler integration algorithm
integrationAlgorithm = new SemiImplicitEuler();
}
// Copy-constructor
DynamicEngine::DynamicEngine(const DynamicEngine& engine)
:PhysicsEngine(engine) {
integrationAlgorithm = engine.integrationAlgorithm;
}
// Destructor
DynamicEngine::~DynamicEngine() {
// Destroy the integration algorithm
delete integrationAlgorithm;
}
// Update the state of a rigid body
void DynamicEngine::updateBodyState(RigidBody* const rigidBody, const Time& timeStep) {
// If the gravity force is on
if(world->getIsGravityOn()) {
// Apply the current gravity force to the body
rigidBody->getCurrentBodyState().setForce(world->getGravity());
}
// The current body state of the body becomes the previous body state
rigidBody->updatePreviousBodyState();
// Integrate the current body state at time t to get the next state at time t + dt
integrationAlgorithm->integrate(rigidBody->getCurrentBodyState(), timer.getTime(), timeStep);
// If the body state has changed, we have to update some informations in the rigid body
rigidBody->update();
}
// Update the physics simulation
void DynamicEngine::update() {
// Check if the physics simulation is running
if (timer.getIsRunning()) {
// While the time accumulator is not empty
while(timer.getAccumulator() >= timer.getTimeStep().getValue()) {
// For each body in the dynamic world
for(std::vector<Body*>::const_iterator it = world->getBodyListStartIterator(); it != world->getBodyListEndIterator(); ++it) {
// If the body is a RigidBody and if the rigid body motion is enabled
RigidBody* rigidBody = dynamic_cast<RigidBody*>(*it);
if (rigidBody && rigidBody->getIsMotionEnabled()) {
// Update the state of the rigid body
updateBodyState(rigidBody, timer.getTimeStep());
}
}
// Update the timer
timer.update();
}
// For each body in the dynamic world
for(std::vector<Body*>::const_iterator it = world->getBodyListStartIterator(); it != world->getBodyListEndIterator(); ++it) {
// If the body is a RigidBody and if the rigid body motion is enabled
RigidBody* rigidBody = dynamic_cast<RigidBody*>(*it);
if (rigidBody && rigidBody->getIsMotionEnabled()) {
// Update the interpolation factor of the rigid body
// This one will be used to compute the interpolated state
rigidBody->setInterpolationFactor(timer.getInterpolationFactor());
}
}
}
}

58
sources/reactphysics3d/engine/DynamicEngine.h
View File

@ -1,58 +0,0 @@
/****************************************************************************
* Copyright (C) 2009 Daniel Chappuis *
****************************************************************************
* This file is part of ReactPhysics3D. *
* *
* ReactPhysics3D is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as published *
* by the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* ReactPhysics3D is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with ReactPhysics3D. If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifndef DYNAMICENGINE_H
#define DYNAMICENGINE_H
// Libraries
#include "PhysicsEngine.h"
#include "../integration/IntegrationAlgorithm.h"
#include "../body/Body.h"
#include "../body/RigidBody.h"
#include "../body/BodyState.h"
#include "PhysicsWorld.h"
#include "../physics/physics.h"
// Namespace ReactPhysics3D
namespace reactphysics3d {
/* -------------------------------------------------------------------
Class DynamicEngine :
This class that represents a physics engine where we use
the dynamics to simulate the movement of bodies. The class
DynamicEngine inherits from the class PhysicsEngine.
-------------------------------------------------------------------
*/
class DynamicEngine : public PhysicsEngine {
protected :
IntegrationAlgorithm* integrationAlgorithm; // Integration algorithm used to solve differential equations of movement
void updateBodyState(RigidBody* const rigidBody, const Time& timeStep); // Update the state of a rigid body
public :
DynamicEngine(PhysicsWorld* world, const Time& timeStep); // Constructor
DynamicEngine(const DynamicEngine& engine); // Copy-constructor
virtual ~DynamicEngine(); // Destructor
virtual void update(); // Update the physics simulation
};
}
#endif