SO3Lines.cpp

Go to the documentation of this file.

 
#include "SO3Utils/SO3Lines.h"
#include "SO3Utils/SO3Exception.h"
 
namespace SO3
{
 
bool SLines::_material_created = false;
 
SLines::SLines(const Ogre::ColourValue& defaultColour, bool dashed, bool disableDepth) : SimpleRenderable()
{
  colour = defaultColour;
 
        mRenderOp.vertexData = new Ogre::VertexData();
        mRenderOp.indexData = 0;
        mRenderOp.vertexData->vertexCount = 0;
        mRenderOp.vertexData->vertexStart = 0;
        mRenderOp.operationType = Ogre::RenderOperation::OT_LINE_LIST;
        mRenderOp.useIndexes = false;
  _drawn = false;
  mDashed = dashed;
 
  if (!_material_created)
  {
    Ogre::StringVector resourceGroups = Ogre::ResourceGroupManager::getSingletonPtr()->getResourceGroups();
    if(std::find(resourceGroups.begin(), resourceGroups.end(), SO3_INTERNAL_RESOURCE_GROUP) == resourceGroups.end())
      Ogre::ResourceGroupManager::getSingletonPtr()->createResourceGroup(SO3_INTERNAL_RESOURCE_GROUP);
    
    Ogre::MaterialPtr autocolour = Ogre::MaterialManager::getSingleton().create(std::string(SO3_INTERNAL_RESOURCE_GROUP)+"/LineAuto", SO3_INTERNAL_RESOURCE_GROUP);
    autocolour->setReceiveShadows(false);
    autocolour->getTechnique(0)->setLightingEnabled(true);
    autocolour->getTechnique(0)->getPass(0)->setVertexProgram("SO3/VS/LINECUSTOMCOLOR");
    autocolour->getTechnique(0)->getPass(0)->setFragmentProgram("SO3/FP/LINECUSTOMCOLOR");
 
    Ogre::MaterialPtr autocolournodepth = Ogre::MaterialManager::getSingleton().create(std::string(SO3_INTERNAL_RESOURCE_GROUP) + "/LineAutoNoDepth", SO3_INTERNAL_RESOURCE_GROUP);
    autocolournodepth->setReceiveShadows(false);
    autocolournodepth->getTechnique(0)->setLightingEnabled(true);
    autocolournodepth->getTechnique(0)->setDepthFunction(Ogre::CMPF_ALWAYS_PASS);
    autocolournodepth->getTechnique(0)->getPass(0)->setVertexProgram("SO3/VS/LINECUSTOMCOLOR");
    autocolournodepth->getTechnique(0)->getPass(0)->setFragmentProgram("SO3/FP/LINECUSTOMCOLOR");
    _material_created = true;
  }
 
  setCastShadows(false);
  std::string matName = (disableDepth) ? "/LineAutoNoDepth" : "/LineAuto";
  Ogre::MaterialPtr linemat = Ogre::MaterialManager::getSingleton().getByName(std::string(SO3_INTERNAL_RESOURCE_GROUP) + matName, SO3_INTERNAL_RESOURCE_GROUP);
  setMaterial(linemat);
  setCustomParameter(0, Ogre::Vector4(colour.r, colour.g, colour.b, colour.a));
}
 
SLines::~SLines()
{ 
  Clear();
  delete mRenderOp.vertexData;
}
 
void SLines::Clear()
{
  _points.clear();
  ClearDraw();
}
 
void SLines::ClearDraw()
{
  if (_drawn)
  {
    _drawn = false;
    mRenderOp.vertexData->vertexCount = 0;
  }
}
 
Ogre::ColourValue SLines::GetColour()
{
  return colour;
}
 
void SLines::SetColour(const Ogre::ColourValue& newColour)
{
  colour = newColour;
  setCustomParameter(0, Ogre::Vector4(colour.r, colour.g, colour.b, colour.a));
}
 
void SLines::AddLine(const Ogre::Vector3& start, const Ogre::Vector3& end)
{
  ClearDraw();
  // TODO optim last point = start point
  _points.push_back(start);
  _points.push_back(end);
}
 
void SLines::AddLine(const Ogre::Real& start_x, const Ogre::Real& start_y, const Ogre::Real& start_z, const Ogre::Real& end_x, const Ogre::Real& end_y, const Ogre::Real& end_z)
{
  AddLine(Ogre::Vector3(start_x,start_y,start_z), Ogre::Vector3(end_x,end_y,end_z));
}
 
void SLines::AddPoint(const size_t& pointIndex, const Ogre::Vector3& pt)
{
  if(pointIndex <= _points.size())
  {
     ClearDraw();
     if(pointIndex >= (_points.size() - 1))
       _points.push_back(pt);
     else
       _points.insert(_points.begin() + pointIndex + 1, pt);
  }
  else
    SO3_EXCEPT(SExceptionOutOfBound, "Index out of bound, no such point!", "SLines::AddPoint", true);
}
 
void SLines::AddPoint(const size_t& pointIndex, const Ogre::Real& x, const Ogre::Real& y, const Ogre::Real& z)
{
  AddPoint(pointIndex, Ogre::Vector3(x, y, z));
}
 
void SLines::AddPoint(const Ogre::Vector3& pt)
{
  ClearDraw();
  _points.push_back(pt);
}
 
void SLines::AddPoint(const Ogre::Real& x, const Ogre::Real& y, const Ogre::Real& z)
{
  AddPoint(Ogre::Vector3(x, y, z));
}
 
void SLines::RemovePoint(const size_t& pointIndex)
{
  if(pointIndex <= _points.size())
  {
     ClearDraw();
     _points.erase(_points.begin() + pointIndex);
  }
  else
    SO3_EXCEPT(SExceptionOutOfBound, "Index out of bound, no such point!", "SLines::RemovePoint", true);
}
 
size_t SLines::GetNumberOfPoints() const
{
  return _points.size();
}
 
Ogre::Vector3 SLines::GetPoint(const size_t& pointIndex)
{
  if(pointIndex <= _points.size())
  {
    return _points[pointIndex];
  }
  else
  {
    SO3_EXCEPT(SExceptionOutOfBound, "Index out of bound, no such point!", "SLines::GetPoint", true);
    return Ogre::Vector3::ZERO;
  }
}
 
void SLines::SetPoint(const size_t& pointIndex, const Ogre::Vector3& pt)
{
  if(pointIndex <= _points.size())
  {
    ClearDraw();
    _points[pointIndex] = pt;
  }
  else
    SO3_EXCEPT(SExceptionOutOfBound, "Index out of bound, no such point!", "SLines::SetPoint", true);
}
 
void SLines::SetPoint(const size_t& pointIndex, const Ogre::Real& x, const Ogre::Real& y, const Ogre::Real& z)
{
  SetPoint(pointIndex, Ogre::Vector3(x, y, z));
}
 
void SLines::SetDashed(bool dashed)
{
  mDashed = dashed;
}
 
bool SLines::GetDashed()
{
  return mDashed;
}
 
void SLines::Draw()
{
  if (mDashed)
  {
    DrawDash();
    return;
  }
 
  if (_drawn || _points.size() < 2)
    return;
  else
    _drawn = true;
 
  // Initialization, count * 2 - (first and last) for continuous lines
  mRenderOp.vertexData->vertexCount = (_points.size() * 2) - 2;
 
  Ogre::VertexDeclaration* decl = mRenderOp.vertexData->vertexDeclaration;
  Ogre::VertexBufferBinding* bind = mRenderOp.vertexData->vertexBufferBinding;
 
  //clear bindings
  bind->unsetAllBindings();
 
  // Setup vertex struct
  decl->removeAllElements();
  size_t currOffset = 0;
 
  // positions
  decl->addElement(0, currOffset, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
  currOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT3);
 
  decl->addElement(0, currOffset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES, 0);
  currOffset += Ogre::VertexElement::getTypeSize(Ogre::VET_FLOAT2);
 
  // Get vertex buffer
  Ogre::HardwareVertexBufferSharedPtr vbuf;
  vbuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(0),
                                                                                          mRenderOp.vertexData->vertexCount,
                                                                                          Ogre::HardwareBuffer::HBU_DYNAMIC);
  bind->setBinding(0, vbuf);
 
