Physics Class Reference

Physics class will handle all things related to collisions, creating Bullet physics objects and the physics simulation. More...

#include <physics.h>

Public Member Functions
	Physics (const core::aabbox3df irrBox)
	Default constructor, given a boundbix will create the opposite physics ground. More...
	~Physics ()
void	initWorld ()
	Init physics instances of the World. More...
btTransform	getGround ()
	Return ground transform. More...
void	UpdatePhysics (u32 delta, u32 fps)
	World step simulation. More...
void	UpdateRender (btRigidBody *btbody)
	Update graphic object transformation. More...
btRigidBody *	createCannonBall (scene::ISceneNode *node, core::vector3df position, f32 radius)
	Create the projectile physics instance. More...
btRigidBody *	createTreasure (scene::IMeshSceneNode *node, core::vector3df scale, core::vector3df position)
	Create the treasure physics instance. More...
btRigidBody *	createCastleBlock (scene::ISceneNode *node, core::vector3df rotation, core::vector3df scale, core::vector3df position)
	Create a castle block. More...

Private Attributes
btDiscreteDynamicsWorld *	World
	Type of discrete rigid body simulation. More...
std::list< btRigidBody * >	Objects
	List of btRigitBody instances. More...
btDefaultCollisionConfiguration *	collisionConfiguration
	Default collision system. More...
btBroadphaseInterface *	broadPhase
	Bounding box overlapping interface. More...
btCollisionDispatcher *	dispatcher
	Collision system dispatcher. More...
btSequentialImpulseConstraintSolver *	solver
	Internal bullet solver. More...
btTransform	ground
	Ground transform properties. More...

Detailed Description

Physics class will handle all things related to collisions, creating Bullet physics objects and the physics simulation.

Remember that ONLY Bullet shape dimensions are x2 greater than Irrlicht unit. That means whenever you want to add an object from irrlicht extent you have to consider only half of it : irrSceneNode->getExtent() * 0.5f.

Constructor & Destructor Documentation

Physics()

Physics::Physics

(

const core::aabbox3df

irrBox

)

Default constructor, given a boundbix will create the opposite physics ground.

Parameters

irrBox

aabbox3df irrlicht world bounding box

                                          {

    this->collisionConfiguration = new btDefaultCollisionConfiguration();
    /*this->broadPhase = new btAxisSweep3(
        toBulletVector(core::vector3df(irrBox.MinEdge)), toBulletVector(core::vector3df(irrBox.MaxEdge))
    );*/
    this->broadPhase = new btAxisSweep3(btVector3(-100000, -100000, -100000), btVector3(100000, 100000, 100000));

    this->dispatcher = new btCollisionDispatcher(collisionConfiguration);
    this->solver = new btSequentialImpulseConstraintSolver();
    this->initWorld();
}

~Physics()

Physics::~Physics

(

)

                 {
    delete this->collisionConfiguration;
    delete this->broadPhase;
    delete this->dispatcher;
    delete this->solver;
}

Member Function Documentation

createCannonBall()

btRigidBody * Physics::createCannonBall	(	scene::ISceneNode *	node,
		core::vector3df	position,
		f32	radius
	)

Create the projectile physics instance.

Parameters

node	ISceneNode graphic node
position	vector3df position to set
radius	f32 radius of the projectile

See also

Physics

Ball

MotionStateManager

                                                                                               {
    btTransform transformer;
    transformer.setIdentity();
    transformer.setOrigin(toBulletVector(position));

//    btDefaultMotionState *motion = new btDefaultMotionState(transformer);
    MotionStateManager *motion = new MotionStateManager(transformer, node);
    btCollisionShape *sphere = new btSphereShape(radius);

    btVector3 localInertia;
    sphere->calculateLocalInertia(2600.f, localInertia);
    btRigidBody::btRigidBodyConstructionInfo ballRigidBodyCI(2600,motion,sphere,localInertia);
    ballRigidBodyCI.m_friction =2.5f;
    ballRigidBodyCI.m_restitution = 0.001f;
    ballRigidBodyCI.m_spinningFriction = 2.1f;
    ballRigidBodyCI.m_rollingFriction = 2.1f;
    ballRigidBodyCI.m_angularDamping = 0.65f;
    btRigidBody *rigidBody = new btRigidBody(ballRigidBodyCI);
    rigidBody->setUserPointer((void *)(node));

    this->Objects.push_back(rigidBody);

    this->World->addRigidBody(rigidBody);
    return rigidBody;
}

