Irrlicht+True axis, physical engine ,matrix rotation

[jsmurthy4]

Hi I wrote a small example for combining irrlicht(3D Render Engine) and trueaxis(Physical Engine)
I am using True Axis Physics SDK 1.2.0.3 and vc++ 2008.
1)First create a folder ‘Physics’ in solution Explorer in vc++ and copy all the cpp (only cpp) files from \TA\TA\Physics.
2) create a folder ‘Common’ as above and copy all cpp file from \TA\TA\Common
3) Go to Tools->options->vc++ directories in include files select \TA\TA\Physics and \TA\TA\Common
4) Add your source and header file as u need.


I add 2 examples 1st example is a basic rotation,2nd one is a ration with matrix so that we can get 100% perfect rotation and collision and also it can hold more no. of boxes
// You can download all needed files at http://groups.google.com/group/mur_games

Code: Select all

#include<CollisionObjectAABBMesh.h>
#include<Physics.h>
#include<DynamicObject.h>
#include<StaticObject.h>
using namespace TA;

#include<Irrlicht.h>
#pragma comment(lib,"Irrlicht.lib")
using namespace irr;

void main()
{ 

 //Irrlicht Initialization.

 IrrlichtDevice *device=createDevice(video::EDT_DIRECT3D9,core::dimension2d<irr::s32>(800,640),16);
 video::IVideoDriver *driver=device->getVideoDriver();
 scene::ISceneManager *smgr=device->getSceneManager();
 gui::IGUIEnvironment *guienv=device->getGUIEnvironment();

 //loading max created 3ds mesh file from local disk

 scene::IAnimatedMesh *planemesh=smgr->getMesh("G:/GameCoder/irrlicht-1.3.1/media/plane1.3ds");
 scene::ISceneNode *node=smgr->addAnimatedMeshSceneNode(planemesh);
 node->setMaterialTexture(0,driver->getTexture("G:/GameCoder/irrlicht-1.3.1/media/stones.jpg"));
 node->setMaterialType(video::EMT_LIGHTMAP);
 node->setMaterialFlag(video::EMF_LIGHTING,false);
 
 //adding to TA::physics

 core::aabbox3df abbox=planemesh->getBoundingBox();
 AABB aabb;
 aabb.Initialise(Vec3(abbox.getCenter().X,abbox.getCenter().Y,abbox.getCenter().Z),
  Vec3(abbox.getExtent().X,abbox.getExtent().Y,abbox.getExtent().Z)); 
 Physics::CreateInstance(aabb);
 Physics& physics = TA::Physics::GetInstance();
 
 //creating static object and collision object

 StaticObject *pStaticObject=StaticObject::CreateNew();
 TA::CollisionObjectAABBMesh *pStaticCollisionObject=TA::CollisionObjectAABBMesh::CreateNew();
 
 //Add polygon mesh into collision object by vertices and indices

 scene::IMeshBuffer *mb;
 int i;
 for(i=0;i<(int)planemesh->getMesh(0)->getMeshBufferCount();i++)
 {
  mb=(scene::IMeshBuffer*)planemesh->getMesh(0)->getMeshBuffer(i);
 }

 //initialise to collision object

 pStaticCollisionObject->Initialise(
  mb->getVertexCount(),
  mb->getIndexCount()/3,
  mb->getIndexCount());

 //add vertex 

 video::S3DVertex *mb_vertices=(irr::video::S3DVertex*)mb->getVertices();
 for(i=0;i<(int)mb->getVertexCount();i++)
 {
  pStaticCollisionObject->AddVertex(Vec3(mb_vertices[i].Pos.X,mb_vertices[i].Pos.Y,mb_vertices[i].Pos.Z));
  
 }

 //add polygon

 irr::u16 *mb_indices=mb->getIndices();
 int polygonList[3];
 for(i=0;i<(int)mb->getIndexCount();i+=3)
 {
  polygonList[0]=mb_indices[i+2];
  polygonList[1]=mb_indices[i+1];
  polygonList[2]=mb_indices[i];
  pStaticCollisionObject->AddPolygon(3,polygonList);
 }
 pStaticCollisionObject->FinishedAddingGeometry();

//release collision object

 pStaticObject->Initialise(pStaticCollisionObject);
 pStaticCollisionObject->Release();  

//release static object
 
physics.AddStaticObject(pStaticObject);
 pStaticObject->Release(); 
 
 //create dynamic object

 TA::DynamicObject *pDynamicObject=TA::DynamicObject::CreateNew();
 aabb.Initialise(TA::Vec3(0.0f, 0.0f, 0.0f),TA::Vec3(5.0f,5.0f, 5.0f)); 
 pDynamicObject->InitialiseAsABox(aabb);
 pDynamicObject->SetPosition(TA::Vec3(100.0f, 100.0f, 0.0f));

// these are optionals
 pDynamicObject->SetMass(5.0f);
 pDynamicObject->SetRestitution(0.5f);
 pDynamicObject->SetLinearVelocity(Vec3(0.0f,-10.0f,0.0f));
 pDynamicObject->SetAngularVelocity(Vec3(8.5f,2.5f,2.5f));

// these are optionals

 physics.AddDynamicObject(pDynamicObject);

  //create a irrlicht cube and add it to a node

 scene::ISceneNode *node1= smgr->addCubeSceneNode(5.0f);
 node1->setPosition(core::vector3df(100,100,0));
 node1->setMaterialTexture(0,driver->getTexture("G:/GameCoder/irrlicht-1.3.1/media/wood.jpg"));
 node1->setMaterialFlag(video::EMF_LIGHTING,false);

  //create a camera

 scene::ICameraSceneNode *cam=smgr->addCameraSceneNodeMaya();
 device->getCursorControl()->setVisible(false);
 cam->setPosition(core::vector3df(0,80,50));
 TA::Vec3 pos=pDynamicObject->GetPosition();
 cam->setTarget(core::vector3df(pos.x,pos.y-20,pos.z));

 float fDt = 1.0f/60.0f;
 core::matrix4 matrix;

  //main Loop

 while(device->run())
 {
  
   driver->beginScene(true,true,video::SColor(0,255,255,255));
   smgr->drawAll();
   guienv->drawAll();
   driver->endScene();

   physics.Update(fDt);//update TA

   TA::MFrame frame=pDynamicObject->GetFrame();
   TA::Mat33 rot=frame.m33Rotation;

  //matrix rotation
 
   matrix.setRotationRadians(core::vector3df(TA::EulerAngles(rot).x,TA::EulerAngles(rot).y,TA::EulerAngles(rot).z));
   

   node1->setRotation(matrix.getRotationDegrees());
   node1->setPosition(core::vector3df(frame.v3Translation.x,frame.v3Translation.y,frame.v3Translation.z));
   
   //to camera target u can remove if want

   TA::Vec3 pos=pDynamicObject->GetPosition();
   cam->setTarget(core::vector3df(pos.x,pos.y-20,pos.z));
 }
 Physics::DestroyInstance();
  driver->drop();
}

