OgreNewt_Tools.cpp

Go to the documentation of this file.

#include "External/ogrenewt/OgreNewt_Stdafx.h"
#include "External/ogrenewt/OgreNewt_Tools.h"
#include "External/ogrenewt/OgreNewt_World.h"
#include "External/ogrenewt/OgreNewt_Body.h"
#include <iostream>
 
#include <OgreMaterialManager.h>
#include <OgreCamera.h>
#include <OgreHardwareBufferManager.h>
#include <OgreRoot.h>
#include <OgreShaderGenerator.h>
 
namespace OgreNewt
{
 
  namespace Converters
  {
 
    void MatrixToQuatPos(const float* matrix, Ogre::Quaternion& quat, Ogre::Vector3 &pos)
    {
      // this takes a matrix returned by Newton, and creates a Quaternion
      // and position Vector3, which is more meaningful for Ogre.
      using namespace Ogre;
      quat = Quaternion(Matrix3(matrix[0], matrix[4], matrix[8],
        matrix[1], matrix[5], matrix[9],
        matrix[2], matrix[6], matrix[10]));
 
      pos = Vector3(matrix[12], matrix[13], matrix[14]);
    }
 
    void QuatPosToMatrix(const Ogre::Quaternion& _quat, const Ogre::Vector3 &pos, dFloat* matrix)
    {
      // this takes a Quaternion and a Vector3 and creates a float array
      // which is more meaningful to Newton.
 
      using namespace Ogre;
      Matrix3 rot;
      Vector3 xcol, ycol, zcol;
 
      Ogre::Quaternion quat(_quat);
      quat.normalise();
      quat.ToRotationMatrix(rot);   // creates a 3x3 rotation matrix from the Quaternion.
 
      xcol = rot.GetColumn(0);
      ycol = rot.GetColumn(1);
      zcol = rot.GetColumn(2);
 
      // now fill the final matrix with the appropriate data:
      matrix[0] = dFloat(xcol.x);
      matrix[1] = dFloat(xcol.y);
      matrix[2] = dFloat(xcol.z);
      matrix[3] = dFloat(0.0);
 
      matrix[4] = dFloat(ycol.x);
      matrix[5] = dFloat(ycol.y);
      matrix[6] = dFloat(ycol.z);
      matrix[7] = dFloat(0.0);
 
      matrix[8] = dFloat(zcol.x);
      matrix[9] = dFloat(zcol.y);
      matrix[10] = dFloat(zcol.z);
      matrix[11] = dFloat(0.0);
 
      matrix[12] = dFloat(pos.x);
      matrix[13] = dFloat(pos.y);
      matrix[14] = dFloat(pos.z);
      matrix[15] = dFloat(1.0);
    }
 
    void MatrixToMatrix4(const dFloat* matrix_in, Ogre::Matrix4& matrix_out)
    {
      // from Newton to Ogre::Matrix4
      matrix_out = Ogre::Matrix4(Ogre::Real(matrix_in[0]), Ogre::Real(matrix_in[4]), Ogre::Real(matrix_in[8]), Ogre::Real(matrix_in[12]),
        Ogre::Real(matrix_in[1]), Ogre::Real(matrix_in[5]), Ogre::Real(matrix_in[9]), Ogre::Real(matrix_in[13]),
        Ogre::Real(matrix_in[2]), Ogre::Real(matrix_in[6]), Ogre::Real(matrix_in[10]), Ogre::Real(matrix_in[14]),
        Ogre::Real(matrix_in[3]), Ogre::Real(matrix_in[7]), Ogre::Real(matrix_in[11]), Ogre::Real(matrix_in[15]));
    }
 
    void Matrix4ToMatrix(const Ogre::Matrix4& matrix_in, dFloat* matrix_out)
    {
      // from Ogre to Newton.
      matrix_out[0] = matrix_in[0][0];
      matrix_out[1] = matrix_in[1][0];
      matrix_out[2] = matrix_in[2][0];
      matrix_out[3] = matrix_in[3][0];
 
      matrix_out[4] = matrix_in[0][1];
      matrix_out[5] = matrix_in[1][1];
      matrix_out[6] = matrix_in[2][1];
      matrix_out[7] = matrix_in[3][1];
 
      matrix_out[8] = matrix_in[0][2];
      matrix_out[9] = matrix_in[1][2];
      matrix_out[10] = matrix_in[2][2];
      matrix_out[11] = matrix_in[3][2];
 
      matrix_out[12] = matrix_in[0][3];
      matrix_out[13] = matrix_in[1][3];
      matrix_out[14] = matrix_in[2][3];
      matrix_out[15] = matrix_in[3][3];
    }
 
