VertexDeclaration.cc

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/
 
 
 
#include <ACG/GL/acg_glew.hh>
#include <ACG/GL/gl.hh>
#include <ACG/GL/GLState.hh>
#include <ACG/ShaderUtils/GLSLShader.hh>
 
#include <QTextStream>
 
#include "VertexDeclaration.hh"
 
 
namespace ACG
{
 
VertexElement::VertexElement()
  : type_(0), numElements_(0), usage_(VERTEX_USAGE_SHADER_INPUT), shaderInputName_(0), pointer_(0), divisor_(0), vbo_(0)
{
}
 
 
void VertexElement::setByteOffset(unsigned int _offset)
{
  // union cast instead of reinterpret_cast for cross-platform compatibility
  union ptr2uint
  {
    unsigned long u;
    const void* p;
  } offset;
 
  offset.u = static_cast<unsigned long>(_offset);
 
  pointer_ = offset.p;
}
 
unsigned int VertexElement::getByteOffset() const
{
  // union cast instead of reinterpret_cast for cross-platform compatibility
  union ptr2uint
  {
    unsigned long u;
    const void* p;
  } offset;
 
  offset.p = pointer_;
 
  return static_cast<unsigned int>(offset.u);
}
 
bool VertexElement::operator ==(const VertexElement &_other) const
{
  return (type_ == _other.type_) &&
      (numElements_ == _other.numElements_) &&
      (usage_ == _other.usage_) &&
      (shaderInputName_ == _other.shaderInputName_) &&
      (pointer_ == _other.pointer_) &&
      (divisor_ == _other.divisor_) &&
      (vbo_ == _other.vbo_);
}
 
VertexDeclaration::VertexDeclaration()
: vertexStride_(0), strideUserDefined_(0)
{
 
}
 
 
VertexDeclaration::~VertexDeclaration()
{
 
}
 
 
void VertexDeclaration::addElement(const VertexElement* _pElement)
{
  addElements(1, _pElement);
}
 
void VertexDeclaration::addElement(unsigned int _type,
                                   unsigned int _numElements,
                                   VERTEX_USAGE _usage,
                                   const void* _pointer,
                                   const char* _shaderInputName,
                                   unsigned int _divisor,
                                   unsigned int _vbo)
{
  VertexElement* ve = new VertexElement();
 
  ve->type_ = _type;
  ve->numElements_ = _numElements;
  ve->usage_ = _usage;
  ve->shaderInputName_ = _shaderInputName;
  ve->pointer_ = _pointer;
  ve->divisor_ = _divisor;
  ve->vbo_ = _vbo;
  addElement(ve);
 
  delete ve;
}
 
void VertexDeclaration::addElement(unsigned int _type,
                                   unsigned int _numElements,
                                   VERTEX_USAGE _usage, 
                                   size_t _byteOffset,
                                   const char* _shaderInputName,
                                   unsigned int _divisor,
                                   unsigned int _vbo)
{
  VertexElement* ve = new VertexElement();
 
  ve->type_ = _type;
  ve->numElements_ = _numElements;
  ve->usage_ = _usage;
  ve->shaderInputName_ = _shaderInputName;
  ve->pointer_ = (void*)_byteOffset;
  ve->divisor_ = _divisor;
  ve->vbo_ = _vbo;
 
  addElement(ve);
 
  delete ve;
}
 
 
void VertexDeclaration::addElements(unsigned int _numElements, const VertexElement* _pElements)
{
  elements_.reserve(elements_.size() + _numElements);
 
  for (unsigned int i = 0; i < _numElements; ++i)
  {
    VertexElement tmp = _pElements[i];
    updateShaderInputName(&tmp);
    elements_.push_back(tmp);
  }
 
  updateOffsets();
 
  if (!strideUserDefined_)
  {
    // recompute vertex stride from declaration (based on last element)
 
    unsigned int n = getNumElements();
 
    if (n)
    {
      // stride = offset of last element + sizeof last element - offset of first element
 
      // union instead of reinterpret_cast for cross-platform compatibility
      union ptr2uint
      {
        unsigned long u;
        const void* p;
      } lastOffset, firstOffset;
 
 
 
      std::map<unsigned int, VertexElement*> vboFirstElements;
      std::map<unsigned int, VertexElement*> vboLastElements;
 
      for (unsigned int i = 0; i < n; ++i)
      {
        if (vboFirstElements.find(elements_[i].vbo_) == vboFirstElements.end())
          vboFirstElements[elements_[i].vbo_] = &elements_[i];
 
        vboLastElements[elements_[i].vbo_] = &elements_[i];
      }
 
 
      for (std::map<unsigned int, VertexElement*>::iterator it = vboFirstElements.begin(); it != vboFirstElements.end(); ++it)
      {
        VertexElement* lastElement = vboLastElements[it->first];
        firstOffset.p = it->second->pointer_;
        lastOffset.p = lastElement->pointer_;
 
        vertexStridesVBO_[it->first] = static_cast<unsigned int>(lastOffset.u + getElementSize( lastElement ) - firstOffset.u);
      }
 
      vertexStride_ = vertexStridesVBO_.begin()->second;
    }
  }
 
}
 
 
// union instead of reinterpret_cast for cross-platform compatibility, must be global for use in std::map
union VertexDeclaration_ptr2uint
{
  unsigned long u;
  const void* p;
};
 
void VertexDeclaration::updateOffsets()
{
  unsigned int numElements = getNumElements();
 
  if (!numElements) return;
 
 
  // separate offsets for each vbo
 
  std::map<unsigned int, VertexDeclaration_ptr2uint> vboOffsets;
  std::map<unsigned int, VertexElement*> vboPrevElements;
 
  for (unsigned int i = 0; i < numElements; ++i)
  {
    if (vboOffsets.find(elements_[i].vbo_) == vboOffsets.end())
    {
      vboOffsets[elements_[i].vbo_].p = elements_[i].pointer_;
      vboPrevElements[elements_[i].vbo_] = &elements_[i];
    }
  }
 
  for (unsigned int i = 0; i < numElements; ++i)
  {
    VertexElement* el = &elements_[i];
 
    bool updateOffset = false;
 
    if (el->pointer_)
    {
      vboOffsets[el->vbo_].p = el->pointer_;
      vboPrevElements[el->vbo_] = el;
    }
    else
    {
      VertexElement* prevEl = vboPrevElements[el->vbo_];
      if (prevEl != el)
      {
        updateOffset = true;
        vboOffsets[el->vbo_].u += getElementSize(prevEl);
      }
      vboPrevElements[el->vbo_] = el;
    }
 
    if (updateOffset)
      el->pointer_ = vboOffsets[el->vbo_].p;
  }
}
 
 
void VertexDeclaration::updateShaderInputName(VertexElement* _pElem)
{
  if (!_pElem->shaderInputName_)
  {
    assert(_pElem->usage_ != VERTEX_USAGE_SHADER_INPUT);
 
    const char* sz = "";
 
    switch (_pElem->usage_)
    {
    case VERTEX_USAGE_POSITION:     sz = "inPosition"; break;
    case VERTEX_USAGE_NORMAL:       sz = "inNormal"; break;
    case VERTEX_USAGE_TEXCOORD:     sz = "inTexCoord"; break;
    case VERTEX_USAGE_COLOR:        sz = "inColor"; break;
    case VERTEX_USAGE_BLENDWEIGHTS: sz = "inBlendWeights"; break;
    case VERTEX_USAGE_BLENDINDICES: sz = "inBlendIndices"; break;
 
    default:
      std::cerr << "VertexDeclaration::updateShaderInputName - unknown vertex usage - " << _pElem->usage_ << std::endl;
      break;
    }
 
    _pElem->shaderInputName_ = sz;
  }
}
 
 
unsigned int VertexDeclaration::getNumElements() const
{
  return elements_.size();
}
 
 
size_t VertexDeclaration::getGLTypeSize(unsigned int _type)
{
  size_t size = 0;
 
  switch (_type)
  {
  case GL_DOUBLE:
    size = 8; break;
 
  case GL_FLOAT:
  case GL_UNSIGNED_INT:
  case GL_INT:
    size = 4; break;
 
//  case GL_HALF_FLOAT_ARB:
  case 0x140B: // = GL_HALF_FLOAT_ARB
  case GL_SHORT:
  case GL_UNSIGNED_SHORT:
    size = 2; break;
 
  case GL_BYTE:
  case GL_UNSIGNED_BYTE:
    size = 1; break;
 
  default:
    std::cerr << "VertexDeclaration::getElementSize - unknown type - " << _type << std::endl;
    break;
  }
 
  return size;
}
 
 
 
size_t VertexDeclaration::getElementSize(const VertexElement* _pElement)
{
  return _pElement ? getGLTypeSize(_pElement->type_) * _pElement->numElements_ : 0;
}
 
 
 
 
 
 
 
 
void VertexDeclaration::activateFixedFunction() const
{
  unsigned int numElements = getNumElements();
  unsigned int vertexStride = getVertexStride();
 
  for (unsigned int i = 0; i < numElements; ++i)
  {
    const VertexElement* pElem = getElement(i);
 
    switch (pElem->usage_)
    {
    case VERTEX_USAGE_POSITION:
      {
        ACG::GLState::vertexPointer(pElem->numElements_, pElem->type_, vertexStride, pElem->pointer_);
        ACG::GLState::enableClientState(GL_VERTEX_ARRAY);
      } break;
 
    case VERTEX_USAGE_COLOR:
      {
        ACG::GLState::colorPointer(pElem->numElements_, pElem->type_, vertexStride, pElem->pointer_);
        ACG::GLState::enableClientState(GL_COLOR_ARRAY);
      } break;
 
    case VERTEX_USAGE_TEXCOORD:
      {
        glClientActiveTexture(GL_TEXTURE0);
        ACG::GLState::texcoordPointer(pElem->numElements_, pElem->type_, vertexStride, pElem->pointer_);
        ACG::GLState::enableClientState(GL_TEXTURE_COORD_ARRAY);
      } break;
 
    case VERTEX_USAGE_NORMAL:
      {
        assert(pElem->numElements_ == 3);
 
        ACG::GLState::normalPointer(pElem->type_, vertexStride, pElem->pointer_);
        ACG::GLState::enableClientState(GL_NORMAL_ARRAY);
      } break;
 
    default: break;
    }
 
    
  }
}
 
 
void VertexDeclaration::deactivateFixedFunction() const
{
  unsigned int numElements = getNumElements();
 
  for (unsigned int i = 0; i < numElements; ++i)
  {
    const VertexElement* pElem = getElement(i);
 
    switch (pElem->usage_)
    {
    case VERTEX_USAGE_POSITION: ACG::GLState::disableClientState(GL_VERTEX_ARRAY); break;
    case VERTEX_USAGE_COLOR: ACG::GLState::disableClientState(GL_COLOR_ARRAY); break;
    case VERTEX_USAGE_TEXCOORD: ACG::GLState::disableClientState(GL_TEXTURE_COORD_ARRAY); break;
    case VERTEX_USAGE_NORMAL: ACG::GLState::disableClientState(GL_NORMAL_ARRAY); break;
 
    default: break;
    }
  }
}
 
 
 
void VertexDeclaration::activateShaderPipeline(GLSL::Program* _prog) const
{
  assert(_prog);
 
  // setup correct attribute locations as specified
 
  unsigned int numElements = getNumElements();
 
  for (unsigned int i = 0; i < numElements; ++i)
  {
    unsigned int vertexStride = getVertexStride(i);
 
    const VertexElement* pElem = &elements_[i];
 
    int loc = _prog->getAttributeLocation(pElem->shaderInputName_);
 
    if (loc != -1)
    {
      // default: map integers to [-1, 1] or [0, 1] range
      // exception: blend indices for gpu skinning eventually
      GLboolean normalizeElem = GL_TRUE;
 
      if (pElem->usage_ == VERTEX_USAGE_BLENDINDICES)
        normalizeElem = GL_FALSE;
 
      GLint curVBO = 0;
      if (pElem->vbo_)
      {
        glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &curVBO);
        glBindBuffer(GL_ARRAY_BUFFER, pElem->vbo_);
      }
 
      glVertexAttribPointer(loc, pElem->numElements_,  pElem->type_, normalizeElem, vertexStride, pElem->pointer_);
 
      if (supportsInstancedArrays())
      {
        if( openGLVersionTest(3,3) )
        {
          glVertexAttribDivisor(loc, pElem->divisor_);
        }
        else
        {
          glVertexAttribDivisorARB(loc, pElem->divisor_);
        }
      }
      else if (pElem->divisor_)
        std::cerr << "error: VertexDeclaration::activateShaderPipeline - instanced arrays not supported by gpu!" << std::endl;
 
      glEnableVertexAttribArray(loc);
 
      if (curVBO)
        glBindBuffer(GL_ARRAY_BUFFER, curVBO);
    }
  }
}
 
 
void VertexDeclaration::deactivateShaderPipeline( GLSL::Program* _prog ) const
{
  assert(_prog);
 
  unsigned int numElements = getNumElements();
 
  for (unsigned int i = 0; i < numElements; ++i)
  {
    const VertexElement* pElem = &elements_[i];
 
    int loc = _prog->getAttributeLocation(pElem->shaderInputName_);
 
    if (loc != -1)
    {
      glDisableVertexAttribArray(loc);
 
      if (supportsInstancedArrays() && pElem->divisor_)
      {
        if( openGLVersionTest(3,3) )
        {
          glVertexAttribDivisor(loc, 0);
        }
        else
        {
          glVertexAttribDivisorARB(loc, 0);
        }
      }
    }
  }
}
 
 
 