// You can download all needed files at http://groups.google.com/group/mur_games

[xray]

Really nice but I have problems loading a b3d file instead of your 3ds. With b3d the cube falls through the ground, so cant TA handle b3d meshes ?

[jsmurthy4]

In this example by clicking left mouse button u will release a box at particular speed on ur camera direction it will collide and rotate exactly in this I use matrix rotation

http://groups.google.com/group/mur_games/files

Code: Select all

//Bounce.h

#pragma once
#include <irrlicht.h>
#include "mySceneNodeAnimator.h"
#include <CollisionObjectAABBMesh.h>
#include <windows.h>

using namespace irr;
using namespace TA;

class bounce:public irr::IEventReceiver
{
public:
      bounce();
      void LoadScene();
      void Fire();
      void Run();
      bool OnEvent(const irr::SEvent &);
      ~bounce();
      irr::IrrlichtDevice *m_Device;
};


//mySceneNodeAnimator.h

#pragma once
#include<Irrlicht.h>
#include<Physics.h>
#pragma comment(lib,"Irrlicht.lib")

enum
{
      RIGID_BODY=0,
      ANIMATED_BODY,
      TERRAIN_BODY
};

class mySceneNodeAnimator:public irr::scene::ISceneNodeAnimator
{
public:
      mySceneNodeAnimator(irr::scene::ISceneNode *node,irr::f32 mass,irr::s32 collisionId=0);
      ~mySceneNodeAnimator();
      virtual void animateNode(irr::scene::ISceneNode *node,irr::u32  timeMs);
      static TA::Vec3 convertIrrlichtPos(irr::core::vector3df &pos);
      static irr::core::vector3df convertTAPos(const TA::Vec3 &p);
      static TA::Mat33 convertIrrlichtRot(irr::core::vector3df &rot);
      static irr::core::vector3df convertTARot(const TA::Mat33 &r);
      TA::DynamicObject *myDynamicObject;
};


//main.cpp

#include "bounce.h"
int main()
{
      srand(GetTickCount());
      bounce game;
      game.LoadScene();
      game.Run();
      return 0;
}


//bounce.cpp

#include "bounce.h"
bounce::bounce()
{
      irr::SIrrlichtCreationParameters    param=irr::SIrrlichtCreationParameters();
      param.DriverType= video::EDT_DIRECT3D9;
      param.Bits=16;
      param.WindowSize=irr::core::dimension2di(800,600);
      param.Stencilbuffer=true;
      param.Fullscreen=false;
      param.Vsync=true;
      param.EventReceiver=this;
      m_Device=createDeviceEx(param);
}

