#include "ExampleApplication.h"
 // include OgreOde files
 #include "OgreOde_Core.h"
 
 #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
 #define WIN32_LEAN_AND_MEAN
 #include "windows.h"
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef struct{
     std::string charName;
     SceneNode* charNode;
     OgreOde::RayGeometry* charRay;
     // radius used to position ray above actual node position (at feet)
     Real radius;    
 }ODE_CHAR_INFO;
 
 // Declare a subclass of the ExampleFrameListener class
 class MyListener : 
     public ExampleFrameListener, 
     public OgreOde::CollisionListener, 
     public OgreOde::StepListener, 
     public OgreOde::TriangleMeshRayListener
 { 
 public:
     MyListener(RenderWindow* win, Camera* cam, SceneManager* sMgr, Root* mRoot ) 
         : ExampleFrameListener(win, cam)
    {
         mSceneMgr = sMgr;
 
         // create OgreOde World - from SimpleScenes demo
         world = new OgreOde::World(mSceneMgr);
         world->setGravity(Vector3(0,-9.80665,0));
         world->setCFM(10e-5);
         world->setERP(0.8);
         world->setAutoSleep(true);
         world->setContactCorrectionVelocity(1.0);
         world->setCollisionListener(this);
         world->setAutoSleepAngularThreshold(OgreOde::Utility::Infinity);
 
         // Create something that will step the world, but don't do it automatically
         stepper = new OgreOde::ForwardFixedQuickStepper(0.01);
         //stepper = new OgreOde::ExactVariableQuickStepper(_time_step);
         stepper->setAutomatic(OgreOde::Stepper::AutoMode_NotAutomatic,mRoot);
         stepper->setStepListener(this);
 
         //create_ODE_Terrain("yourTerrainFile.mesh",position,size);
         create_ODE_Terrain("HutTown.mesh",Vector3::ZERO,Vector3(10,10,10));
 
         //Entity* ent = mSceneMgr->createEntity("yourEntityName", "yourEntityFile.mesh");
         Entity* ent = mSceneMgr->createEntity("yourEntityName", "ninja.mesh");
         SceneNode* entNode = mSceneMgr->getRootSceneNode()->createChildSceneNode( "yourEntityNodeName", Vector3(0,20,0) );
         entNode->attachObject(ent);
         entNode->setScale(0.05,0.05,0.05);
 
         create_ODE_character( "yourEntityName", entNode );
 
         // attach and position the camera
         entNode->attachObject(cam);
         cam->setPosition(0,20,150);
    }
 
     ~MyListener()
     {
         // destroy to remove the characters, terrain and stepper
         // before destroying the OgreOde world
         destroy_ALL_ODE_characters();
         if(terrainTriMeshGeom) delete terrainTriMeshGeom;
 
         delete stepper;
         stepper = NULL;
 
         delete world;
         world = NULL;
     }
 
    bool frameStarted(const FrameEvent& evt)
    {
         mInputDevice->capture();
 
         // quit app
         if( mInputDevice->isKeyDown( Ogre::KC_ESCAPE ) ) return false;
 
         // basic movement
         Vector3 direction;
         if( mInputDevice->isKeyDown(Ogre::KC_W) )
         {
             direction = ode_characters[0].charNode->getWorldOrientation() * Ogre::Vector3::NEGATIVE_UNIT_Z;
             ode_characters[0].charNode->translate( direction * (evt.timeSinceLastFrame * 100) );
         }
         if( mInputDevice->isKeyDown(Ogre::KC_S) )
         {
             direction = ode_characters[0].charNode->getWorldOrientation() * Ogre::Vector3::UNIT_Z;
             ode_characters[0].charNode->translate( direction * (evt.timeSinceLastFrame * 100) );
         }
         if( mInputDevice->isKeyDown(Ogre::KC_A) )
         {
             ode_characters[0].charNode->rotate( Ogre::Vector3::UNIT_Y, (Radian(0.1)) * (evt.timeSinceLastFrame * 100) ); 
         }
         if( mInputDevice->isKeyDown(Ogre::KC_D) )
         {
             ode_characters[0].charNode->rotate( Ogre::Vector3::UNIT_Y, (Radian(-0.1)) * (evt.timeSinceLastFrame * 100) );
         }
 
         simulatePhysics(evt);
 
        return true;        
    }
 
    bool frameEnded(const FrameEvent& evt)
    {
        return ExampleFrameListener::frameEnded(evt);        
    }
 
     // OgreOde::CollisionListener function
     bool collision(OgreOde::Contact* contact)
     {
         // search through ode_characters and adjust each charNode's height
         for( std::vector< ODE_CHAR_INFO >::iterator it = ode_characters.begin(); it != ode_characters.end(); it++ )
         {
             if( contact->getFirstGeometry()->getID() == it->charRay->getID() ||
                 contact->getSecondGeometry()->getID() == it->charRay->getID() )
             {
                 it->charNode->setPosition(contact->getPosition());
                 break;
             }
         }
 
         return true;
     }
 
     // OgreOde::StepListener function
     bool preStep(Real time)
     {
         return true;
     }
 
     // reposition OgreOde Ray(s)
     void simulatePhysics( const FrameEvent &evt )
     {
         stepper->step(evt.timeSinceLastFrame);
         world->synchronise();
 
         Vector3 position;
 
         for( std::vector< ODE_CHAR_INFO >::iterator it = ode_characters.begin(); it != ode_characters.end(); it++ )
         {
             // raise desired ray position a little above character's scenenode
             position = it->charNode->getPosition();
                        // may need to raise it higher for better accuracy
             position.y += (it->radius * 2);
 
             // fire ray downward
             it->charRay->setDefinition(position,Vector3::NEGATIVE_UNIT_Y);
             // add ray to collisionListener
             it->charRay->collide(terrainTriMeshGeom,this);
         }
     }
 
     // Create the tri-mesh terrain from a mesh
     void create_ODE_Terrain( std::string meshFile, Vector3 position, Vector3 size )
     {
         SceneNode* sn = mSceneMgr->getRootSceneNode()->createChildSceneNode("TerrainNode",position);
         Entity* ent = mSceneMgr->createEntity("Terrain",meshFile.c_str());
         sn->attachObject(ent);
         sn->setScale(size);
 
         OgreOde::EntityInformer ei(ent,sn->_getFullTransform());
         terrainTriMeshGeom = ei.createStaticTriangleMesh(OgreOde::World::getSingletonPtr()->getDefaultSpace());
         terrainTriMeshGeom->setRayListener(this);
     }
 
     // create the character object
     void create_ODE_character( std::string name, SceneNode* baseNode )
     {
         AxisAlignedBox aab = baseNode->getAttachedObject(name.c_str())->getBoundingBox();
         Vector3 min = aab.getMinimum()*baseNode->getScale();
         Vector3 max = aab.getMaximum()*baseNode->getScale();
         Vector3 size(fabs(max.x-min.x),fabs(max.y-min.y),fabs(max.z-min.z));
         float radius = (size.x > size.z) ? size.z/2.0 : size.x/2;
 
         // create ray for character
         // associate node with array. Store data
         ODE_CHAR_INFO c;
         c.charName = name;
         c.charNode = baseNode;
                // may want to adjust the length of the ray for accuracy
         c.charRay = new OgreOde::RayGeometry(100);
         c.radius = radius;
         ode_characters.push_back(c);
     }
 
     void destroy_ODE_character( std::string name )
     {
         for( std::vector< ODE_CHAR_INFO >::iterator it = ode_characters.begin(); it != ode_characters.end(); it++ )
         {
             if( it->charName == name )
             {
                 it->charNode = NULL;
                 delete it->charRay;
                 ode_characters.erase(it);
                 break;
             }
         }
     }
 
     void destroy_ALL_ODE_characters()
     {
         for( std::vector< ODE_CHAR_INFO >::iterator it = ode_characters.begin(); it != ode_characters.end(); it++ )
         {
             it->charNode = NULL;
             delete it->charRay;
         }
         ode_characters.clear();
     }
 private:
     std::vector< ODE_CHAR_INFO > ode_characters;
     OgreOde::World* world;
     OgreOde::ForwardFixedQuickStepper* stepper;
     SceneManager* mSceneMgr;
 
     OgreOde::TriangleMeshGeometry* terrainTriMeshGeom;
 };
 
 // Declare a subclass of the ExampleApplication class
 class SampleApp : public ExampleApplication 
 {
 public:
   SampleApp() {}
 
 protected:
   // Define what is in the scene
   void createScene(void) {}
 
   // Create new frame listener
   void createFrameListener(void)
   {
       mFrameListener = new MyListener(mWindow, mCamera, mSceneMgr, mRoot);
       mRoot->addFrameListener(mFrameListener);
   }
 };
 
 #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
 INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR strCmdLine, INT )
 #else
 int main(int argc, char **argv)
 #endif
 {
    // Create application object
    SampleApp app;
 
    try {
        app.go();
    } catch( Exception& e ) {
 #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
        MessageBox( NULL, e.getFullDescription().c_str(), "An exception has occured!", MB_OK | MB_ICONERROR | MB_TASKMODAL);
 #else
        std::cerr << "An exception has occured: " << e.getFullDescription();
 #endif
    }
 
    return 0;
 }
 
 #ifdef __cplusplus
 }
 #endif