Public API Reference

csgfx/vertexlistwalker.h

Go to the documentation of this file.

/*
  Copyright (C) 2005 by Marten Svanfeldt
            (C) 2006 by Frank Richter

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Library General Public
  License as published by the Free Software Foundation; either
  version 2 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Library General Public License for more details.

  You should have received a copy of the GNU Library General Public
  License along with this library; if not, write to the Free
  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_CSGFX_VERTEXLISTWALKER_H__
#define __CS_CSGFX_VERTEXLISTWALKER_H__

#include "cstool/rbuflock.h"

template<typename Tbase, typename Tcomplex = Tbase>
class csVertexListWalker
{
public:
  csVertexListWalker (iRenderBuffer* buffer, size_t desiredComponents = 0, 
    const Tbase* defaultComponents = 0) : currElement (0), bufLock (buffer), 
    defaultComponents (defaultComponents)
  {
    bufferComponents = buffer->GetComponentCount ();
    components = (desiredComponents != 0) ? desiredComponents : 
      bufferComponents;
    CS_ASSERT (components <= maxComponents);
    elements = buffer->GetElementCount();
    compType = buffer->GetComponentType();
    FetchCurrentElement();
  }


  operator Tbase const*() const
  {
    CS_ASSERT(currElement<elements);
    return convertedComps;
  }
  const Tcomplex& operator*() const
  {
    CS_ASSERT(currElement<elements);
    const Tbase* x = convertedComps;
    const Tcomplex* y = (Tcomplex*)x;
    return *y;
  }


  csVertexListWalker& operator++ ()
  {
    currElement++;
    FetchCurrentElement();
    return *this;
  }

  void ResetState ()
  {
    currElement = 0;
    FetchCurrentElement();
  }
private:
  size_t elements;
  size_t currElement;
  csRenderBufferLock<uint8> bufLock;
  
  size_t components;
  size_t bufferComponents;
  enum { maxComponents = 4 };
  Tbase convertedComps[maxComponents];
  const Tbase* const defaultComponents;
  csRenderBufferComponentType compType;
  
  const Tbase GetDefaultComponent (size_t n)
  {
    return (defaultComponents != 0) ? defaultComponents[n] : 
      ((n == 3) ? Tbase(1) : Tbase(0));
  }
  template<typename C>
  void FetchCurrentElementReal()
  {
    uint8* data = bufLock + (currElement * bufferComponents * sizeof (C));
    for (size_t c = 0; c < components; c++)
    {
      convertedComps[c] = 
        (c < bufferComponents) ? Tbase(*(C*)data) :
        GetDefaultComponent (c);
      data += sizeof (C);
    }
  }
  void FetchCurrentElement()
  {
    /* Avoid reading beyond buffer end
     * Don't assert here since FetchCurrentElement() is also called in
     * legitimate cases (i.e. operator++ while on the last valid element.
     * Assert in retrieval operators, though.
     */
    if (currElement >= elements) return;
    switch (compType)
    {
      default:
        CS_ASSERT(false);
      case CS_BUFCOMP_BYTE:
        FetchCurrentElementReal<char>();
        break;
      case CS_BUFCOMP_UNSIGNED_BYTE:
        FetchCurrentElementReal<unsigned char>();
        break;
      case CS_BUFCOMP_SHORT:
        FetchCurrentElementReal<short>();
        break;
      case CS_BUFCOMP_UNSIGNED_SHORT:
        FetchCurrentElementReal<unsigned short>();
        break;
      case CS_BUFCOMP_INT:
        FetchCurrentElementReal<int>();
        break;
      case CS_BUFCOMP_UNSIGNED_INT:
        FetchCurrentElementReal<unsigned int>();
        break;
      case CS_BUFCOMP_FLOAT:
        FetchCurrentElementReal<float>();
        break;
      case CS_BUFCOMP_DOUBLE:
        FetchCurrentElementReal<double>();
        break;
    }
  }
};

#endif // __CS_CSGFX_VERTEXLISTWALKER_H__

---