createCastleBlock()

btRigidBody * Physics::createCastleBlock	(	scene::ISceneNode *	node,
		core::vector3df	rotation,
		core::vector3df	scale,
		core::vector3df	position
	)

Create a castle block.

So it will be sensible to collision.

Parameters

node	ISceneNoe node of the irrlicht graphic object.
rotation	vector3df rotation of the object
scale	vector3df scaling of the node passed.
position	vector3df position of the object.

See also

Castle::createBlock();

Castle::buildCastle();

MotionStateManager;

                                                                                                                                 {
    btTransform transformer;
    transformer.setIdentity();
//    quat.setEuler(irr::core::DEGTORAD*rotation.X,irr::core::DEGTORAD*rotation.Y,irr::core::DEGTORAD*rotation.Z);
    transformer.setRotation(EulerToQuaternion(rotation));
    transformer.setOrigin(toBulletVector(position));
    MotionStateManager* motion = new MotionStateManager(transformer,node);
    core::vector3df extents = core::vector3df(scale.X,scale.Y,scale.Z)*0.5f;
    btCollisionShape* box = new btBoxShape(toBulletVector(extents));
    btVector3 localInertia;
    btScalar mass = 1500.f;
        btVector3 minEdge, maxEdge;

    box->calculateLocalInertia(mass, localInertia);
    box->getAabb(transformer,minEdge,maxEdge);
//    std::cout<<"btMin "<<minEdge[1]<<" irrMin"<<node->getBoundingBox().MinEdge.Y<<" irrMax"<<node->getBoundingBox().MaxEdge.Y<<" "<<maxEdge[1]<<" "<<std::endl;

    btRigidBody::btRigidBodyConstructionInfo blockInfo = btRigidBody::btRigidBodyConstructionInfo(mass,motion,box,localInertia);
    blockInfo.m_friction = 10.f;
    blockInfo.m_restitution = 0.001f;
    blockInfo.m_spinningFriction = 100.f;
    blockInfo.m_linearDamping = 0.05f;
    blockInfo.m_rollingFriction = 100.f;
    blockInfo.m_angularDamping = 0.8f;
    btRigidBody* rigidBody = new btRigidBody(blockInfo);
    rigidBody->activate(true);
    rigidBody->setUserPointer((void *) node);
    this->Objects.push_back(rigidBody);
    this->World->addRigidBody(rigidBody);
    return rigidBody;

}

createTreasure()

btRigidBody * Physics::createTreasure	(	scene::IMeshSceneNode *	node,
		core::vector3df	scale,
		core::vector3df	position
	)

Create the treasure physics instance.

Parameters

node	IMeshSceneNode mesh node of the irrlicht graphic object.
scale	vector3df scaling of the node passed.
position	vector3df position of the object.

See also

Target

::checkTarget

MotionStateManager

                                                                                                          {
    btTransform transformer;
    transformer.setIdentity();
    transformer.setOrigin(toBulletVector(position));
    core::vector3df _extent = node->getBoundingBox().getExtent();
    btCollisionShape* box = new btBoxShape(toBulletVector(_extent*0.5f));
    btVector3 minEdge, maxEdge;
    btVector3 localInertia;
    btScalar mass = 2780.f;
    transformer.setOrigin(btVector3(toBulletVector(position)[0], 0, toBulletVector(position)[2]));
        MotionStateManager *motion = new MotionStateManager(transformer,node);

    box->calculateLocalInertia(mass, localInertia);
    btRigidBody::btRigidBodyConstructionInfo targetInfo = btRigidBody::btRigidBodyConstructionInfo(mass,motion,box,localInertia);
        targetInfo.m_friction = 10.f;
    targetInfo.m_restitution = 0.001f;
    targetInfo.m_spinningFriction = 100.f;
    targetInfo.m_linearDamping = 0.05f;
    targetInfo.m_rollingFriction = 100.f;
    targetInfo.m_angularDamping = 0.8f;
    btRigidBody* rigidBody = new btRigidBody(targetInfo);
    rigidBody->activate(true);
    rigidBody->setUserPointer((void *) node);
    this->Objects.push_back(rigidBody);
    this->World->addRigidBody(rigidBody);
    return rigidBody;
}

