Você está na página 1de 7

Irrlicht Engine wiki - Getting Started With Bullet Page 1 of 7

View Edit History Print


Irrlicht Engine Wiki
Irrlicht Manual Getting Started With Bullet
Tutorials by Punong Bisyonaryo
FAQ
Code Snippets
The IRRext Project Introduction
SceneNodes Bullet Physics is a professional open source collision detection, rigid body and soft body dynamics library. The library is free for commercial use under the Zlib
OtherAdd-ons license. It can be easily integrated into Irrlicht to provide a degree of realism in your game or simulation.
RecentChanges
Note: This tutorial is based on the Irrlicht test demo by Jacky_J in this thread
Development
TODO List
Developers Setting Up
Design Before we get started on the code, we need to make sure our IDE is set up with the Irrlicht header files and linked to the Irrlicht libraries. Check out the tutorials page
Wiki for instructions on setting up Irrlicht on your OS and IDE.
Impressum
You need to specify to your IDE's linker the libBulletDynamics, libBulletCollision, and libLinearMath libraries.
Help
WikiSandbox
Finally, in our main.cpp, we include the Irrlicht library, the main Bullet Dynamics library, and also cstdlib
Irrlicht Home Page
Irrlicht Forums #include <irrlicht.h>
#include "btBulletDynamicsCommon.h"
edit SideBar #include <cstdlib>

Search:
We set the namespace for our Irrlicht library. You can also set the namespace for its 5 subnamespaces, but for this tutorial they are not set to show which stuff
Go belongs to which namespace.

using namespace irr;

We then declare our functions and global variables

// Functions
//For now, there's not much here. Just add them in as we create them
static int GetRandInt(int TMax) { return rand() % TMax; }

// Globals
//For now, there's not much here. Just add them in as we create them
static IrrlichtDevice *irrDevice;
static video::IVideoDriver *irrDriver;
static scene::ISceneManager *irrScene;
static gui::IGUIEnvironment* irrGUI;
static io::IFileSystem *irrFile;
static ITimer *irrTimer;
static ILogger *irrLog;

Create a Basic Irrlicht Shell


We start off with our basic Irrlicht structure by getting the driver, adding a camera and running the Irrlicht engine

int main()
{
irrDevice = createDevice(video::EDT_OPENGL, core::dimension2d<u32>(640, 480), 32, false, false, false, 0);
if (irrDevice == 0)
return 1; // could not create selected driver.
irrGUI = irrDevice->getGUIEnvironment();
irrTimer = irrDevice->getTimer();
irrDriver = irrDevice->getVideoDriver();
irrScene = irrDevice->getSceneManager();

irrDevice->setWindowCaption(L"Irrlicht with Bullet Physics Demo");

//Add an FPS camera move it up and back and point it at the origin
scene::ICameraSceneNode *Camera = irrScene->addCameraSceneNodeFPS(0, 100, 10);
Camera->setPosition(core::vector3df(0, 5, -5));
Camera->setTarget(core::vector3df(0, 0, 0));

//Make the mouse cursor invisible


irrDevice->getCursorControl()->setVisible(false);

while(irrDevice->run())
{
if (irrDevice->isWindowActive())
{
irrDriver->beginScene(true, true, video::SColor(255,200,200,200));
irrScene->drawAll();
irrDriver->endScene();
}
else
irrDevice->yield();
}

//Delete the Irrlicht device


irrDevice->drop();
return 0;
}

Adding Bullet

http://www.irrlicht3d.org/wiki/index.php?n=Main.GettingStartedWithBullet 8/12/2017
Irrlicht Engine wiki - Getting Started With Bullet Page 2 of 7

At this point, there are no objects in our world yet so you won't be able to see anything. Let's start adding in some rigid bodies so we can finally start seeing some
Bullet action.

First we initialize Bullet. Before we can create btDiscreteDynamicsWorld, we must choose a broadphase algorithm to use, a collision configuration, and a constraint
solver. To learn more about these, check out the Hello World Tutorial at the Bullet Wiki.

Add the following global variables. The first variable is our "physical world", and the second one will hold all of our objects in it.

static btDiscreteDynamicsWorld *World;


static core::list<btRigidBody *> Objects;

