C:/development/RenderTools/src/factory/PhysicsWorld.cpp

Go to the documentation of this file.

#include "PhysicsWorld.h"

namespace RenderTools {

PropertyContainerPtr                                    PhysicsWorld::s_instance = PropertyContainerPtr();
float                                                                   PhysicsWorld::s_step = 0.01f;
bool                                                                    PhysicsWorld::s_initialized = false;

#ifdef RT_BULLET
btDefaultCollisionConfiguration *               PhysicsWorld::s_config = 0;
btCollisionDispatcher *                                 PhysicsWorld::s_dispatcher = 0;
btSequentialImpulseConstraintSolver *   PhysicsWorld::s_solver = 0;
btDiscreteDynamicsWorld *                               PhysicsWorld::s_world = 0;
btAlignedObjectArray<btRigidBody*>              PhysicsWorld::s_bodies;
btAxisSweep3 *                                                  PhysicsWorld::s_cache = 0;
btClock                                                                 PhysicsWorld::s_clock;
#endif

PropertyPtr PhysicsWorld::create( const XMLNodePtr & xml ){
        if( ! s_instance ){
                s_instance = PropertyContainerPtr( new RelationalNode() );
                createProperty( s_instance.get(), "step", & s_step );
                s_instance->setProperties( xml, false );
        }
        else{
                Error::error( Error::REINITIALIZATION, __FILE__, __LINE__ );
        }
        return( s_instance );
}

void PhysicsWorld::initialize(){
        if( s_initialized ){
                return;
        }

#ifdef RT_BULLET
        while( s_bodies.size() ){
                deleteRigidBody( s_bodies[ 0 ] );
        }

        if( s_solver ){
                //delete solver
                delete s_solver;
        }

        if( s_cache ){
                //delete broadphase
                delete s_cache;
        }

        if( s_dispatcher ){
                //delete dispatcher
                delete s_dispatcher;
        }

        if( s_config ){
                // delete collision configuration
                delete s_config;
        }

        // setup the collision config
        s_config = new btDefaultCollisionConfiguration();

        // use the default collision dispatcher
        s_dispatcher = new btCollisionDispatcher( s_config );

        // default solver
        s_solver = new btSequentialImpulseConstraintSolver();

        Vec3 worldMin( - 2.0 * WARP_X, - 2.0 * WARP_Y, - 10.0 );
        Vec3 worldMax( + 2.0 * WARP_X, + 2.0 * WARP_Y, + 10000.0 );
        s_cache = new btAxisSweep3( toSim( worldMin ), toSim( worldMax ), MAX_OBJECTS );

        // create the world
        s_world = new btDiscreteDynamicsWorld( s_dispatcher, s_cache, s_solver, s_config );

        // set gravity in m/s^2
        s_world->setGravity( btVector3( 0.0, 0.0, -100.0 ) );

        // make a plane for the PhysicsWorld //! TODO move this somewhere else
        btCollisionShape * ground = new btBoxShape( btVector3( 3 * WARP_X, 3 * WARP_Y, 10 ) );

        // create a motionState for it
        btTransform groundTransform;
        groundTransform.setOrigin( btVector3( 0, 0, -10 ) );
        btDefaultMotionState * motionState = new btDefaultMotionState( groundTransform );
        btRigidBody::btRigidBodyConstructionInfo rbInfo( btScalar(0.0), motionState, ground, btVector3( 0.0, 0.0, 0.0 ) );
        btRigidBody * body = new btRigidBody( rbInfo );
        body->setFriction( 0.5 );

        //add the body to the dynamics world
        addRigidBody( body );
#endif
}

#ifdef RT_BULLET
void PhysicsWorld::addRigidBody( btRigidBody * const & body ){
        s_bodies.push_back( body );
        if( ! s_world ){
                Error::error( Error::NULL_POINTER, __FILE__, __LINE__ );
        }
        s_world->addRigidBody( body );
}

void PhysicsWorld::deleteRigidBody( btRigidBody * const & body ){
        if( body ){
                s_bodies.remove( body );
                for( int i = 0; i < body->getNumConstraintRefs(); i++ ){
                        s_world->removeConstraint( body->getConstraintRef( i ) );
                        body->removeConstraintRef( body->getConstraintRef( i ) );
                }
                s_world->removeRigidBody( body );
        }
}

void PhysicsWorld::deleteConstraint( btTypedConstraint * const & constraint ){
        if( constraint ){
                s_world->removeConstraint( constraint );
                delete constraint;
        }
}
#endif

void PhysicsWorld::update( void ){
#ifdef RT_BULLET
        s_world->stepSimulation( s_step, 30, s_step );
#endif
}

float PhysicsWorld::toSim( float x ){
        return( x * 0.1 );
}

float PhysicsWorld::fromSim( float x ){
        return( x * 10.0 );
}

Vec3 PhysicsWorld::fromSim( const Vec3 & x ){
        Vec3 r;
        r[0] = fromSim( x[0] );
        r[1] = fromSim( x[1] );
        r[2] = fromSim( x[2] );
        return( r );
}

Mat4 PhysicsWorld::fromSim( const Mat4 & x ){
        Mat4 m( x );
        m.setCol( 3, Vec4( fromSim( x.getCol(3).xyz() ), 1.0f ) );
        return( m );
}

Vec3 PhysicsWorld::getWarpVector(){ 
        return( Vec3( WARP_X, WARP_Y, WARP_Z ) ); 
}

void PhysicsWorld::setTimeStep( float step ){ 
        s_step = step; 
}

float PhysicsWorld::getTimeStep( void ){ 
        return( s_step ); 
}

#ifdef RT_BULLET
btVector3 PhysicsWorld::toSim( const Vec3 & v ){
        btVector3 r;
        r[0] = toSim( v[0] );
        r[1] = toSim( v[1] );
        r[2] = toSim( v[2] );
        return( r );
}

btVector3 PhysicsWorld::toSim( const btVector3 & v ){
        btVector3 r;
        r[0] = toSim( v[0] );
        r[1] = toSim( v[1] );
        r[2] = toSim( v[2] );
        return( r );
}

Vec3 PhysicsWorld::fromSim( const btVector3 & x ){
        Vec3 r;
        r[0] = fromSim( x[0] );
        r[1] = fromSim( x[1] );
        r[2] = fromSim( x[2] );
        return( r );
}

btTransform PhysicsWorld::toSim( const Mat4 & x ){
        Mat4 xt = x;
        btTransform t;
        t.setFromOpenGLMatrix( x.getPointer() );
        t.setOrigin( toSim( t.getOrigin() ) );
        return( t );
}

Mat4 PhysicsWorld::fromSim( const btTransform & x ){
        btScalar ogl[16];
        x.getOpenGLMatrix( ogl );
        Mat4 m( ogl );
        m.setCol( 3, Vec4( fromSim( m.getCol(3).xyz() ), 1.0f ) );
        return( m );
}

static btDiscreteDynamicsWorld * PhysicsWorld::getWorld( void ){ 
        return( s_world ); 
}

#endif

};//namespace

---