  // Drawing stuff
  float* pFloat;
  unsigned int size = (unsigned int)_points.size();
  unsigned char* pVert = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
  for(unsigned int i = 0; i < size; i++)
  {
    // VES_POSITION
    decl->getElement(0)->baseVertexPointerToElement(pVert, &pFloat);
    *pFloat++ = _points[i].x;
    *pFloat++ = _points[i].y;
    *pFloat++  = _points[i].z;
 
    // VES_TEXTURE_COORDINATES
    *pFloat++ = 0.0f;
    *pFloat++ = 0.0f;
 
    // Update pVert
    pVert += vbuf->getVertexSize();
 
    // double the vertex if this is not the first or last point
    if ((i != 0) && (i < size - 1))
    {
      // VES_POSITION
      decl->getElement(0)->baseVertexPointerToElement(pVert, &pFloat);
      *pFloat++ = _points[i].x;
      *pFloat++ = _points[i].y;
      *pFloat++   = _points[i].z;
 
      // VES_TEXTURE_COORDINATES
      *pFloat++ = 0.0f;
      *pFloat++ = 0.0f;
 
      // Update pVert
      pVert += vbuf->getVertexSize();
    }
  }
 
  vbuf->unlock();
  mBox.setInfinite();
}
 
void SLines::DrawDash()
{
  if (_drawn || _points.empty())
    return;
  else
    _drawn = true;
 
  mRenderOp.vertexData->vertexCount = _points.size();
 
  Ogre::VertexDeclaration* decl = mRenderOp.vertexData->vertexDeclaration;
  Ogre::VertexBufferBinding* bind = mRenderOp.vertexData->vertexBufferBinding;
  
  //clear bindings
  bind->unsetAllBindings();
 
  // Setup vertex struct
  decl->removeAllElements();
  decl->addElement(0, 0, Ogre::VET_FLOAT3, Ogre::VES_POSITION);
 
  Ogre::HardwareVertexBufferSharedPtr vbuf;
  vbuf = Ogre::HardwareBufferManager::getSingleton().createVertexBuffer(decl->getVertexSize(0),
                                                                                          mRenderOp.vertexData->vertexCount,
                                                                                          Ogre::HardwareBuffer::HBU_DYNAMIC);
  bind->setBinding(0, vbuf);
 
  // Drawing stuff
  float* pFloat;
  unsigned int size = (unsigned int)_points.size();
  unsigned char* pVert = static_cast<unsigned char*>(vbuf->lock(Ogre::HardwareBuffer::HBL_WRITE_ONLY));
  for(unsigned int i = 0; i < size; i++)
  {
    // VES_POSITION
    decl->getElement(0)->baseVertexPointerToElement(pVert, &pFloat);
    *pFloat++ = _points[i].x;
    *pFloat++ = _points[i].y;
    *pFloat   = _points[i].z;
 
    // Update pVert
    pVert += vbuf->getVertexSize();
  }
 
  vbuf->unlock();
  mBox.setInfinite();
}
 
Ogre::Real SLines::getSquaredViewDepth(const Ogre::Camera* cam) const
{
  Ogre::Vector3 vMin, vMax, vMid, vDist;
  vMin = mBox.getMinimum();
  vMax = mBox.getMaximum();
  vMid = ((vMin - vMax) * 0.5) + vMin;
  vDist = cam->getDerivedPosition() - vMid;
 
  return vDist.squaredLength();
}
 
Ogre::Real SLines::getBoundingRadius() const
{
  return Ogre::Math::Sqrt(std::max(mBox.getMaximum().squaredLength(), mBox.getMinimum().squaredLength()));
}
 
}