    Ogre::Quaternion grammSchmidt(const Ogre::Vector3& pin)
    {
      Ogre::Vector3 front, up, right;
      front = pin;
 
      front.normalise();
      if (Ogre::Math::Abs(front.z) > 0.577f)
        right = front.crossProduct(Ogre::Vector3(-front.y, front.z, 0.0f));
      else
        right = front.crossProduct(Ogre::Vector3(-front.y, front.x, 0.0f));
      right.normalise();
      up = right.crossProduct(front);
 
      Ogre::Matrix3 ret;
      ret.FromAxes(front, up, right);
 
      Ogre::Quaternion quat;
      quat.FromRotationMatrix(ret);
 
      return quat;
    }
  } // end namespace "converters"
 
 
  namespace CollisionTools
  {
 
    int CollisionPointDistance(const OgreNewt::World* world, const Ogre::Vector3& globalpt,
      const OgreNewt::CollisionPtr& col, const Ogre::Quaternion& colorient, const Ogre::Vector3& colpos,
      Ogre::Vector3& retpt, Ogre::Vector3& retnormal, int threadIndex)
    {
      dFloat matrix[16];
      dVector gPt;
      dVector fretPt;
      dVector fretNorm;
 
      gPt.m_x = dFloat(globalpt.x);
      gPt.m_y = dFloat(globalpt.y);
      gPt.m_z = dFloat(globalpt.z);
 
      Converters::QuatPosToMatrix(colorient, colpos, matrix);
      int ret = NewtonCollisionPointDistance(world->getNewtonWorld(), &gPt.m_x, col->getNewtonCollision(), matrix, &fretPt.m_x, &fretNorm.m_x, threadIndex);
 
      retpt.x = Ogre::Real(fretPt.m_x);
      retpt.y = Ogre::Real(fretPt.m_y);
      retpt.z = Ogre::Real(fretPt.m_z);
 
      retnormal.x = Ogre::Real(fretNorm.m_x);
      retnormal.y = Ogre::Real(fretNorm.m_y);
      retnormal.z = Ogre::Real(fretNorm.m_z);
 
      return ret;
    }
 
 
 
 
    int CollisionClosestPoint(const OgreNewt::World* world, const OgreNewt::CollisionPtr& colA, const Ogre::Quaternion& colOrientA, const Ogre::Vector3& colPosA,
      const OgreNewt::CollisionPtr& colB, const Ogre::Quaternion& colOrientB, const Ogre::Vector3& colPosB,
      Ogre::Vector3& retPosA, Ogre::Vector3& retPosB, Ogre::Vector3& retNorm, int threadIndex)
    {
      dFloat matrixA[16];
      dFloat matrixB[16];
      dVector fretPosA;
      dVector fretPosB;
      dVector fretNorm;
 
      Converters::QuatPosToMatrix(colOrientA, colPosA, matrixA);
      Converters::QuatPosToMatrix(colOrientB, colPosB, matrixB);
 
      int ret = NewtonCollisionClosestPoint(world->getNewtonWorld(), colA->getNewtonCollision(), matrixA, colB->getNewtonCollision(), matrixB, &fretPosA.m_x, &fretPosB.m_x, &fretNorm.m_x, threadIndex);
      retPosA.x = Ogre::Real(fretPosA.m_x);
      retPosA.y = Ogre::Real(fretPosA.m_y);
      retPosA.z = Ogre::Real(fretPosA.m_z);
 
      retPosB.x = Ogre::Real(fretPosB.m_x);
      retPosB.y = Ogre::Real(fretPosB.m_y);
      retPosB.z = Ogre::Real(fretPosB.m_z);
 
      retNorm.x = Ogre::Real(fretNorm.m_x);
      retNorm.y = Ogre::Real(fretNorm.m_y);
      retNorm.z = Ogre::Real(fretNorm.m_z);
 
      return ret;
    }
 
