source: code/branches/physics/src/ogreode/OgreOdeFrameListener.h @ 1923

/*
    PhysicsFrameListener.h

        A very simple wrapper class for ODE
        primarily for the example car application
*/
#ifndef _PHYSICSFRAMELISTENER_H_
#define _PHYSICSFRAMELISTENER_H_

#include "OgreOdePreReqs.h"
#include <OgreSceneQuery.h>
#include <OgreFrameListener.h>

// Uncomment this if you're planning to use the Plane2D joint
// But you'll have to have modified ODE first!
// #define INCLUDE_PLANE2D_JOINT

/*
A physical thing
*/
class PhysicalThing : public Ogre::RaySceneQueryListener
{
public:
        // Doesn't actually do anything
        PhysicalThing(dSpace *space);
        ~PhysicalThing(void);

        // Just create geoms
    void makePlane(Ogre::Real a, Ogre::Real b, Ogre::Real c, Ogre::Real d);                             // Plane
    void makeBox(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Real lx, Ogre::Real ly, Ogre::Real lz);        // Box
    void makeSphere(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Real r);                            // Sphere

        // Create bodies and geoms
    void makePlane(dWorld *world, Ogre::SceneNode *node);
        void makeBox(dWorld *world, Ogre::SceneNode *node, Ogre::Real mass = 1, Ogre::Vector3 const &offs = Ogre::Vector3(0,0,0));
    void makeSphere(dWorld *world, Ogre::SceneNode *node, Ogre::Real mass = 1);
        void makeTerrainTriMesh(dWorld *world, Ogre::SceneManager *mgr, Ogre::Real grid_size, Ogre::Real grid_spacing);

        // Callback functions for the ray scene query functionality
        virtual bool queryResult(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance);
        virtual bool queryResult(Ogre::MovableObject *obj, Ogre::Real distance);

        // Update the position and orientation of the scene node we're controlling
        void update(void);

        // Utility functions to get at internal stuff
        Ogre::SceneNode *getNode(void);
        dBodyID getBodyID(void);
        dSpaceID getSpaceID(void);

protected:
        dGeom           *_geom;
        dBody           *_body;
        dSpace          *_space;
        Ogre::SceneNode *_node;

        std::list<Ogre::Vector3> _frag;

        dVector3 *_vertices;
        int *_indices;
};

/*
A Frame listener that implements the physics
*/
class PhysicsFrameListener : public Ogre::FrameListener
{
protected:
        // All the stuff we need for ODE
    dWorld          *world;
    dHashSpace      *space;
    dJointGroup     *contactgroup;
    dSpace          *current_space;
        bool                    paused;

        // Keep track of anything we've created
    std::list<PhysicalThing*>   things;
    std::list<dSimpleSpace*>    spaces;
        std::list<dJoint*>                      joints;
    
        // Adjustable variables
    Ogre::Real total_time,step_size;
        Ogre::Real k_spring,k_damper,k_tyre,k_mu,k_erp,k_cfm;

        // Utility function to find the physical thing associated with an Ogre scene node
        dBodyID getBodyID(Ogre::SceneNode *node);

public:
        // Standard constructor/destructor
    PhysicsFrameListener(void);
    ~PhysicsFrameListener(void);

        // Tell us when every frame's about to be started
    bool frameStarted(const Ogre::FrameEvent& evt);
        void pause(bool p = true);

        // Mainly so we can access internal stuff from the collision callback
    dWorld *getWorld(void){return world;};
    dSpace *getSpace(void){return space;};
    dJointGroup *getContactGroup(void){return contactgroup;};

        // Create things manually, no physical bodies 
        // so they won't move, but things will collide with them
    PhysicalThing *createPlane(Ogre::Real a,Ogre::Real b,Ogre::Real c,Ogre::Real d);
    PhysicalThing *createBox(Ogre::Real x,Ogre::Real y,Ogre::Real z,Ogre::Real lx,Ogre::Real ly,Ogre::Real lz);
    PhysicalThing *createSphere(Ogre::Real x,Ogre::Real y,Ogre::Real z,Ogre::Real r);

        // Create objects based on Ogre nodes, these nodes will then
        // come under control of the physics simulation and will move about
        // as if by magic!
        // Except for the plane, which can't actually be a physical body
        // and the trimesh which we're not going to allow to be a physical body
    PhysicalThing *createPlane(Ogre::SceneNode *node);
        PhysicalThing *createBox(Ogre::SceneNode *node,Ogre::Real mass = 1,Ogre::Vector3 const &offs = Ogre::Vector3(0,0,0));
    PhysicalThing *createSphere(Ogre::SceneNode *node,Ogre::Real mass = 1);
        PhysicalThing *createTerrainTriMesh(Ogre::SceneManager *mgr,Ogre::Real grid_size,Ogre::Real grid_spacing);

        // Create and activate a new space inside the standard hash space
        // Things won't collide within a space so (for example) the objects
        // that make up a car won't collide with each other
    dSimpleSpace *createSpace(void);

        // Create joints between the nodes specified
        // The order of n1/n2 does matter; n1 is what you want attaching
        // and n2 is what you want it attaching to
        dJoint *createHinge2(Ogre::SceneNode *n1,Ogre::SceneNode *n2,const Ogre::Vector3 &suspension = Ogre::Vector3(0,1,0),const Ogre::Vector3 &axle = Ogre::Vector3(1,0,0));
        dJoint *createHinge(Ogre::SceneNode *n1,Ogre::SceneNode *n2,const Ogre::Vector3 &axis = Ogre::Vector3(1,0,0));
        dJoint *createSlider(Ogre::SceneNode *n1,Ogre::SceneNode *n2,const Ogre::Vector3 &axis = Ogre::Vector3(0,1,0));
        dJoint *createBall(Ogre::SceneNode *n1,Ogre::SceneNode *n2);
#ifdef INCLUDE_PLANE2D_JOINT
        dJoint *createPlane2D(Ogre::SceneNode *n);
#endif

        // Apply forces to a body under our control
        void addTorque(Ogre::SceneNode *n,const Ogre::Vector3 &force);

        // Set the parameters used for the CFM/ERP joint parameters
        void setSuspension(Ogre::Real spring,Ogre::Real damper);

        // Set the acceleration due to gravity
        void setGravity(Ogre::Real g);

        // Get our constants
        Ogre::Real getTyre(void){return k_tyre;};
        Ogre::Real getMu(void){return k_mu;};
        Ogre::Real getCFM(void){return k_cfm;};
        Ogre::Real getERP(void){return k_erp;};

        // Static function for ODE to call when collisions (potentially) occur
    static void collisionCallback(void *data,dGeomID o1,dGeomID o2);
};

#endif