void bounce::LoadScene()
{
      video::IVideoDriver *driver=m_Device->getVideoDriver();
      scene::ISceneManager *smgr=m_Device->getSceneManager();
      scene::IAnimatedMesh *plane=smgr->getMesh("plane1.3ds");
      scene::ISceneNode *node=smgr->addAnimatedMeshSceneNode(plane);
     node->setMaterialTexture(0,driver->getTexture("stones.jpg"));
      node->setMaterialType(video::EMT_LIGHTMAP);
      node->setMaterialFlag(video::EMF_LIGHTING,false);
      core::aabbox3df abbox=plane->getBoundingBox();

      AABB aabb;
      aabb.Initialise(Vec3(0,0,0),Vec3(1000,1000,1000));

      TA::Physics::CreateInstance(aabb);
      TA::Physics &Physics=TA::Physics::GetInstance();
      TA::StaticObject *mystaticobject=TA::StaticObject::CreateNew();

      TA::CollisionObjectAABBMesh *mystaticcollision=TA::CollisionObjectAABBMesh::CreateNew();

      scene::IMeshBuffer *buf;
      for(int i=0;i<(int)plane->getMesh(0)->getMeshBufferCount();i++)
            buf=(scene::IMeshBuffer*)plane->getMesh(0)->getMeshBuffer(i);

      mystaticcollision->Initialise(buf->getVertexCount(),
            buf->getIndexCount()/3,
            buf->getIndexCount());
      video::S3DVertex *vtx=(video::S3DVertex *)buf->getVertices();

      for(int i=0;i<(int)buf->getVertexCount();i++)
      {
            TA::Vec3 vec=mySceneNodeAnimator::convertIrrlichtPos(vtx[i].Pos);
            mystaticcollision->AddVertex(vec);
      }
      irr::u16 *indices=buf->getIndices();
      int polygonlist[3];
    
  for(int i=0;i<(int)buf->getIndexCount();i+=3)
      {
            polygonlist[0]=indices[i+2];
            polygonlist[1]=indices[i+1];
            polygonlist[2]=indices[i];
            mystaticcollision->AddPolygon(3,polygonlist);
      }

      mystaticcollision->FinishedAddingGeometry();
      mystaticobject->Initialise(mystaticcollision);
      mystaticcollision->Release();
      Physics.AddStaticObject(mystaticobject);
      mystaticobject->Release();

      scene::IAnimatedMesh *mesh=smgr->getMesh("cube.3ds");
      core::vector3df pos(100,100,0);
      scene::IAnimatedMeshSceneNode *cube=smgr->addAnimatedMeshSceneNode(mesh,0,-1,pos);

      cube->addShadowVolumeSceneNode(-1,false);
      mySceneNodeAnimator *tok=new mySceneNodeAnimator(cube,1.0f);
      cube->addAnimator(tok);
      tok->drop();
      smgr->addLightSceneNode(0,core::vector3df(-50,50,-50),video::SColorf(1,1,1,1),1000);

      scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS(0, 50.0f, 50.0f);
      cam->setPosition(core::vector3df(0,10,-10));
      cam->setTarget(core::vector3df(0,0,0));
      m_Device->getCursorControl()->setVisible(false);
}

void bounce::Run(void) 
{
      video::IVideoDriver* driver = m_Device->getVideoDriver();
      scene::ISceneManager* smgr = m_Device->getSceneManager();
      TA::Physics& physics = TA::Physics::GetInstance();
      irr::ITimer *timer=m_Device->getTimer();
      irr::u32 prevtime = -1;

      while(m_Device->run() && m_Device->isWindowActive()) 
      {
            irr::u32 now = timer->getTime();
            if(prevtime == -1) prevtime=now;
            irr::u32 timeMs = (now - prevtime);
            physics.Update(timeMs/1000.0f);
    
 // update TAphysics.Update(1.0f/60.0f);

            prevtime = now;
            driver->beginScene(true, true, video::SColor(255,0,0,0));
            smgr->drawAll();
            driver->endScene();
      }

}

void bounce::Fire(void) 
{
      scene::ISceneManager* smgr = m_Device->getSceneManager();
      scene::ICameraSceneNode* cam = smgr->getActiveCamera();
      scene::IAnimatedMeshSceneNode *cube = smgr->addAnimatedMeshSceneNode(smgr->getMesh("cube.3ds"),0,-1,cam->getPosition()); 

      cube->addShadowVolumeSceneNode(-1,false);
      cube->setMaterialFlag(video::EMF_LIGHTING, false);
      cube->setMaterialTexture(0,m_Device->getVideoDriver()->getTexture("rocket.png"));

      mySceneNodeAnimator *tok=new mySceneNodeAnimator(cube, 1.0f, RIGID_BODY);

      cube->addAnimator(tok);
      tok->drop();      
      core::vector3df forward = (cam->getTarget()-cam->getPosition()).normalize();
      tok->myDynamicObject->SetLinearVelocity(mySceneNodeAnimator::convertIrrlichtPos(forward*100.0f));
      tok->myDynamicObject->SetRestitution(.01f);
}