    Ogre::AxisAlignedBox CollisionCalculateFittingAABB(const OgreNewt::CollisionPtr& col, const Ogre::Quaternion& orient, const Ogre::Vector3& pos)
    {
      Ogre::Vector3 max, min;
 
      for (int i = 0; i < 3; i++)
      {
        Ogre::Vector3 currentDir, supportVertex;
 
        currentDir = Ogre::Vector3::ZERO;
        currentDir[i] = 1;
        currentDir = orient*currentDir;
        supportVertex = CollisionSupportVertex(col, currentDir) - pos;
        max[i] = supportVertex.dotProduct(currentDir);
 
        currentDir *= -1.0f;
        supportVertex = CollisionSupportVertex(col, currentDir) - pos;
        min[i] = -supportVertex.dotProduct(currentDir);
      }
 
      return Ogre::AxisAlignedBox(min, max);
    }
 
    Ogre::Vector3 CollisionSupportVertex(const OgreNewt::CollisionPtr& col, const Ogre::Vector3& dir)
    {
      Ogre::Vector3 ret;
      dVector fDir;
      dVector fRet;
      fDir.m_x = dFloat(dir.x);
      fDir.m_y = dFloat(dir.y);
      fDir.m_z = dFloat(dir.z);
 
      NewtonCollisionSupportVertex(col->getNewtonCollision(), &fDir.m_x, &fRet.m_x);
 
      ret.x = Ogre::Real(fRet.m_x);
      ret.y = Ogre::Real(fRet.m_y);
      ret.z = Ogre::Real(fRet.m_z);
 
      return ret;
    }
 
  }   // end namespace "CollisionTools"
 
  namespace Springs
  {
 
    Ogre::Real calculateSpringDamperAcceleration(Ogre::Real deltaTime, Ogre::Real springK,
      Ogre::Real stretchDistance, Ogre::Real springDamping, Ogre::Real dampVelocity)
    {
      return Ogre::Real(NewtonCalculateSpringDamperAcceleration(deltaTime, springK, stretchDistance, springDamping, dampVelocity));
    }
  }
 
 
  namespace OgreAddons
  {
    using namespace Ogre;
 
    const unsigned short POS_TEX_BINDING = 0;
    const unsigned short COLOUR_BINDING = 1;
 
    MovableText::MovableText(const String &name, const String &caption, const String &fontName, Real charHeight, const ColourValue &color)
      : mpCam(NULL)
      , mpWin(NULL)
      , mName(name)
      , mCaption(caption)
      , mFontName(fontName)
      , mCharHeight(charHeight)
      , mColor(color)
      , mType("MovableText")
      , mTimeUntilNextToggle(0)
      , mSpaceWidth(0)
      , mUpdateColors(true)
      , mOnTop(false)
      , mHorizontalAlignment(H_LEFT)
      , mVerticalAlignment(V_BELOW)
      , mGlobalTranslation(0.0)
      , mLocalTranslation(0.0)
    {
      if (name == "")
        throw Exception(Exception::ERR_INVALIDPARAMS, "Trying to create MovableText without name", "MovableText::MovableText");
 
      if (caption == "")
        throw Exception(Exception::ERR_INVALIDPARAMS, "Trying to create MovableText without caption", "MovableText::MovableText");
 
      mRenderOp.vertexData = NULL;
      this->setFontName(mFontName);
      this->_setupGeometry();
    }
 
    MovableText::~MovableText()
    {
      if (mRenderOp.vertexData)
        delete mRenderOp.vertexData;
      // May cause crashing... check this and comment if it does
      if (mpMaterial)
        MaterialManager::getSingletonPtr()->remove(mpMaterial->getName());
    }
 