Now place the following code after you declare the irrGui, irrDriver, irrScene, etc.

// Initialize bullet
btBroadphaseInterface *BroadPhase = new btAxisSweep3(btVector3(-1000, -1000, -1000), btVector3(1000, 1000, 1000));
btDefaultCollisionConfiguration *CollisionConfiguration = new btDefaultCollisionConfiguration();
btCollisionDispatcher *Dispatcher = new btCollisionDispatcher(CollisionConfiguration);
btSequentialImpulseConstraintSolver *Solver = new btSequentialImpulseConstraintSolver();
World = new btDiscreteDynamicsWorld(Dispatcher, BroadPhase, Solver, CollisionConfiguration);

Creating Objects
Now we're going to create two functions: 1 for creating a box shape and another for creating a sphere. Both will be rigid bodies so they could interact using Bullet For
each of the two functions, we'll start of by creating an object in Irrlicht (that's what gets rendered), and then we set the position of the object in a way for Bullet to
figure out where it's at. We'll then give it a MotionState and describe to Bullet what that object is shaped like, give it some mass, and with all of those parameters,
Bullet can figure out how to create that rigid body in space.

// Create a box rigid body


void CreateBox(const btVector3 &TPosition, const core::vector3df &TScale, btScalar TMass) {

// Create an Irrlicht cube


scene::ISceneNode *Node = irrScene->addCubeSceneNode(1.0f);
Node->setScale(TScale);
Node->setMaterialFlag(video::EMF_LIGHTING, 1);
Node->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
Node->setMaterialTexture(0, irrDriver->getTexture("rust0.jpg"));

// Set the initial position of the object


btTransform Transform;
Transform.setIdentity();
Transform.setOrigin(TPosition);

// Give it a default MotionState


btDefaultMotionState *MotionState = new btDefaultMotionState(Transform);

// Create the shape


btVector3 HalfExtents(TScale.X * 0.5f, TScale.Y * 0.5f, TScale.Z * 0.5f);
btCollisionShape *Shape = new btBoxShape(HalfExtents);

// Add mass
btVector3 LocalInertia;
Shape->calculateLocalInertia(TMass, LocalInertia);

// Create the rigid body object


btRigidBody *RigidBody = new btRigidBody(TMass, MotionState, Shape, LocalInertia);

// Store a pointer to the irrlicht node so we can update it later


RigidBody->setUserPointer((void *)(Node));

// Add it to the world


World->addRigidBody(RigidBody);
Objects.push_back(RigidBody);
}

// Create a sphere rigid body


void CreateSphere(const btVector3 &TPosition, btScalar TRadius, btScalar TMass) {

// Create an Irrlicht sphere


scene::ISceneNode *Node = irrScene->addSphereSceneNode(TRadius, 32);
Node->setMaterialFlag(video::EMF_LIGHTING, 1);
Node->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
Node->setMaterialTexture(0, irrDriver->getTexture("ice0.jpg"));

// Set the initial position of the object


btTransform Transform;
Transform.setIdentity();
Transform.setOrigin(TPosition);

// Give it a default MotionState


btDefaultMotionState *MotionState = new btDefaultMotionState(Transform);

// Create the shape


btCollisionShape *Shape = new btSphereShape(TRadius);

// Add mass
btVector3 LocalInertia;
Shape->calculateLocalInertia(TMass, LocalInertia);

// Create the rigid body object


btRigidBody *RigidBody = new btRigidBody(TMass, MotionState, Shape, LocalInertia);

// Store a pointer to the irrlicht node so we can update it later


RigidBody->setUserPointer((void *)(Node));

// Add it to the world


World->addRigidBody(RigidBody);
Objects.push_back(RigidBody);
}

You can grab the texture files from Jacky_J's post , or you could supply your own textures.

http://www.irrlicht3d.org/wiki/index.php?n=Main.GettingStartedWithBullet 8/12/2017
Irrlicht Engine wiki - Getting Started With Bullet Page 3 of 7

We're also going to need to create a function that creates the "ground" which our objects can interact with. The ground will basically be a large box we'll create with
our createBox function

// Creates a base box


void CreateStartScene() {

ClearObjects();
CreateBox(btVector3(0.0f, 0.0f, 0.0f), core::vector3df(10.0f, 0.5f, 10.0f), 0.0f);
}

