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

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

Browse Source
This commit is contained in:
chappuis.daniel 2009-02-13 11:26:51 +00:00
parent f4e061911c
commit 7afb8ba7f0
9 changed files with 189 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
sources/demo/Context.cpp
View File

@ -19,19 +19,21 @@
// Libraries // Libraries
#include "Context.h" #include "Context.h"
#include "../reactphysics3d/reactphysics3d.h"
#include <iostream> #include <iostream>
#include <vector> #include <vector>
// We want to use the ReactPhysics3D namespace
using namespace reactphysics3d;
// Constructor of the class Context // Constructor of the class Context
Context::Context() { Context::Context() {
// We add some objects in the context at the beginning ---> THESE THINGS WILL BE STORE IN A TEXT FILE // We add some objects in the context at the beginning ---> THESE THINGS WILL BE STORE IN A TEXT FILE
Cube* cube1 = new Cube(Object::Position(-2.0, 1.0, -6.0), 2.0); Cube* cube1 = new Cube(Vector3D(-2.0, 3, -6.0), 2.0, 10.0);
Cube* cube2 = new Cube(Object::Position(0.0, 1.5, 6.0), 3.0); Cube* cube2 = new Cube(Vector3D(0.0, 3, 6.0), 3.0, 5.0);
Cube* cube3 = new Cube(Object::Position(4.0, 4.0, -2.0), 2.0); Cube* cube3 = new Cube(Vector3D(4.0, 3.0, -2.0), 2.0, 0.01);
Plane* plane1 = new Plane(Object::Position(0.0, 0.0, 0.0), 20.0, 30.0, Vector3D(-1.0, 0.0, 0.0), Vector3D(0.0, 0.0, 1.0)); Plane* plane1 = new Plane(Vector3D(0.0, 0.0, 0.0), 20.0, 30.0, Vector3D(-1.0, 0.0, 0.0), Vector3D(0.0, 0.0, 1.0), 10.0);
addObject(cube1); addObject(cube1);
addObject(cube2); addObject(cube2);
@ -43,7 +45,7 @@ Context::Context() {
// Destructor of the class Context // Destructor of the class Context
Context::~Context() { Context::~Context() {
// Delete all the objects in vectObjects // Delete all the objects in vectObjects
for(int i=0; i<vectObjects.size(); ++i) { for(unsigned int i=0; i<vectObjects.size(); ++i) {
delete vectObjects[0]; delete vectObjects[0];
} }
} }

1
sources/demo/Context.h
View File

@ -22,7 +22,6 @@
// Libraries // Libraries
#include "Objects.h" #include "Objects.h"
#include <vector> #include <vector>
// Class Context // Class Context

114
sources/demo/Objects.cpp
View File

@ -21,42 +21,41 @@
#include "Objects.h" #include "Objects.h"
//#include <windows.h> // To avoid an error due to the #include <GL/glut.h> //#include <windows.h> // To avoid an error due to the #include <GL/glut.h>
#include <GL/freeglut.h> #include <GL/freeglut.h>
#include <math.h> #include <GL/gl.h>
#include <GL/glu.h>
#include <cmath>
#include <iostream>
// ----- Class Object ----- // // ----- Class Object ----- //
// Constructor of the class Object // Constructor of the class Object
Object::Object(const Position& position) { Object::Object(const Vector3D& position, const Kilogram& mass, const Matrix3x3& inertiaTensor)
this->position = position; :rigidBody(new RigidBody(position, mass, inertiaTensor)) {
} }
// Destructor of the class Object // Destructor of the class Object
Object::~Object() { Object::~Object() {
// Delete the rigid body object
delete rigidBody;
}
// Return the pointer to the rigid body
RigidBody* Object::getRigidBody() {
return rigidBody;
} }
// ----- Structure Position ----- //
// Constructor without arguments of the structure Position
Object::Position::Position() {
x = 0.0;
y = 0.0;
z = 0.0;
}
// Constructor of the structure Position
Object::Position::Position(double x, double y, double z) {
this->x = x;
this->y = y;
this->z = z;
};
// ----- Class Cube ----- // // ----- Class Cube ----- //
// Static attributes
const Matrix3x3 Cube::inertiaTensor;
// Constructor of the class Cube // Constructor of the class Cube
Cube::Cube(const Position& position, float size) Cube::Cube(const Vector3D& position, float size, const Kilogram& mass)
:Object(position) { :Object(position, mass, Matrix3x3(1.0/12.0*mass.getValue()*2*size*size, 0.0, 0.0,
0.0, 1.0/12.0*mass.getValue()*2*size*size, 0.0,
0.0, 0.0, 1.0/12.0*mass.getValue()*2*size*size)) {
this->size = size; this->size = size;
} }
@ -66,24 +65,46 @@ Cube::~Cube() {
} }
// Method to draw the cube // Method to draw the cube
void Cube::draw() const { void Cube::draw() const {
// Translation of the cube to its position
glTranslatef(position.x, position.y, position.z); // Get the interpolated state of the rigid body
BodyState state = rigidBody->getInterpolatedState();
// Position of the cube
double x = state.getPosition().getX();
double y = state.getPosition().getY();
double z = state.getPosition().getZ();
// Orientation of the cube
Vector3D orientationAxis;
double orientationAngle;
state.getOrientation().getRotationAngleAxis(orientationAngle, orientationAxis);
// Draw the cube // Translation of the cube to its position
glutSolidCube(size); glTranslatef(x, y, z);
// Rotation of the cube according to its orientation
glRotatef(orientationAngle/pi*180.0, orientationAxis.getX(), orientationAxis.getY(), orientationAxis.getZ());
// Draw the cube
glutSolidCube(size);
} }
// ----- Class Plane ----- // // ----- Class Plane ----- //
// Constructor of the class Plane // Constructor of the class Plane
Plane::Plane(const Position& position, float width, float height, const Vector3D& d1, const Vector3D& d2) Plane::Plane(const Vector3D& position, float width, float height, const Vector3D& d1, const Vector3D& d2, const Kilogram& mass)
:Object(position) { :Object(position, mass, Matrix3x3(1.0/12.0*mass.getValue()*height*height, 0.0, 0.0,
0.0, 1.0/12.0*mass.getValue()*(width*width+height*height), 0.0,
0.0, 0.0, 1.0/12.0*mass.getValue()*width*width)) {
this->width = width; this->width = width;
this->height = height; this->height = height;
this->d1 = d1; this->d1 = d1;
this->d2 = d2; this->d2 = d2;
// By default Planes in the demo cannot move
rigidBody->setIsMotionEnabled(false);
// Compute the unit normal vector of the plane by a cross product // Compute the unit normal vector of the plane by a cross product
normalVector = d1.crossProduct(d2).getUnit(); normalVector = d1.crossProduct(d2).getUnit();
@ -95,9 +116,18 @@ Plane::~Plane() {
} }
// Method used to draw the plane // Method used to draw the plane
void Plane::draw() const { void Plane::draw() const {
// Translation of the cube to its position
glTranslatef(position.x, position.y, position.z); // Get the interpolated state of the rigid body
BodyState state = rigidBody->getInterpolatedState();
// Get the position of the rigid body
double x = state.getPosition().getX();
double y = state.getPosition().getY();
double z = state.getPosition().getZ();
// Translation of the cube to its position
glTranslatef(x, y, z);
float halfWidth = width / 2.0; float halfWidth = width / 2.0;
float halfHeight = height / 2.0; float halfHeight = height / 2.0;
@ -105,17 +135,17 @@ void Plane::draw() const {
// Draw the plane // Draw the plane
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(1.0, 1.0, 1.0); glColor3f(1.0, 1.0, 1.0);
glVertex3f(position.x + d1.getX() * halfWidth + d2.getX() * halfHeight , position.y + d1.getY() * halfWidth + d2.getY() * halfHeight glVertex3f(x + d1.getX() * halfWidth + d2.getX() * halfHeight , y + d1.getY() * halfWidth + d2.getY() * halfHeight
, position.z + d1.getZ() * halfWidth + d2.getZ() * halfHeight); , z + d1.getZ() * halfWidth + d2.getZ() * halfHeight);
glNormal3f(normalVector.getX(), normalVector.getY(), normalVector.getZ()); glNormal3f(normalVector.getX(), normalVector.getY(), normalVector.getZ());
glVertex3f(position.x + d1.getX() * halfWidth - d2.getX() * halfHeight , position.y + d1.getY() * halfWidth - d2.getY() * halfHeight glVertex3f(x + d1.getX() * halfWidth - d2.getX() * halfHeight , y + d1.getY() * halfWidth - d2.getY() * halfHeight
, position.z + d1.getZ() * halfWidth - d2.getZ() * halfHeight); , z + d1.getZ() * halfWidth - d2.getZ() * halfHeight);
glNormal3f(normalVector.getX(), normalVector.getY(), normalVector.getZ()); glNormal3f(normalVector.getX(), normalVector.getY(), normalVector.getZ());
glVertex3f(position.x - d1.getX() * halfWidth - d2.getX() * halfHeight , position.y - d1.getY() * halfWidth - d2.getY() * halfHeight glVertex3f(x - d1.getX() * halfWidth - d2.getX() * halfHeight , y - d1.getY() * halfWidth - d2.getY() * halfHeight
, position.z - d1.getZ() * halfWidth - d2.getZ() * halfHeight); , z - d1.getZ() * halfWidth - d2.getZ() * halfHeight);
glNormal3f(normalVector.getX(), normalVector.getY(), normalVector.getZ()); glNormal3f(normalVector.getX(), normalVector.getY(), normalVector.getZ());
glVertex3f(position.x - d1.getX() * halfWidth + d2.getX() * halfHeight , position.y - d1.getY() * halfWidth + d2.getY() * halfHeight glVertex3f(x - d1.getX() * halfWidth + d2.getX() * halfHeight , y - d1.getY() * halfWidth + d2.getY() * halfHeight
, position.z - d1.getZ() * halfWidth + d2.getZ() * halfHeight); , z - d1.getZ() * halfWidth + d2.getZ() * halfHeight);
glEnd(); glEnd();
} }

51
sources/demo/Objects.h
View File

@ -32,48 +32,45 @@ using namespace reactphysics3d;
// ----- Class Object (abstract) ----- // // ----- Class Object (abstract) ----- //
// Represent an object of the simulation // Represent an object of the simulation
class Object { class Object {
public : protected :
// Structure Object::Position RigidBody* rigidBody; // Rigid Body that represents the object
struct Position {
double x; // x coordinate
double y; // y coordinate
double z; // z coordinate
// Methods public :
Position(); // Constructor without arguments of the structure Position Object(const Vector3D& position, const Kilogram& mass, const Matrix3x3& inertiaTensor); // Constructor of the class Object
Position(double x, double y, double z); // Constructor of the structure Position virtual ~Object(); // Destructor of the class Object
} position; // Position of the object
Object(const Position& position); // Constructor of the class Object virtual void draw() const =0; // pure virtual method to draw the object
virtual ~Object(); // Destructor of the class Object RigidBody* getRigidBody(); // Return the pointer to the rigid body
virtual void draw() const =0; // pure virtual method to draw the object
}; };
// ----- Class Cube ----- // // ----- Class Cube ----- //
// Represente a Cube in the simulation // Represente a Cube in the simulation
class Cube : public Object { class Cube : public Object {
private : private :
float size; // Size of a side in the cube float size; // Size of a side in the cube
static const Matrix3x3 inertiaTensor; // Inertia tensor of a cube
public : public :
Cube(const Position& position, float size); // Constructor of the class cube Cube(const Vector3D& position, float size, const Kilogram& mass); // Constructor of the class cube
virtual ~Cube(); // Destructor of the class cube virtual ~Cube(); // Destructor of the class cube
virtual void draw() const; // Method to draw the cube virtual void draw() const; // Method to draw the cube
}; };
// ----- Class Plane ---- // // ----- Class Plane ---- //
// Represent a plane in the simulation // Represent a plane in the simulation
class Plane : public Object { class Plane : public Object {
private :
float width; // Width of the plane
float height; // Height of the plane
Vector3D d1; // Unit vector in the plane
Vector3D d2; // Unit vector in the plane
Vector3D normalVector; // Unit normal vector of the plane
public : public :
float width; // Width of the plane Plane(const Vector3D& position, float width, float height, const Vector3D& d1, const Vector3D& d2, const Kilogram& mass); // Constructor of the class Plane
float height; // Height of the plane virtual ~Plane(); // Destructor of the class Plane
Vector3D d1; // Unit vector in the plane virtual void draw() const; // Method to draw the plane
Vector3D d2; // Unit vector in the plane
Vector3D normalVector; // Unit normal vector of the plane
Plane(const Position& position, float width, float height, const Vector3D& d1, const Vector3D& d2); // Constructor of the class Plane
virtual ~Plane(); // Destructor of the class Plane
virtual void draw() const; // Method to draw the plane
}; };
#endif #endif

6
sources/demo/OutSideCamera.cpp
View File

@ -31,7 +31,7 @@ OutSideCamera::OutSideCamera() {
heightFromFloor = 20.0; heightFromFloor = 20.0;
horizontalAngleRotation = 0; horizontalAngleRotation = 0;
verticalAngleRotation = 45; verticalAngleRotation = 45;
distanceFromOrigin = 10.0; distanceFromOrigin = 40.0;
lookAtPoint.setAllValues(0.0, 0.0, 0.0); lookAtPoint.setAllValues(0.0, 0.0, 0.0);
// Update the position of the camera // Update the position of the camera
@ -61,7 +61,7 @@ void OutSideCamera::updatePosition() {
void OutSideCamera::modifyHorizontalAngleRotation(int screenDistance, float fps) { void OutSideCamera::modifyHorizontalAngleRotation(int screenDistance, float fps) {
// Update the horizontal rotation angle of the camera // Update the horizontal rotation angle of the camera
horizontalAngleRotation = (horizontalAngleRotation + int(screenDistance * 60.0 / fps)) % 360; horizontalAngleRotation = (horizontalAngleRotation + int(screenDistance * 700.0 / fps)) % 360;
// Update the position and the view vector of the camera // Update the position and the view vector of the camera
updatePosition(); updatePosition();
@ -72,7 +72,7 @@ void OutSideCamera::modifyHorizontalAngleRotation(int screenDistance, float fps)
void OutSideCamera::modifyVerticalAngleRotation(int screenDistance, float fps) { void OutSideCamera::modifyVerticalAngleRotation(int screenDistance, float fps) {
// Update the vertical rotation angle of the camera // Update the vertical rotation angle of the camera
verticalAngleRotation = verticalAngleRotation + (screenDistance * 60.0 / fps); verticalAngleRotation = verticalAngleRotation + (screenDistance * 700.0 / fps);
// Vertical angle limits // Vertical angle limits
if (verticalAngleRotation > 89) { if (verticalAngleRotation > 89) {

3
sources/demo/Scene.h
View File

@ -22,8 +22,7 @@
// Libraries // Libraries
#include "Context.h" #include "Context.h"
#include "OutSideCamera.h" #include "OutSideCamera.h"
#include <SDL/SDL.h> #include <SDL/SDL.h>
#include <GL/freeglut.h> // Used only to draw cubes #include <GL/freeglut.h> // Used only to draw cubes
#include <GL/gl.h> #include <GL/gl.h>

88
sources/demo/Simulation.cpp
View File

@ -20,18 +20,25 @@
// Libraries // Libraries
#include "Simulation.h" #include "Simulation.h"
#include "ReactDemo.h" #include "ReactDemo.h"
#include <iostream> #include <iostream>
// We want to use the ReactPhysics3D namespace
using namespace reactphysics3d;
// Constructor of the class Simulation // Constructor of the class Simulation
Simulation::Simulation() { Simulation::Simulation()
:world(new DynamicWorld(Vector3D(0.0, -9.81, 0.0))), engine(world, Time(0.01)){
simRunning = false; simRunning = false;
mouseButtonPressed = false; mouseButtonPressed = false;
nbFrame = 0;
lastFrameTime = 0.0;
fps = 0.0; fps = 0.0;
} }
// Destructor of the class Simulation // Destructor of the class Simulation
Simulation::~Simulation() { Simulation::~Simulation() {
// Delete the physics world object
delete world;
} }
// Method to start the simulation // Method to start the simulation
@ -40,26 +47,71 @@ void Simulation::start() {
scene.init(); scene.init();
// Reshape the windows for the first time // Reshape the windows for the first time
scene.reshape(WINWIDTH, WINHEIGHT); scene.reshape(WINWIDTH, WINHEIGHT);
// Add every rigid body to the dynamic world
for (int i=0; i<context.getNbObjects(); ++i) {
world->addBody(context.getObject(i).getRigidBody());
}
// Activation of the simulation // Activation of the simulation
simRunning = true; simRunning = true;
// Get the current time // Get the current time
currentFrameTime = SDL_GetTicks(); lastFrameTime = SDL_GetTicks();
// Initialize the display time
engine.initializeDisplayTime(Time(SDL_GetTicks()/1000.0));
// Start the physics simulation
engine.start();
// Main loop of the simulation // Main loop of the simulation
while(simRunning) { while(simRunning) {
// Check if an SDL event occured and make the apropriate actions // Check if an SDL event occured and make the apropriate actions
checkEvents(); checkEvents();
double time = SDL_GetTicks()/1000.0;
std::cout << "Time : " << time << std::endl;
// Update the display time
engine.updateDisplayTime(Time(time));
// Update the physics
engine.update();
// Display the actual scene // Display the actual scene
scene.display(context); scene.display(context);
// Compute the fps (framerate) // Compute the fps (framerate)
computeFps(); computeFps();
std::cout << "FPS : " << fps << std::endl;
//std::cout << fps << std::endl; BodyState state = context.getObject(0).getRigidBody()->getInterpolatedState();
Vector3D velocity = context.getObject(0).getRigidBody()->getInterpolatedState().getLinearVelocity();
//std::cout << "Velocity 0 : " << velocity.getX() << ", " << velocity.getY() << ", " << velocity.getZ() << ")" << std::endl;
double x = state.getPosition().getX();
double y = state.getPosition().getY();
double z = state.getPosition().getZ();
std::cout << "Position Cube 0 : (" << x << ", " << y << ", " << z << ")" << std::endl;
std::cout << "linear velocity 0 : " << velocity.length() << std::endl;;
BodyState state1 = context.getObject(1).getRigidBody()->getInterpolatedState();
Vector3D velocity1 = context.getObject(1).getRigidBody()->getInterpolatedState().getLinearVelocity();
//std::cout << "Velocity 1 : " << velocity1.getX() << ", " << velocity1.getY() << ", " << velocity1.getZ() << ")" << std::endl;
double x1 = state1.getPosition().getX();
double y1 = state1.getPosition().getY();
double z1 = state1.getPosition().getZ();
std::cout << "Position Cube 1 : (" << x1 << ", " << y1 << ", " << z1 << ")" << std::endl;
std::cout << "linear velocity 1 : " << velocity1.length() << std::endl;
BodyState state2 = context.getObject(2).getRigidBody()->getInterpolatedState();
Vector3D velocity2 = context.getObject(2).getRigidBody()->getInterpolatedState().getLinearVelocity();
//std::cout << "Velocity 2 : " << velocity2.getX() << ", " << velocity2.getY() << ", " << velocity2.getZ() << ")" << std::endl;
double x2 = state2.getPosition().getX();
double y2 = state2.getPosition().getY();
double z2 = state2.getPosition().getZ();
std::cout << "Position Cube 2: (" << x2 << ", " << y2 << ", " << z2 << ")" << std::endl;
std::cout << "linear velocity 2 : " << velocity2.length() << std::endl;;
} }
} }
@ -96,10 +148,8 @@ void Simulation::checkEvents() {
// If the mouse moved // If the mouse moved
case SDL_MOUSEMOTION: if (SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(1)) { case SDL_MOUSEMOTION: if (SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(1)) {
// Rotation of the outSideCamera // Rotation of the outSideCamera
// TODO : Problem here when we try to implement fps indepence (if we try to scene.getOutSideCamera().modifyHorizontalAngleRotation(event.motion.xrel, fps);
// replace 60 by the variable fps scene.getOutSideCamera().modifyVerticalAngleRotation(event.motion.yrel, fps);
scene.getOutSideCamera().modifyHorizontalAngleRotation(event.motion.xrel, 30);
scene.getOutSideCamera().modifyVerticalAngleRotation(event.motion.yrel, 30);
} }
} }
} }
@ -107,11 +157,17 @@ void Simulation::checkEvents() {
// Compute the framerate (fps) of the application // Compute the framerate (fps) of the application
void Simulation::computeFps() { void Simulation::computeFps() {
double lastFrameTime = currentFrameTime;
// Get the current time // Increment the number of frame in the last second
currentFrameTime = SDL_GetTicks(); nbFrame++;
// Compute the new framerate // Get the current time
fps = 1000 / double(currentFrameTime - lastFrameTime); double currentTime = SDL_GetTicks();
// Compute the framerate
if (currentTime - lastFrameTime > 1000.0) {
fps = nbFrame * 1000.0/(currentTime-lastFrameTime);
lastFrameTime = currentTime;
nbFrame = 0;
}
} }

10
sources/demo/Simulation.h
View File

@ -22,16 +22,20 @@
// Librairies // Librairies
#include "Context.h" #include "Context.h"
#include "Scene.h" #include "Scene.h"
#include "../reactphysics3d/reactphysics3d.h"
// Class Simulation // Class Simulation
class Simulation { class Simulation {
private : private :
Scene scene; // Scene object for displaying the simulation Scene scene; // Scene object for displaying the simulation
Context context; // Context of the simulation Context context; // Context of the simulation
rp3d::DynamicWorld* world; // Pointer to the dynamic world that contains bodies of the simulation
rp3d::DynamicEngine engine; // Dynamic engine for the physics of the simulation
bool simRunning; // True if the simulation is running and false otherwise bool simRunning; // True if the simulation is running and false otherwise
bool mouseButtonPressed; // True if the left mouse button is pressed bool mouseButtonPressed; // True if the left mouse button is pressed
double currentFrameTime; // Current frame time double lastFrameTime; // Last frame time
int nbFrame; // Number of frame (used to compute the framerate)
double fps; // Framerate of the application double fps; // Framerate of the application
void computeFps(); // Compute the framerate of the application void computeFps(); // Compute the framerate of the application

2
sources/demo/main.cpp
View File

@ -87,7 +87,7 @@ int initSDL() {
} }
// Define the window title and the window icon // Define the window title and the window icon
SDL_WM_SetCaption("React Demo 0.01", NULL); SDL_WM_SetCaption("React Demo 0.02", NULL);
// Get the state of the Double Buffer parameter // Get the state of the Double Buffer parameter
int nValue; int nValue;