const VertexElement* VertexDeclaration::getElement(unsigned int i) const
{
  return &elements_[i];
}
 
 
int VertexDeclaration::findElementIdByUsage(VERTEX_USAGE _usage) const
{
  for (size_t i = 0; i < elements_.size(); ++i)
    if (elements_[i].usage_ == _usage)
      return int(i);
  
  return -1;
}
 
const VertexElement* VertexDeclaration::findElementByUsage(VERTEX_USAGE _usage) const
{
  int eid = findElementIdByUsage(_usage);
 
  if (eid >= 0)
    return getElement((unsigned int)eid);
 
  return 0;
}
 
 
unsigned int VertexDeclaration::getVertexStride(unsigned int i) const
{
  if (strideUserDefined_)
    return vertexStride_;
 
  const VertexElement* element = getElement(i);
 
  if (element)
  {
    unsigned int vbo = getElement(i)->vbo_;
    std::map<unsigned int, unsigned int>::const_iterator it = vertexStridesVBO_.find(vbo);
 
    return (it != vertexStridesVBO_.end()) ? it->second : vertexStride_;
  }
 
  return 0;
}
 
 
void VertexDeclaration::setVertexStride(unsigned int _stride)
{
  strideUserDefined_ = 1;
  vertexStride_ = _stride;
}
 