Don't forget to add their function declarations at the top of your code

static void CreateStartScene();


static void CreateBox(const btVector3 &TPosition, const core::vector3df &TScale, btScalar TMass);
static void CreateSphere(const btVector3 &TPosition, btScalar TRadius, btScalar TMass);

Listening in For Events


Now that we've created the functions for adding objects in our world, we need to assign them to map them to some keyboard keys. We do this through events and an
event receiver. We need to create an event receiver class so that we could put in some cool interactions with our Irrlicht/Bullet engine. We extend the IEventReceiver
class and overload the OnEvent method. There are three key events that we're gonna handle: the Escape, 1, 2, and X keys.

// Event receiver
class EventReceiverClass : public IEventReceiver {

public:

virtual bool OnEvent(const SEvent &TEvent) {

if(TEvent.EventType == EET_KEY_INPUT_EVENT && !TEvent.KeyInput.PressedDown) {


switch(TEvent.KeyInput.Key) {
case KEY_ESCAPE:
Done = true;
break;
case KEY_KEY_1:
CreateBox(btVector3(GetRandInt(10) - 5.0f, 7.0f, GetRandInt(10) - 5.0f), core::vector3df(GetRandIn
break;
case KEY_KEY_2:
CreateSphere(btVector3(GetRandInt(10) - 5.0f, 7.0f, GetRandInt(10) - 5.0f), GetRandInt(5) / 5.0f +
break;
case KEY_KEY_X:
CreateStartScene();
break;
default:
return false;
break;
}

return true;
}

return false;
}
};

For our Irrlicht engine to take note of these events, we have to instantiate this receiver and pass it along to our IrrlichtDevice. We're also going to have to change how
we create our IrrlichtDevice. Look for the line where we create our IrrlichtDevice, instantiate our receiver class and pass it in the createDevice function.

// Create Event Receiver


EventReceiverClass Receiver;

irrDevice = createDevice(video::EDT_OPENGL, core::dimension2d<u32>(640, 480), 32, false, false, false, &Receiver);

Notice that when we hit the Escape key, our receiver class sets a variable "Done" to true. We'll declare this variable with our other global variables.

static bool Done = false;

We'll also modify our main loop so that when Done is true, our program will terminate.

while(irrDevice->run() && Done==false)

Physics Simulation
Now that we have our objects set up, we need to actually start applying the physics calculations like gravity and collisions to our objects. Bullet does this by
"stepping" the simulation. A step is basically a discrete period of time and for each step, Bullet calculates how high or how fast an object falls, or how much a collision
throws back an object since the last frame.

So what we have to do is before we call on Irrlicht to draw our objects onto the screen, we first have to call on Bullet to give us the updated position of each of our
objects. For this, we create a new function called updatePhysics.

// Runs the physics simulation.


// - TDeltaTime tells the simulation how much time has passed since the last frame so the simulation can run independently of the frame ra
void UpdatePhysics(u32 TDeltaTime) {

World->stepSimulation(TDeltaTime * 0.001f, 60);

btRigidBody *TObject;
// Relay the object's orientation to irrlicht
for(core::list<btRigidBody *>::Iterator it = Objects.begin(); it != Objects.end(); ++it) {

//UpdateRender(*Iterator);
scene::ISceneNode *Node = static_cast<scene::ISceneNode *>((*it)->getUserPointer());
TObject = *it;

// Set position

http://www.irrlicht3d.org/wiki/index.php?n=Main.GettingStartedWithBullet 8/12/2017
Irrlicht Engine wiki - Getting Started With Bullet Page 4 of 7

btVector3 Point = TObject->getCenterOfMassPosition();


Node->setPosition(core::vector3df((f32)Point[0], (f32)Point[1], (f32)Point[2]));

// Set rotation
btVector3 EulerRotation;
QuaternionToEuler(TObject->getOrientation(), EulerRotation);
Node->setRotation(core::vector3df(EulerRotation[0], EulerRotation[1], EulerRotation[2]));

}
}

// Converts a quaternion to an euler angle


void QuaternionToEuler(const btQuaternion &TQuat, btVector3 &TEuler) {
btScalar W = TQuat.getW();
btScalar X = TQuat.getX();
btScalar Y = TQuat.getY();
btScalar Z = TQuat.getZ();
float WSquared = W * W;
float XSquared = X * X;
float YSquared = Y * Y;
float ZSquared = Z * Z;

TEuler.setX(atan2f(2.0f * (Y * Z + X * W), -XSquared - YSquared + ZSquared + WSquared));


TEuler.setY(asinf(-2.0f * (X * Z - Y * W)));
TEuler.setZ(atan2f(2.0f * (X * Y + Z * W), XSquared - YSquared - ZSquared + WSquared));
TEuler *= core::RADTODEG;
}

We then update our program's main loop to calculate the delta (the time since the last screen render), update the physics, and then render everything on screen. Our
main loop should now look something like this.

u32 TimeStamp = irrTimer->getTime(), DeltaTime = 0;


while(irrDevice->run() && Done==false)
{
if (irrDevice->isWindowActive())
{
DeltaTime = irrTimer->getTime() - TimeStamp;
TimeStamp = irrTimer->getTime();

UpdatePhysics(DeltaTime);

irrDriver->beginScene(true, true, video::SColor(255,200,200,200));


irrScene->drawAll();
irrGUI->drawAll();
irrDriver->endScene();

int fps = irrDriver->getFPS();

if (lastFPS != fps)
{
core::stringw str = L"Irrlicht Engine - Quake 3 Map example [";
str += irrDriver->getName();
str += "] FPS:";
str += fps;

irrDevice->setWindowCaption(str.c_str());
lastFPS = fps;
}
}
else
irrDevice->yield();
}

Finishing Up
You can preload the textures you'll be using by getting the textures beforehand in your main(), before going into your main program loop.

// Preload textures
irrDriver->getTexture("ice0.jpg");
irrDriver->getTexture("rust0.jpg");

As an added touch, we're going to add some GUI text on the upper-left corner of our screen explaining what keys the player can press.

// Create text
gui::IGUISkin* Skin = irrGUI->getSkin();
Skin->setColor(gui::EGDC_BUTTON_TEXT, video::SColor(255, 255, 255, 255));
irrGUI->addStaticText(L"Hit 1 to create a box\nHit 2 to create a sphere\nHit x to reset", core::rect<s32>(0, 0, 200, 100), false);

And finally, before our main loop we put in some final bits of code to initialize our scene.

irrScene->addLightSceneNode(0, core::vector3df(2, 5, -2), video::SColorf(4, 4, 4, 1));


CreateStartScene();

Other Notes
If you find a problem in this tutorial, contact me via punong_bisyonaryo _at_ yahoo_dot_com or at http://www.jplui.com/contact.php

To Compile on Linux
g++ example.cpp -o example -lIrrlicht -lGL -lGLU -lXrandr -lXext -lX11 `pkg-config --libs --cflags bullet`

Updated for recent Irrlicht and Bullet APIs


These are changes to Jacky_J's sample code to use newer versions of Irrlicht and Bullet. Also, we will be using Irrlicht's quaternion class to convert Bullet's
quaternion to a rotation in Euler angles.

http://www.irrlicht3d.org/wiki/index.php?n=Main.GettingStartedWithBullet 8/12/2017
Irrlicht Engine wiki - Getting Started With Bullet Page 5 of 7

//***************************************************************
// Bullet/irrlicht demo by Alan Witkowski
// http://www.cs.utah.edu/~witkowsk
// http://code.google.com/p/irrlamb/
//***************************************************************
#include <irrlicht.h>
#include <btBulletCollisionCommon.h>
#include <btBulletDynamicsCommon.h>
#include <cstdlib>

using namespace irr;


using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

// Functions
static void CreateStartScene();
static void CreateBox(const btVector3 &TPosition, const vector3df &TScale, btScalar TMass);
static void CreateSphere(const btVector3 &TPosition, btScalar TRadius, btScalar TMass);
static void UpdatePhysics(u32 TDeltaTime);
static void UpdateRender(btRigidBody *TObject);
static void ClearObjects();
static int GetRandInt(int TMax) { return rand() % TMax; }

// Globals
static bool Done = false;
static btDiscreteDynamicsWorld *World;
static IrrlichtDevice *irrDevice;
static IVideoDriver *irrDriver;
static ISceneManager *irrScene;
static IGUIEnvironment *irrGUI;
static IFileSystem *irrFile;
static ITimer *irrTimer;
static ILogger *irrLog;
static list<btRigidBody *> Objects;

// Event receiver
class EventReceiverClass : public IEventReceiver {

public:

virtual bool OnEvent(const SEvent &TEvent) {

if(TEvent.EventType == EET_KEY_INPUT_EVENT && !TEvent.KeyInput.PressedDown) {


switch(TEvent.KeyInput.Key) {
case KEY_ESCAPE:
Done = true;
break;
case KEY_KEY_1:
CreateBox(btVector3(GetRandInt(10) - 5.0f, 7.0f, GetRandInt(10) - 5.0f), vector3df(GetRandInt(3) +
break;
case KEY_KEY_2:
CreateSphere(btVector3(GetRandInt(10) - 5.0f, 7.0f, GetRandInt(10) - 5.0f), GetRandInt(5) / 5.0f +
break;
case KEY_KEY_X:
CreateStartScene();
break;
default:
return false;
break;
}

return true;
}

return false;
}
};

int main() {

// Initialize irrlicht
EventReceiverClass Receiver;
irrDevice = createDevice(video::EDT_OPENGL, dimension2d<u32>(800, 600), 32, false, false, false, &Receiver);
irrGUI = irrDevice->getGUIEnvironment();
irrTimer = irrDevice->getTimer();
irrScene = irrDevice->getSceneManager();
irrDriver = irrDevice->getVideoDriver();

irrDevice->getCursorControl()->setVisible(0);

// Initialize bullet
btDefaultCollisionConfiguration *CollisionConfiguration = new btDefaultCollisionConfiguration();
btBroadphaseInterface *BroadPhase = new btAxisSweep3(btVector3(-1000, -1000, -1000), btVector3(1000, 1000, 1000));
btCollisionDispatcher *Dispatcher = new btCollisionDispatcher(CollisionConfiguration);
btSequentialImpulseConstraintSolver *Solver = new btSequentialImpulseConstraintSolver();
World = new btDiscreteDynamicsWorld(Dispatcher, BroadPhase, Solver, CollisionConfiguration);

// Add camera
ICameraSceneNode *Camera = irrScene->addCameraSceneNodeFPS(0, 100, 10);
Camera->setPosition(vector3df(0, 5, -5));
Camera->setTarget(vector3df(0, 0, 0));

// Preload textures
irrDriver->getTexture("ice0.jpg");
irrDriver->getTexture("rust0.jpg");

// Create text
IGUISkin *Skin = irrGUI->getSkin();
Skin->setColor(EGDC_BUTTON_TEXT, SColor(255, 255, 255, 255));
irrGUI->addStaticText(L"Hit 1 to create a box\nHit 2 to create a sphere\nHit x to reset", rect<s32>(0, 0, 200, 100), false);

// Create the initial scene


irrScene->addLightSceneNode(0, core::vector3df(2, 5, -2), SColorf(4, 4, 4, 1));
CreateStartScene();

http://www.irrlicht3d.org/wiki/index.php?n=Main.GettingStartedWithBullet 8/12/2017
Irrlicht Engine wiki - Getting Started With Bullet Page 6 of 7

// Main loop
u32 TimeStamp = irrTimer->getTime(), DeltaTime = 0;
while(!Done) {

DeltaTime = irrTimer->getTime() - TimeStamp;


TimeStamp = irrTimer->getTime();

UpdatePhysics(DeltaTime);

irrDriver->beginScene(true, true, SColor(255, 20, 0, 0));


irrScene->drawAll();
irrGUI->drawAll();
irrDriver->endScene();
irrDevice->run();
}

ClearObjects();
delete World;
delete Solver;
delete Dispatcher;
delete BroadPhase;
delete CollisionConfiguration;

irrDevice->drop();

return 0;
}

// Runs the physics simulation.


// - TDeltaTime tells the simulation how much time has passed since the last frame so the simulation can run independently of the frame ra
void UpdatePhysics(u32 TDeltaTime) {

World->stepSimulation(TDeltaTime * 0.001f, 60);

// Relay the object's orientation to irrlicht


for(list<btRigidBody *>::Iterator Iterator = Objects.begin(); Iterator != Objects.end(); ++Iterator) {

UpdateRender(*Iterator);
}
}

// Creates a base box


void CreateStartScene() {

ClearObjects();
CreateBox(btVector3(0.0f, 0.0f, 0.0f), vector3df(10.0f, 0.5f, 10.0f), 0.0f);
}

// Create a box rigid body


void CreateBox(const btVector3 &TPosition, const vector3df &TScale, btScalar TMass) {

ISceneNode *Node = irrScene->addCubeSceneNode(1.0f);


Node->setScale(TScale);
Node->setMaterialFlag(EMF_LIGHTING, 1);
Node->setMaterialFlag(EMF_NORMALIZE_NORMALS, true);
Node->setMaterialTexture(0, irrDriver->getTexture("rust0.jpg"));

// Set the initial position of the object


btTransform Transform;
Transform.setIdentity();
Transform.setOrigin(TPosition);

btDefaultMotionState *MotionState = new btDefaultMotionState(Transform);

// Create the shape


btVector3 HalfExtents(TScale.X * 0.5f, TScale.Y * 0.5f, TScale.Z * 0.5f);
btCollisionShape *Shape = new btBoxShape(HalfExtents);

// Add mass
btVector3 LocalInertia;
Shape->calculateLocalInertia(TMass, LocalInertia);

// Create the rigid body object


btRigidBody *RigidBody = new btRigidBody(TMass, MotionState, Shape, LocalInertia);

// Store a pointer to the irrlicht node so we can update it later


RigidBody->setUserPointer((void *)(Node));

// Add it to the world


World->addRigidBody(RigidBody);
Objects.push_back(RigidBody);
}

// Create a sphere rigid body


void CreateSphere(const btVector3 &TPosition, btScalar TRadius, btScalar TMass) {

ISceneNode *Node = irrScene->addSphereSceneNode(TRadius, 32);


Node->setMaterialFlag(EMF_LIGHTING, 1);
Node->setMaterialFlag(EMF_NORMALIZE_NORMALS, true);
Node->setMaterialTexture(0, irrDriver->getTexture("ice0.jpg"));

// Set the initial position of the object


btTransform Transform;
Transform.setIdentity();
Transform.setOrigin(TPosition);

btDefaultMotionState *MotionState = new btDefaultMotionState(Transform);

// Create the shape


btCollisionShape *Shape = new btSphereShape(TRadius);

// Add mass
btVector3 LocalInertia;
Shape->calculateLocalInertia(TMass, LocalInertia);

// Create the rigid body object

http://www.irrlicht3d.org/wiki/index.php?n=Main.GettingStartedWithBullet 8/12/2017
Irrlicht Engine wiki - Getting Started With Bullet Page 7 of 7

btRigidBody *RigidBody = new btRigidBody(TMass, MotionState, Shape, LocalInertia);

// Store a pointer to the irrlicht node so we can update it later


RigidBody->setUserPointer((void *)(Node));

// Add it to the world


World->addRigidBody(RigidBody);
Objects.push_back(RigidBody);
}

// Passes bullet's orientation to irrlicht


void UpdateRender(btRigidBody *TObject) {
ISceneNode *Node = static_cast<ISceneNode *>(TObject->getUserPointer());

// Set position
btVector3 Point = TObject->getCenterOfMassPosition();
Node->setPosition(vector3df((f32)Point[0], (f32)Point[1], (f32)Point[2]));

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

// Removes all objects from the world


void ClearObjects() {

for(list<btRigidBody *>::Iterator Iterator = Objects.begin(); Iterator != Objects.end(); ++Iterator) {


btRigidBody *Object = *Iterator;

// Delete irrlicht node


ISceneNode *Node = static_cast<ISceneNode *>(Object->getUserPointer());
Node->remove();

// Remove the object from the world


World->removeRigidBody(Object);

// Free memory
delete Object->getMotionState();
delete Object->getCollisionShape();
delete Object;
}

Objects.clear();
}

Page last modified on September 07, 2011, at 03:49 AM


▲ Top ▲ Search Recent Changes All Recent Changes

http://www.irrlicht3d.org/wiki/index.php?n=Main.GettingStartedWithBullet 8/12/2017