getGround()

btTransform Physics::getGround

(

)

Return ground transform.

{ return this->ground; }

initWorld()

void Physics::initWorld

(

)

Init physics instances of the World.

Like ground, collision configuration, gravity and friction. A ground is created.

                       {

    this->World = new btDiscreteDynamicsWorld(this->dispatcher, this->broadPhase, this->solver, this->collisionConfiguration);
    this->World->setGravity(btVector3(0,-10,0));

    btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0, 1, 0),-1);
    this->ground = btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, 1, 0));
    btDefaultMotionState* groundMotionState = new btDefaultMotionState(ground);

    btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI = btRigidBody::btRigidBodyConstructionInfo(0, groundMotionState, groundShape, btVector3(0, 0, 0));
    groundRigidBodyCI.m_restitution = 1.f;
    groundRigidBodyCI.m_friction = 1.5f;
    groundRigidBodyCI.m_rollingFriction = 1.5f;
    groundRigidBodyCI.m_spinningFriction = 1.5f;

    btRigidBody* groundRigidBody = new btRigidBody(groundRigidBodyCI);
    this->World->addRigidBody(groundRigidBody);
    groundRigidBody->setUserPointer((void *) 0);
    this->Objects.push_back(groundRigidBody);

}

UpdatePhysics()

void Physics::UpdatePhysics	(	u32	delta,
		u32	fps
	)

World step simulation.

This must be sync with Irrlicht

DEPRECATED, MotionStateManager will handle this now!/

                                                   {

    this->World->stepSimulation(TDeltaTime);


//  for(std::list<btRigidBody *>::iterator Iterator = Objects.begin(); Iterator != Objects.end(); ++Iterator) {
//        if((*Iterator)->getUserPointer() != 0)
//      this->UpdateRender(*Iterator);
//
//  }


}

UpdateRender()

void Physics::UpdateRender

(

btRigidBody *

btbody

)

Update graphic object transformation.

DEPRECATED, MotionStateManager will handle this now!/

See also

MotionStateManager

Deprecated:

                                               {
    return;
    scene::ISceneNode *Node = static_cast<scene::ISceneNode *>(TObject->getUserPointer());

    // Set position
    btVector3 Point = TObject->getCenterOfMassPosition();
    std::cout<<Point.getX()<<" "<<Point.getY()<<" "<<Point.getZ()<< "BULLET"<<std::endl;
    Node->setPosition(core::vector3df((f32)Point[0], (f32)Point[1], (f32)Point[2]));
    std::cout<<Node->getAbsolutePosition().X<<" "<<Node->getAbsolutePosition().Y<<" "<<Node->getAbsolutePosition().Z<<"irrlicht"<<std::endl;

//  // Set rotation ---testing
    core::vector3df Euler;
    const btQuaternion& TQuat = TObject->getOrientation();
    core::quaternion q(TQuat.getX(), TQuat.getY(), TQuat.getZ(), TQuat.getW());
    q.toEuler(Euler);
    Euler *= core::RADTODEG;
    Node->setRotation(Euler);
}

Member Data Documentation

broadPhase

btBroadphaseInterface* Physics::broadPhase

private

Bounding box overlapping interface.

collisionConfiguration

btDefaultCollisionConfiguration* Physics::collisionConfiguration

private

Default collision system.

dispatcher

btCollisionDispatcher* Physics::dispatcher

private

Collision system dispatcher.

ground

btTransform Physics::ground

private

Ground transform properties.

Objects

std::list<btRigidBody *> Physics::Objects

private

List of btRigitBody instances.

All this btRigidBody have a pointer to corresponding graphic object. This system is not used anymore.

See also

MotionStateManager

Deprecated:

solver

btSequentialImpulseConstraintSolver* Physics::solver

private

Internal bullet solver.

World

btDiscreteDynamicsWorld* Physics::World

private

Type of discrete rigid body simulation.

---

The documentation for this class was generated from the following files:

• src/game/physics.h
• src/game/physics.cpp