#include <btBulletDynamicsCommon.h>
#include <irrlicht.h>
#include <iostream>

using namespace irr;
using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;
       
// convert bullet vector to irrlicht vector
core::vector3df toIrrVec(const btVector3& v);

// convert
btVector3 toBtVec(const core::vector3df& v);

// get Euler angles in YXZ-order from bullet quaternion
core::vector3df quaternionToEuler(const btQuaternion& q);

// get bullet quaternion from angles in YXZ-order
btQuaternion eulerToQuaternion(const core::vector3df& euler);

// transform irrlicht matrix to bullet transform
btTransform toBtTransform(const core::matrix4& m);

// choose coordinates from vector
core::vector3df vecAxes(const core::vector3df& v, bool x, bool y, bool z);

// null vector
const btVector3 NullVector(0.0f, 0.0f, 0.0f);



int main ()
{
   std::cout << "Hello World!" << std::endl;
   int maxProxies = 1024;
   btVector3 worldAabbMin(-10000,-10000,-10000);
    btVector3 worldAabbMax(10000,10000,10000);
   btAxisSweep3* broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax,maxProxies);
   btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration();
    btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration);
   btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver;
   btDiscreteDynamicsWorld* dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,broadphase,solver,collisionConfiguration);
   dynamicsWorld->setGravity(btVector3(0,-10,0));

   btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0,1,0),1);
   btCollisionShape* fallShape = new btSphereShape(1);
    btDefaultMotionState* groundMotionState = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1),btVector3(0,-1,0)));
   btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0,groundMotionState,groundShape,btVector3(0,0,0));
    btRigidBody* groundRigidBody = new btRigidBody(groundRigidBodyCI);
   dynamicsWorld->addRigidBody(groundRigidBody);
    btDefaultMotionState* fallMotionState = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1),btVector3(0,50,0)));
   btScalar mass = 1;
    btVector3 fallInertia(0,0,0);
    fallShape->calculateLocalInertia(mass,fallInertia);
   btRigidBody::btRigidBodyConstructionInfo fallRigidBodyCI(mass,fallMotionState,fallShape,fallInertia);
    btRigidBody* fallRigidBody = new btRigidBody(fallRigidBodyCI);
    dynamicsWorld->addRigidBody(fallRigidBody);

   // Irrlicht
   IrrlichtDevice *device = createDevice(EDT_DIRECT3D9, core::dimension2d<s32>(640, 480));
    if (device == 0)
      return 1; // could not create selected driver.
     video::IVideoDriver* driver = device->getVideoDriver();
     scene::ISceneManager* smgr = device->getSceneManager();
meraSceneNodeFPS(0, 100.0f, 300.0f, -1, 0, 5, true, 1.0);
   device->getFileSystem()->addZipFileArchive("map.pk3");
   IAnimatedMesh* mesh = smgr->getMesh("addit.bsp");
   ISceneNode* node = 0;
   node = smgr->addOctTreeSceneNode(mesh->getMesh(0), 0, -1, 128);
    node->setPosition(core::vector3df(-1300,-144,-1249));
   ITriangleSelector* selector=smgr->createOctTreeTriangleSelector(mesh->getMesh(0), node,128);
    node->setTriangleSelector(selector);
   if (selector)
    {
      ISceneNodeAnimator* anim = smgr->createCollisionResponseAnimator(
        selector, camera, vector3df(20,40,35),
        vector3df(0,-1,0),
        vector3df(0,50,0));
        selector->drop();
        camera->addAnimator(anim);
        anim->drop();
   }

      // car
   IAnimatedMesh* mesh2 = smgr->getMesh("bat.3DS");
   ISceneNode *node3 = smgr->addAnimatedMeshSceneNode( mesh2 );
   node3->setMaterialFlag(EMF_LIGHTING, false);

    while(device->run())
     {

                driver->beginScene(true, true, SColor(255,100,101,140));
                smgr->drawAll();
                driver->endScene();
        }




   delete dynamicsWorld;
    delete solver;
    delete dispatcher;
    delete collisionConfiguration;
    delete broadphase;

   system("PAUSE");
   return 0;
}

vector3df toIrrVec(const btVector3& v)
{
   return (vector3df&)v;
}

btVector3 toBtVec(const vector3df& v)
{
   // btVector requires special byte alignment so better not take my chances.
   return btVector3(v.X, v.Y, v.Z);
}

vector3df quaternionToEuler(const btQuaternion& q) {
  vector3df euler;
  quaternion(q.getX(), q.getY(), q.getZ(), q.getW()).toEuler(euler);
  return euler;
}

btQuaternion eulerToQuaternion(const vector3df& euler) {
  return btQuaternion(euler.Y, euler.X, euler.Z);
}

btTransform toBtTransform(const matrix4& m) {
  btScalar* p = (btScalar*)m.pointer();
  return btTransform(
    btMatrix3x3(p[0], p[1], p[2], p[4], p[5], p[6], p[8], p[9], p[10]),
    btVector3(p[12], p[13], p[14])
    );
}

core::vector3df vecAxes(const core::vector3df& v, bool x, bool y, bool z) {
  vector3df c;
  if(x) c.X = v.X;
  if(y) c.Y = v.Y;
  if(z) c.Z = v.Z;
  return c;
}