    void MovableText::setFontName(const String &fontName)
    {
      if ((Ogre::MaterialManager::getSingletonPtr()->resourceExists(mName + "Material")))
      {
        Ogre::MaterialManager::getSingleton().remove(mName + "Material");
      }
 
      if (mFontName != fontName || !mpMaterial || !mpFont)
      {
        mFontName = fontName;
        mpFont = FontManager::getSingleton().getByName(mFontName);
        if (!mpFont)
        {
          mpFont = Ogre::FontManager::getSingleton().create(mFontName, "SO3/Internal");
          mpFont->setParameter("type", "truetype");
          mpFont->setParameter("source", "bluehigh.ttf");
          mpFont->setParameter("size", "10");
          mpFont->setParameter("resolution", "128");
          //throw Exception(Exception::ERR_ITEM_NOT_FOUND, "Could not find font " + fontName, "MovableText::setFontName");
        }
        mpFont->load();
        if (mpMaterial)
        {
          MaterialManager::getSingletonPtr()->remove(mpMaterial->getName());
          mpMaterial.reset();
        }
 
        mpMaterial = mpFont->getMaterial()->clone(mName + "Material");
        mpMaterial->setDepthCheckEnabled(!mOnTop);
        mpMaterial->setDepthBias(1.0, 1.0);
        mpMaterial->setDepthWriteEnabled(mOnTop);
        mpMaterial->setLightingEnabled(false);
        mpMaterial->setReceiveShadows(false);
 
        mpMaterial->getTechnique(0)->setSchemeName(Ogre::MSN_DEFAULT);
        if (!mpMaterial->isLoaded())
          mpMaterial->load();
 
        mNeedUpdate = true;
      }
    }
 
    void MovableText::setCaption(const String &caption)
    {
      if (caption != mCaption)
      {
        mCaption = caption;
        mNeedUpdate = true;
      }
    }
 
    void MovableText::setColor(const ColourValue &color)
    {
      if (color != mColor)
      {
        mColor = color;
        mUpdateColors = true;
      }
    }
 
    void MovableText::setCharacterHeight(Real height)
    {
      if (height != mCharHeight)
      {
        mCharHeight = height;
        mNeedUpdate = true;
      }
    }
 
    void MovableText::setSpaceWidth(Real width)
    {
      if (width != mSpaceWidth)
      {
        mSpaceWidth = width;
        mNeedUpdate = true;
      }
    }
 
    void MovableText::setTextAlignment(const HorizontalAlignment& horizontalAlignment, const VerticalAlignment& verticalAlignment)
    {
      if (mHorizontalAlignment != horizontalAlignment)
      {
        mHorizontalAlignment = horizontalAlignment;
        mNeedUpdate = true;
      }
      if (mVerticalAlignment != verticalAlignment)
      {
        mVerticalAlignment = verticalAlignment;
        mNeedUpdate = true;
      }
    }
 
    void MovableText::setGlobalTranslation(Vector3 trans)
    {
      mGlobalTranslation = trans;
    }
 
    void MovableText::setLocalTranslation(Vector3 trans)
    {
      mLocalTranslation = trans;
    }
 
    void MovableText::showOnTop(bool show)
    {
      if (mOnTop != show && mpMaterial)
      {
        mOnTop = show;
        mpMaterial->setDepthBias(1.0, 1.0);
        mpMaterial->setDepthCheckEnabled(!mOnTop);
        mpMaterial->setDepthWriteEnabled(mOnTop);
      }
    }
 