void VertexDeclaration::clear()
{
  strideUserDefined_ = 0;
  vertexStride_ = 0;
 
  elements_.clear();
  vertexStridesVBO_.clear();
}
 
 
QString VertexDeclaration::toString() const
{
  // maps VERTEX_USAGE -> string
  const char* usageStrings[] = 
  {
    "POSITION",
    "NORMAL",
    "TEXCOORD",
    "COLOR",
    "BLENDWEIGHTS",
    "BLENDINDICES"
  };
 
  QString result;
 
  QTextStream resultStrm(&result);
  resultStrm << "stride = " << getVertexStride() << "\n";
 
 
  for (unsigned int i = 0; i < getNumElements(); ++i)
  {
    const VertexElement* el = getElement(i);
 
    // convert element-type GLEnum to string
    const char* typeString = "";
 
    switch (el->type_)
    {
    case GL_FLOAT: typeString = "GL_FLOAT"; break;
    case GL_DOUBLE: typeString = "GL_DOUBLE"; break;
 
    case GL_INT: typeString = "GL_INT"; break;
    case GL_UNSIGNED_INT: typeString = "GL_UNSIGNED_INT"; break;
 
    case GL_SHORT: typeString = "GL_SHORT"; break;
    case GL_UNSIGNED_SHORT: typeString = "GL_UNSIGNED_SHORT"; break;
 
    case GL_BYTE: typeString = "GL_BYTE"; break;
    case GL_UNSIGNED_BYTE: typeString = "GL_UNSIGNED_BYTE"; break;
    default: typeString = "unknown"; break;
    }
 
    // get usage in string form
    const char* usage = (el->usage_ < VERTEX_USAGE_SHADER_INPUT) ? usageStrings[el->usage_] : el->shaderInputName_;
 
    resultStrm << "element " << i
               << " - [type: " << typeString
               << ", count: " << el->numElements_
               << ", usage: " << usage
               << ", shader-input: " << el->shaderInputName_
               << ", offset: " << el->pointer_ 
               << ", divisor: " << el->divisor_ 
               << ", vbo: " << el->vbo_
               << ", stride: " << getVertexStride(i)
               << "]\n";
  }
 
  return result;
}
 
bool VertexDeclaration::operator ==(const VertexDeclaration &_other) const
{
  if (strideUserDefined_ != _other.strideUserDefined_ ||
      vertexStride_ != _other.vertexStride_)
    return false;
 
  if (elements_ != _other.elements_)
    return false;
 
  if (vertexStridesVBO_ != _other.vertexStridesVBO_)
    return false;
 
  return true;
}
 
bool VertexDeclaration::supportsInstancedArrays()
{
  static int status_ = -1;
 
  if (status_ < 0) // core in 3.3
    status_ = (checkExtensionSupported("GL_ARB_instanced_arrays") || openGLVersion(3,3)) ? 1 : 0;
 
  return status_ > 0;
}
 
//=============================================================================
} // namespace ACG
//=============================================================================