OgreNewt_Debugger.h

Go to the documentation of this file.

/*
    OgreNewt Library
 
    Ogre implementation of Newton Game Dynamics SDK
 
    OgreNewt basically has no license, you may use any or all of the library however you desire... I hope it can help you in any way.
 
        by Walaber
        some changes by melven
 
*/
#ifndef _INCLUDE_OGRENEWT_DEBUGGER
#define _INCLUDE_OGRENEWT_DEBUGGER
 
 
#include "OgreNewt_Prerequisites.h"
#include "OgreNewt_Tools.h"
 
 
namespace Ogre
{
  class ManualObject;
}
 
namespace OgreNewt
{
 
 
 
  class _OgreNewtExport Debugger : public Ogre::Node::Listener
  {
 
  public:
    ~Debugger();
 
    /*
        \param smgr pointer to your Ogre::SceneManager
    */
    void init(Ogre::SceneManager* smgr);
 
    void deInit();
 
    virtual void nodeDestroyed(const Ogre::Node *);
 
 
    void showDebugInformation();
 
    void hideDebugInformation();
 
    void setDefaultColor(Ogre::ColourValue col);
 
    void setMaterialColor(const MaterialID* mat, Ogre::ColourValue col);
 
    void startRaycastRecording(bool markhitbodies = false);
 
    bool isRaycastRecording();
 
    bool isRaycastRecordingHitBodies();
 
    void clearRaycastsRecorded();
 
    void stopRaycastRecording();
 
    void setRaycastRecordingColor(Ogre::ColourValue rayCol, Ogre::ColourValue convexCol, Ogre::ColourValue hitBodyCol, Ogre::ColourValue prefilterDiscardedBodyCol);
 
    void addRay(const Ogre::Vector3 &startpt, const Ogre::Vector3 &endpt);
 
    void addConvexRay(const OgreNewt::ConvexCollisionPtr& col, const Ogre::Vector3 &startpt, const Ogre::Quaternion &colori, const Ogre::Vector3 &endpt);
 
    void addDiscardedBody(const OgreNewt::Body* body);
 
    void addHitBody(const OgreNewt::Body* body);
 
    // utility function to build a visual wire from shape for a collision
    void buildDebugObjectFromCollision(Ogre::ManualObject* object, Ogre::ColourValue colour, const NewtonCollision* shape) const;
 
  protected:
    friend class OgreNewt::World;
    Debugger(const OgreNewt::World* world);
 
    const OgreNewt::World*        m_world;
    Ogre::SceneManager*     m_sceneManager;
    Ogre::SceneNode*        m_debugnode;
    typedef std::map<int, Ogre::ColourValue> MaterialIdColorMap;
    MaterialIdColorMap      m_materialcolors;
    Ogre::ColourValue       m_defaultcolor;
 
    // raycast-debugging
    Ogre::SceneNode*        m_raycastsnode;
    bool                    m_recordraycasts;
    Ogre::ColourValue       m_raycol, m_convexcol, m_hitbodycol, m_prefilterdiscardedcol;
    bool                    m_markhitbodies;
 
    struct BodyDebugData
    {
      BodyDebugData() :
#ifdef OGRENEWT_NO_COLLISION_SHAREDPTR
        m_lastcol(NULL),
#endif
        m_node(NULL), m_lines(NULL), m_text(NULL), m_updated(false) {}
      CollisionPtr m_lastcol;
      Ogre::Vector3 m_scale;
      Ogre::SceneNode* m_node;
      Ogre::ManualObject* m_lines;
      OgreNewt::OgreAddons::MovableText* m_text;
      int m_updated;
    };
    typedef std::map<OgreNewt::Body*, BodyDebugData> BodyDebugDataMap;
    BodyDebugDataMap m_cachemap;
 
    void processBody(Body* body);
 
    void processJoint(Joint* joint);
 
    void clearBodyDebugDataCache();
 
    typedef std::list<Ogre::ManualObject*> ManualObjectList;
    ManualObjectList mRecordedRaycastObjects;
 
 
  private:
    Debugger() {}
 
    Debugger(const Debugger&) {}
 
    const Debugger& operator=(const Debugger& d) { return d; } // actually this implementation must *never* be used!
 
        static void _CDECL newtonPerPoly( void* userData, int vertexCount, const float* faceVertec, int id );
 
    static void _CDECL newtonprocessJoints(const NewtonJoint* joint, void* userData);
  };
 
}   // end namespace OgreNewt
 
 
#endif  // _INCLUDE_OGRENEWT_DEBUGGER