    void MovableText::_setupGeometry()
    {
      assert(mpFont);
      assert(mpMaterial);
 
      unsigned int vertexCount = static_cast<unsigned int>(mCaption.size() * 6);
 
      if (mRenderOp.vertexData)
      {
        // Removed this test as it causes problems when replacing a caption
        // of the same size: replacing "Hello" with "hello"
        // as well as when changing the text alignment
        //if (mRenderOp.vertexData->vertexCount != vertexCount)
        {
          delete mRenderOp.vertexData;
          mRenderOp.vertexData = NULL;
          mUpdateColors = true;
        }
      }
 
      if (!mRenderOp.vertexData)
        mRenderOp.vertexData = new VertexData();
 
      mRenderOp.indexData = 0;
      mRenderOp.vertexData->vertexStart = 0;
      mRenderOp.vertexData->vertexCount = vertexCount;
      mRenderOp.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
      mRenderOp.useIndexes = false;
 
      VertexDeclaration  *decl = mRenderOp.vertexData->vertexDeclaration;
      VertexBufferBinding   *bind = mRenderOp.vertexData->vertexBufferBinding;
      size_t offset = 0;
 
      // create/bind positions/tex.ccord. buffer
      if (!decl->findElementBySemantic(Ogre::VES_POSITION))
        decl->addElement(POS_TEX_BINDING, offset, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
 
      offset += VertexElement::getTypeSize(Ogre::VET_FLOAT3);
 
      if (!decl->findElementBySemantic(Ogre::VES_TEXTURE_COORDINATES))
        decl->addElement(POS_TEX_BINDING, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0);
 
      offset += VertexElement::getTypeSize(Ogre::VET_FLOAT2);
 
      HardwareVertexBufferSharedPtr ptbuf = HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(POS_TEX_BINDING),
        mRenderOp.vertexData->vertexCount,
        HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
      bind->setBinding(POS_TEX_BINDING, ptbuf);
 
      // Colours - store these in a separate buffer because they change less often
      if (!decl->findElementBySemantic(VES_DIFFUSE))
          decl->addElement(COLOUR_BINDING, 0, VET_COLOUR, VES_DIFFUSE);
 
      HardwareVertexBufferSharedPtr cbuf = HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(COLOUR_BINDING),
              mRenderOp.vertexData->vertexCount,
              HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY);
      bind->setBinding(COLOUR_BINDING, cbuf);
 
      size_t charlen = mCaption.size();
      float *pPCBuff = static_cast<float*>(ptbuf->lock(HardwareBuffer::HBL_DISCARD));
 
      float largestWidth = 0;
      float left = 0 * 2.0 - 0.1;
      float top = -((0 * 2.0) - 0.1);
 
      Real spaceWidth = mSpaceWidth;
      // Derive space width from a capital A
      if (spaceWidth == 0)
        spaceWidth = mpFont->getGlyphAspectRatio('A') * mCharHeight * 2.0f;
 
      // for calculation of AABB
      Ogre::Vector3 min, max, currPos;
      Ogre::Real maxSquaredRadius;
      bool first = true;
 
#define GetMax(x,y) x>y ? x : y
 
      // Use iterator
      String::iterator i, iend;
      iend = mCaption.end();
      bool newLine = true;
      Real len = 0.0f;
 
      Real verticalOffset = 0;
      switch (mVerticalAlignment)
      {
      case MovableText::V_ABOVE:
        verticalOffset = mCharHeight;
        break;
      case MovableText::V_CENTER:
        verticalOffset = 0.5f * mCharHeight;
        break;
      case MovableText::V_BELOW:
        verticalOffset = 0.0f;
        break;
      }
      // Raise the first line of the caption
      top += verticalOffset;
      for (i = mCaption.begin(); i != iend; ++i)
      {
        if (*i == '\n')
          top += verticalOffset * 2.0f;
      }
 
      for (i = mCaption.begin(); i != iend; ++i)
      {
        if (newLine)
        {
          len = 0.0f;
          for (String::iterator j = i; j != iend && *j != '\n'; j++)
          {
            if (*j == ' ')
              len += spaceWidth;
            else
              len += mpFont->getGlyphAspectRatio(*j) * mCharHeight * 2.0f;
          }
          newLine = false;
        }
 
        if (*i == '\n')
        {
          left = 0 * 2.0f - 0.1f;
          top -= mCharHeight * 2.0f;
          newLine = true;
          continue;
        }
 
        if (*i == ' ')
        {
          // Just leave a gap, no tris
          left += spaceWidth;
          // Also reduce tri count
          mRenderOp.vertexData->vertexCount -= 6;
          continue;
        }
 
        Real horiz_height = mpFont->getGlyphAspectRatio(*i);
        Real u1, u2, v1, v2;
        Ogre::Font::UVRect utmp;
        utmp = mpFont->getGlyphTexCoords(*i);
        u1 = utmp.left;
        u2 = utmp.right;
        v1 = utmp.top;
        v2 = utmp.bottom;
 
        // each vert is (x, y, z, u, v)
        //-------------------------------------------------------------------------------------
        // First tri
        //
        // Upper left
        if (mHorizontalAlignment == MovableText::H_LEFT)
          *pPCBuff++ = left;
        else
          *pPCBuff++ = left - (len / 2);
        *pPCBuff++ = top;
        *pPCBuff++ = -0.1;
        *pPCBuff++ = u1;
        *pPCBuff++ = v1;
 
        // Deal with bounds
        if (mHorizontalAlignment == MovableText::H_LEFT)
          currPos = Ogre::Vector3(left, top, -0.1);
        else
          currPos = Ogre::Vector3(left - (len / 2), top, -0.1);
        if (first)
        {
          min = max = currPos;
          maxSquaredRadius = currPos.squaredLength();
          first = false;
        }
        else
        {
          min.makeFloor(currPos);
          max.makeCeil(currPos);
          maxSquaredRadius = GetMax(maxSquaredRadius, currPos.squaredLength());
        }
 
        top -= mCharHeight * 2.0f;
 
        // Bottom left
        if (mHorizontalAlignment == MovableText::H_LEFT)
          *pPCBuff++ = left;
        else
          *pPCBuff++ = left - (len / 2);
        *pPCBuff++ = top;
        *pPCBuff++ = -0.1;
        *pPCBuff++ = u1;
        *pPCBuff++ = v2;
 
        // Deal with bounds
        if (mHorizontalAlignment == MovableText::H_LEFT)
          currPos = Ogre::Vector3(left, top, -0.1f);
        else
          currPos = Ogre::Vector3(left - (len / 2.0f), top, -0.1f);
        min.makeFloor(currPos);
        max.makeCeil(currPos);
        maxSquaredRadius = GetMax(maxSquaredRadius, currPos.squaredLength());
 
        top += mCharHeight * 2.0f;
        left += horiz_height * mCharHeight * 2.0f;
 
        // Top right
        if (mHorizontalAlignment == MovableText::H_LEFT)
          *pPCBuff++ = left;
        else
          *pPCBuff++ = left - (len / 2.0f);
        *pPCBuff++ = top;
        *pPCBuff++ = -0.1;
        *pPCBuff++ = u2;
        *pPCBuff++ = v1;
        //-------------------------------------------------------------------------------------
 
        // Deal with bounds
        if (mHorizontalAlignment == MovableText::H_LEFT)
          currPos = Ogre::Vector3(left, top, -0.1f);
        else
          currPos = Ogre::Vector3(left - (len / 2.0f), top, -0.1f);
        min.makeFloor(currPos);
        max.makeCeil(currPos);
        maxSquaredRadius = GetMax(maxSquaredRadius, currPos.squaredLength());
 
        //-------------------------------------------------------------------------------------
        // Second tri
        //
        // Top right (again)
        if (mHorizontalAlignment == MovableText::H_LEFT)
          *pPCBuff++ = left;
        else
          *pPCBuff++ = left - (len / 2.0f);
        *pPCBuff++ = top;
        *pPCBuff++ = -0.1f;
        *pPCBuff++ = u2;
        *pPCBuff++ = v1;
 
        currPos = Ogre::Vector3(left, top, -0.1f);
        min.makeFloor(currPos);
        max.makeCeil(currPos);
        maxSquaredRadius = GetMax(maxSquaredRadius, currPos.squaredLength());
 
        top -= mCharHeight * 2.0f;
        left -= horiz_height  * mCharHeight * 2.0f;
 
        // Bottom left (again)
        if (mHorizontalAlignment == MovableText::H_LEFT)
          *pPCBuff++ = left;
        else
          *pPCBuff++ = left - (len / 2.0f);
        *pPCBuff++ = top;
        *pPCBuff++ = -0.1f;
        *pPCBuff++ = u1;
        *pPCBuff++ = v2;
 
        currPos = Ogre::Vector3(left, top, -0.1f);
        min.makeFloor(currPos);
        max.makeCeil(currPos);
        maxSquaredRadius = GetMax(maxSquaredRadius, currPos.squaredLength());
 
        left += horiz_height  * mCharHeight * 2.0f;
 
        // Bottom right
        if (mHorizontalAlignment == MovableText::H_LEFT)
          *pPCBuff++ = left;
        else
          *pPCBuff++ = left - (len / 2.0f);
        *pPCBuff++ = top;
        *pPCBuff++ = -0.1f;
        *pPCBuff++ = u2;
        *pPCBuff++ = v2;
        //-------------------------------------------------------------------------------------
 
        currPos = Ogre::Vector3(left, top, -0.1f);
        min.makeFloor(currPos);
        max.makeCeil(currPos);
        maxSquaredRadius = GetMax(maxSquaredRadius, currPos.squaredLength());
 
        // Go back up with top
        top += mCharHeight * 2.0f;
 
        float currentWidth = (left + 0.1f) / 2.0f;
        if (currentWidth > largestWidth)
          largestWidth = currentWidth;
      }
 
      // Unlock vertex buffer
      ptbuf->unlock();
 
      // update AABB/Sphere radius
      mAABB = Ogre::AxisAlignedBox(min, max);
      mRadius = Ogre::Math::Sqrt(maxSquaredRadius);
 
      if (mUpdateColors)
        this->_updateColors();
 
      mNeedUpdate = false;
    }
 
