libs/openengine/bullet/BtOgreExtras.h

Go to the documentation of this file.

/*
 * =====================================================================================
 *
 *       Filename:  BtOgreExtras.h
 *
 *    Description:  Contains the Ogre Mesh to Bullet Shape converters.
 *
 *        Version:  1.0
 *        Created:  27/12/2008 01:45:56 PM
 *
 *         Author:  Nikhilesh (nikki)
 *
 * =====================================================================================
 */

#ifndef _BtOgreShapes_H_
#define _BtOgreShapes_H_

#include "btBulletDynamicsCommon.h"
#include "OgreSimpleRenderable.h"
#include "OgreCamera.h"
#include "OgreHardwareBufferManager.h"
#include "OgreMaterialManager.h"
#include "OgreTechnique.h"
#include "OgrePass.h"

#include "OgreLogManager.h"

namespace BtOgre
{

typedef std::vector<Ogre::Vector3> Vector3Array;

//Converts from and to Bullet and Ogre stuff. Pretty self-explanatory.
class Convert
{
public:
    Convert() {};
    ~Convert() {};

    static btQuaternion toBullet(const Ogre::Quaternion &q)
    {
        return btQuaternion(q.x, q.y, q.z, q.w);
    }
    static btVector3 toBullet(const Ogre::Vector3 &v)
    {
        return btVector3(v.x, v.y, v.z);
    }

    static Ogre::Quaternion toOgre(const btQuaternion &q)
    {
        return Ogre::Quaternion(q.w(), q.x(), q.y(), q.z());
    }
    static Ogre::Vector3 toOgre(const btVector3 &v)
    {
        return Ogre::Vector3(v.x(), v.y(), v.z());
    }
};

//From here on its debug-drawing stuff. ------------------------------------------------------------------

class DynamicRenderable : public Ogre::SimpleRenderable
{
public:
  DynamicRenderable();
  virtual ~DynamicRenderable();

  void initialize(Ogre::RenderOperation::OperationType operationType,
                  bool useIndices);

  virtual Ogre::Real getBoundingRadius(void) const;
  virtual Ogre::Real getSquaredViewDepth(const Ogre::Camera* cam) const;

protected:
  size_t mVertexBufferCapacity;
  size_t mIndexBufferCapacity;

  virtual void createVertexDeclaration() = 0;

  void prepareHardwareBuffers(size_t vertexCount, size_t indexCount);

  virtual void fillHardwareBuffers() = 0;
};

class DynamicLines : public DynamicRenderable
{
  typedef Ogre::Vector3 Vector3;
  typedef Ogre::Quaternion Quaternion;
  typedef Ogre::Camera Camera;
  typedef Ogre::Real Real;
  typedef Ogre::RenderOperation::OperationType OperationType;

public:
  DynamicLines(OperationType opType=Ogre::RenderOperation::OT_LINE_STRIP);
  virtual ~DynamicLines();

  void addPoint(const Ogre::Vector3 &p);
  void addPoint(Real x, Real y, Real z);

  void setPoint(unsigned short index, const Vector3 &value);

  const Vector3& getPoint(unsigned short index) const;

  unsigned short getNumPoints(void) const;

  void clear();

  void update();

  void setOperationType(OperationType opType);
  OperationType getOperationType() const;

protected:
  virtual void createVertexDeclaration();
  virtual void fillHardwareBuffers();

private:
  std::vector<Vector3> mPoints;
  bool mDirty;
};

class DebugDrawer : public btIDebugDraw
{
protected:
    Ogre::SceneNode *mNode;
    btDynamicsWorld *mWorld;
    DynamicLines *mLineDrawer;
    bool mDebugOn;

public:

    DebugDrawer(Ogre::SceneNode *node, btDynamicsWorld *world)
        : mNode(node),
          mWorld(world),
          mDebugOn(true)
    {
        mLineDrawer = new DynamicLines(Ogre::RenderOperation::OT_LINE_LIST);
        mNode->attachObject(mLineDrawer);

                if (!Ogre::ResourceGroupManager::getSingleton().resourceGroupExists("BtOgre"))
                    Ogre::ResourceGroupManager::getSingleton().createResourceGroup("BtOgre");
                if (!Ogre::MaterialManager::getSingleton().resourceExists("BtOgre/DebugLines"))
                {
                    Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create("BtOgre/DebugLines", "BtOgre");
                    mat->setReceiveShadows(false);
                    mat->setSelfIllumination(1,1,1);
                }

        mLineDrawer->setMaterial("BtOgre/DebugLines");

        //mLineDrawer->setVisibilityFlags (1024);
    }

    ~DebugDrawer()
    {
                Ogre::MaterialManager::getSingleton().remove("BtOgre/DebugLines");
                Ogre::ResourceGroupManager::getSingleton().destroyResourceGroup("BtOgre");
        delete mLineDrawer;
    }

    void step()
    {
        if (mDebugOn)
        {
            mWorld->debugDrawWorld();
            mLineDrawer->update();
            mNode->needUpdate();
            mLineDrawer->clear();
        }
        else
        {
            mLineDrawer->clear();
            mLineDrawer->update();
            mNode->needUpdate();
        }
    }

    void drawLine(const btVector3& from,const btVector3& to,const btVector3& color)
    {
        mLineDrawer->addPoint(Convert::toOgre(from));
        mLineDrawer->addPoint(Convert::toOgre(to));
    }

    void drawContactPoint(const btVector3& PointOnB,const btVector3& normalOnB,btScalar distance,int lifeTime,const btVector3& color)
    {
        mLineDrawer->addPoint(Convert::toOgre(PointOnB));
        mLineDrawer->addPoint(Convert::toOgre(PointOnB) + (Convert::toOgre(normalOnB) * distance * 20));
    }

    void reportErrorWarning(const char* warningString)
    {
        Ogre::LogManager::getSingleton().logMessage(warningString);
    }

    void draw3dText(const btVector3& location,const char* textString)
    {
    }

    //0 for off, anything else for on.
    void setDebugMode(int isOn)
    {
        mDebugOn = (isOn == 0) ? false : true;

        if (!mDebugOn)
            mLineDrawer->clear();
    }

    //0 for off, anything else for on.
    int getDebugMode() const
    {
        return mDebugOn;
    }

};

}

#endif