#include "main.hpp"
irr::IrrlichtDevice *device = 0;
irr::video::IVideoDriver *driver = 0;
irr::scene::ISceneManager *sceneManager = 0;
static NewtonWorld* world;
static NewtonBody* body;
static NewtonBody* bodyB;
static NewtonBody* bodyC;
irr::scene::ISceneNode *cubeNode = 0;
irr::scene::ISceneNode *cam = 0;
unsigned int lasttick;
void initScene()
{
device = irr::createDevice(irr::video::EDT_OPENGL, irr::core::dimension2d<irr::u32>(640,480), false);
driver = device->getVideoDriver();
sceneManager = device->getSceneManager();
sceneManager->addSkyBoxSceneNode(driver->getTexture("data/irrlicht2_up.bmp"),driver->getTexture("data/irrlicht2_dn.bmp"),driver->getTexture("data/irrlicht2_rt.bmp"),driver->getTexture("data/irrlicht2_lf.bmp"),driver->getTexture("data/irrlicht2_ft.bmp"),driver->getTexture("data/irrlicht2_bk.bmp"));
world = NewtonCreate (NULL, NULL);
// Création d'un cube soumis à la gravité.
irr::scene::IMesh* cubeMesh = sceneManager->getMesh("data/smallcube.3ds");
cubeNode = sceneManager->addMeshSceneNode(cubeMesh);
cubeNode->setMaterialTexture(0, driver->getTexture("data/crate.jpg"));
cubeNode->setMaterialFlag(irr::video::EMF_LIGHTING, false);
NewtonCollision *collision;
collision = NewtonCreateBox(world, 0, 0, 0, NULL);
body = NewtonCreateBody (world, collision);
NewtonReleaseCollision (world, collision);
NewtonBodySetUserData(body,reinterpret_cast<void*>(cubeNode));
// Calcul de l'inertie de l'objet.
float masse = 100.0;
irr::core::vector3df inertie;
irr::core::vector3df taille = irr::core::vector3df(10,10,10);
inertie.X = (masse/12)*(pow(taille.Y,2)+pow(taille.Z,2));
inertie.Y = (masse/12)*(pow(taille.X,2)+pow(taille.Z,2));
inertie.Z = (masse/12)*(pow(taille.X,2)+pow(taille.Y,2));
NewtonBodySetMassMatrix (body, masse, inertie.X, inertie.Y, inertie.Z);
// Méthode permettant la modification de l'objet en fonction des forces.
NewtonBodySetTransformCallback(body, SetMeshTransformEvent);
NewtonBodySetForceAndTorqueCallback(body, ApplyForceAndTorqueEvent);
irr::core::matrix4 mat;
mat.setTranslation(irr::core::vector3df(0.0,0.0,50.0));
NewtonBodySetMatrix(body, mat.pointer());
// Fin de création.
// Création d'un cube soumis à la gravité.
irr::scene::IMesh* cubeMeshB = sceneManager->getMesh("data/smallcube.3ds");
cubeNode = sceneManager->addMeshSceneNode(cubeMeshB);
cubeNode->setMaterialTexture(0, driver->getTexture("data/crate.jpg"));
cubeNode->setMaterialFlag(irr::video::EMF_LIGHTING, false);
NewtonCollision *collisionB;
collisionB = NewtonCreateBox(world, 0, 0, 0, NULL);
bodyB = NewtonCreateBody (world, collisionB);
NewtonReleaseCollision (world, collisionB);
NewtonBodySetUserData(bodyB,reinterpret_cast<void*>(cubeNode));
// Calcul de l'inertie de l'objet.
float masseB = 200.0;
irr::core::vector3df inertieB;
irr::core::vector3df tailleB = irr::core::vector3df(10,10,10);
inertieB.X = (masseB/12)*(pow(tailleB.Y,2)+pow(tailleB.Z,2));
inertieB.Y = (masseB/12)*(pow(tailleB.X,2)+pow(tailleB.Z,2));
inertieB.Z = (masseB/12)*(pow(tailleB.X,2)+pow(tailleB.Y,2));
NewtonBodySetMassMatrix (bodyB, masseB, inertieB.X, inertieB.Y, inertieB.Z);
// Méthode permettant la modification de l'objet en fonction des forces.
NewtonBodySetTransformCallback(bodyB, SetMeshTransformEvent);
NewtonBodySetForceAndTorqueCallback(bodyB, ApplyForceAndTorqueEvent);
irr::core::matrix4 matB;
matB.setTranslation(irr::core::vector3df(0.0,0.0,-50.0));
NewtonBodySetMatrix(bodyB, matB.pointer());
// Fin de création.
// Création d'un cube non soumis à la gravité.
irr::scene::IMesh* cubeMeshC = sceneManager->getMesh("data/smallcube.3ds");
cubeNode = sceneManager->addMeshSceneNode(cubeMeshC);
cubeNode->setMaterialTexture(0, driver->getTexture("data/crate.jpg"));
cubeNode->setMaterialFlag(irr::video::EMF_LIGHTING, false);
NewtonCollision *collisionC;
collisionC = NewtonCreateBox(world, 0, 0, 0, NULL);
bodyC = NewtonCreateBody (world, collisionC);
NewtonReleaseCollision (world, collisionC);
NewtonBodySetUserData(bodyC,reinterpret_cast<void*>(cubeNode));
// Calcul de l'inertie de l'objet.
float masseC = 0.0;
irr::core::vector3df inertieC;
irr::core::vector3df tailleC = irr::core::vector3df(10,10,10);
inertieC.X = (masseC/12)*(pow(tailleC.Y,2)+pow(tailleC.Z,2));
inertieC.Y = (masseC/12)*(pow(tailleC.X,2)+pow(tailleC.Z,2));
inertieC.Z = (masseC/12)*(pow(tailleC.X,2)+pow(tailleC.Y,2));
NewtonBodySetMassMatrix (bodyC, masseC, inertieC.X, inertieC.Y, inertieC.Z);
// Méthode permettant la modification de l'objet en fonction des forces.
NewtonBodySetTransformCallback(bodyC, SetMeshTransformEvent);
NewtonBodySetForceAndTorqueCallback(bodyC, ApplyForceAndTorqueEvent);
irr::core::matrix4 matC;
matC.setTranslation(irr::core::vector3df(0.0,0.0,0.0));
NewtonBodySetMatrix(bodyC, matC.pointer());
// Fin de création.
// Caméra
irr::scene::ICameraSceneNode* cam = sceneManager->addCameraSceneNode();
cam->setPosition(irr::core::vector3df(200,100,0));
cam->setTarget(irr::core::vector3df(0,0,0));
}
// -----------------------------------------------------------------------------
// --------------------------------- CALLBACK ----------------------------------
// -----------------------------------------------------------------------------
void SetMeshTransformEvent(const NewtonBody* body, const float* matrix)
{
irr::core::matrix4 mat;
memcpy(mat.pointer(), matrix, sizeof(float)*16);
irr::scene::ISceneNode *cubeNode = (irr::scene::ISceneNode *)NewtonBodyGetUserData(body);
if (cubeNode)
{
cubeNode->setPosition(mat.getTranslation());
cubeNode->setRotation(mat.getRotationDegrees());
}
}
void ApplyForceAndTorqueEvent(const NewtonBody* body)
{
float masse;
float inertieX;
float inertieY;
float inertieZ;
float force[3];
float torque[3];
NewtonBodyGetMassMatrix (body, &masse, &inertieX, &inertieY, &inertieZ);
force[0] = 0.0f;
force[1] = -9.81 * masse;
force[2] = 0.0f;
torque[0] = 0.0f;
torque[1] = 0.0f;
torque[2] = 0.0f;
NewtonBodyAddForce(body, force);
NewtonBodyAddTorque(body, torque);
}
// -----------------------------------------------------------------------------
// ------------------------------- END OF CALLBACK -----------------------------
// -----------------------------------------------------------------------------
void drawScene(){
if (device->getTimer()->getTime() > lasttick + 10)
{
lasttick = device->getTimer()->getTime();
NewtonUpdate(world, 0.01f);
}
}
int main()
{
initScene();
while(device->run())
{
drawScene();
driver->beginScene(true, true, irr::video::SColor(255,255,255,255));
sceneManager->drawAll();
driver->endScene();
}
NewtonDestroy(world);
device->drop();
return 0;
}