    void MovableText::_updateColors(void)
    {
      assert(mpFont);
      assert(mpMaterial);
 
      // Convert to system-specific
      RGBA color;
      Root::getSingleton().convertColourValue(mColor, &color);
      HardwareVertexBufferSharedPtr vbuf = mRenderOp.vertexData->vertexBufferBinding->getBuffer(COLOUR_BINDING);
      if (!vbuf)
        return;
 
      RGBA *pDest = static_cast<RGBA*>(vbuf->lock(HardwareBuffer::HBL_DISCARD));
      for (int i = 0; i < (int)mRenderOp.vertexData->vertexCount; ++i)
          *pDest++ = color;
      vbuf->unlock();
 
      mUpdateColors = false;
    }
 
    const Quaternion& MovableText::getWorldOrientation(void) const
    {
      assert(mpCam);
      return const_cast<Quaternion&>(mpCam->getDerivedOrientation());
    }
 
    const Vector3& MovableText::getWorldPosition(void) const
    {
      assert(mParentNode);
      return mParentNode->_getDerivedPosition();
    }
 
    void MovableText::getWorldTransforms(Matrix4 *xform) const
    {
      if (this->isVisible() && mpCam)
      {
        Matrix3 rot3x3, scale3x3 = Matrix3::IDENTITY;
 
        // store rotation in a matrix
        mpCam->getDerivedOrientation().ToRotationMatrix(rot3x3);
 
        // parent node position
        Vector3 ppos = mParentNode->_getDerivedPosition() + Vector3::UNIT_Y*mGlobalTranslation;
        ppos += rot3x3*mLocalTranslation;
 
        // apply scale
        scale3x3[0][0] = mParentNode->_getDerivedScale().x / 2;
        scale3x3[1][1] = mParentNode->_getDerivedScale().y / 2;
        scale3x3[2][2] = mParentNode->_getDerivedScale().z / 2;
 
        // apply all transforms to xform
        *xform = (rot3x3 * scale3x3);
        xform->setTrans(ppos);
      }
    }
 
    void MovableText::getRenderOperation(RenderOperation &op)
    {
      if (this->isVisible())
      {
        if (mNeedUpdate)
          this->_setupGeometry();
        if (mUpdateColors)
          this->_updateColors();
        op = mRenderOp;
      }
    }
 
    void MovableText::_notifyCurrentCamera(Camera *cam)
    {
      mpCam = cam;
    }
 
    void MovableText::_updateRenderQueue(RenderQueue* queue)
    {
      if (this->isVisible())
      {
        if (mNeedUpdate)
          this->_setupGeometry();
        if (mUpdateColors)
          this->_updateColors();
 
        queue->addRenderable(this, mRenderQueueID, OGRE_RENDERABLE_DEFAULT_PRIORITY);
        //queue->addRenderable(this, mRenderQueueID, RENDER_QUEUE_SKIES_LATE);
      }
    }
 
    void MovableText::visitRenderables(Renderable::Visitor* visitor, bool debugRenderables)
    {
      visitor->visit(this, 0, debugRenderables);
    }
  }
}