bounce::~bounce(void) 
{
      TA::Physics& physics = TA::Physics::GetInstance();
      physics.DestroyInstance();
      m_Device->drop();
}

bool bounce::OnEvent(const irr::SEvent &event)
 {
      if(event.EventType == EET_MOUSE_INPUT_EVENT) {
            if(event.MouseInput.Event == EMIE_LMOUSE_PRESSED_DOWN) {
                  Fire();
                  return true;
            }
      }
      if(event.EventType == EET_KEY_INPUT_EVENT) 
      {
            if(event.KeyInput.Key == KEY_ESCAPE) 
            {
                  m_Device->closeDevice();
            }
      }
      return false;
}

//mySceneNodeAnimator.cpp

#include "mySceneNodeAnimator.h"
#define WORLD_SCALE 1.0f;

mySceneNodeAnimator::mySceneNodeAnimator(irr::scene::ISceneNode *node, irr::f32 mass, irr::s32 collissionID)
{
      TA::Physics &Physics=TA::Physics::GetInstance();
      irr::core::aabbox3df box=node->getBoundingBox();
      irr::core::vector3df extent=box.getExtent()/2;
      irr::core::vector3df center=box.getCenter()/2;
      myDynamicObject=TA::DynamicObject::CreateNew();
      TA::AABB aabb(convertIrrlichtPos(center),convertIrrlichtPos(extent));
      myDynamicObject->InitialiseAsABox(aabb);
      myDynamicObject->SetMass(mass);
      irr::core::vector3df pos = node->getPosition();
      irr::core::vector3df rot = node->getRotation();
      TA::MFrame frame(convertIrrlichtPos(pos),convertIrrlichtRot(rot));
      myDynamicObject->SetFrame(frame);
      Physics.AddDynamicObject(myDynamicObject);
      myDynamicObject->Release();
}

mySceneNodeAnimator::~mySceneNodeAnimator()
{

}

void mySceneNodeAnimator::animateNode(irr::scene::ISceneNode *node, irr::u32 timeMs)
{
      const TA::MFrame frame=myDynamicObject->GetFrame();
      node->setPosition(convertTAPos(frame.v3Translation));
      node->setRotation(convertTARot(frame.m33Rotation));
}

TA::Vec3 mySceneNodeAnimator::convertIrrlichtPos(irr::core::vector3df &pos) {

      // convert to TA vector
      TA::Vec3 tokpos(pos.X,pos.Y,pos.Z);
      return tokpos * WORLD_SCALE;
}

irr::core::vector3df mySceneNodeAnimator::convertTAPos(const TA::Vec3 &p) {

      //Now, we convert to irrlicht vector
      return irr::core::vector3df(p.x,p.y,p.z) / WORLD_SCALE;
}

TA::Mat33 mySceneNodeAnimator::convertIrrlichtRot(irr::core::vector3df &r) {
      irr::core::matrix4 mat;
      mat.setRotationDegrees(r);
      TA::Mat33 tamat;
      tamat(0,0)= mat(0,0) ;
      tamat(0,1)= mat(0,1) ;
      tamat(0,2)= mat(0,2) ;
      tamat(1,0)= mat(1,0) ;
      tamat(1,1)= mat(1,1) ;
      tamat(1,2)= mat(1,2) ;
      tamat(2,0)= mat(2,0) ;
      tamat(2,1)= mat(2,1) ;
      tamat(2,2)= mat(2,2) ;
      return tamat;
}

irr::core::vector3df mySceneNodeAnimator::convertTARot(const TA::Mat33 &r) {
      irr::core::matrix4 mat;
      mat(0,0) = r(0,0);
      mat(0,1) = r(0,1);
      mat(0,2) = r(0,2);
      mat(0,3) = 0.0f;
      mat(1,0) = r(1,0);
      mat(1,1) = r(1,1);
      mat(1,2) = r(1,2);
      mat(1,3) = 0.0f;
      mat(2,0) = r(2,0);
      mat(2,1) = r(2,1);
      mat(2,2) = r(2,2);
      mat(2,3) = 0.0f;
      mat(3,0) = 0.0f;
      mat(3,1) = 0.0f;
      mat(3,2) = 0.0f;
      mat(3,3) = 1.0f;
      return mat.getRotationDegrees();
}

http://groups.google.com/group/mur_games/files