ogrehardwarebufferwrapper.h

使用stl技术,(还没看,是听说的)

#ifndef PYOGRE_HARDWAREBUFFERWRAPPER_H_INCLUDED
# define PYOGRE_HARDWAREBUFFERWRAPPER_H_INCLUDED

#include <deque>
#include <assert.h>
#include <OgreHardwareIndexBuffer.h>
#include <OgreHardwareVertexBuffer.h>
#include <OgreVector3.h>
#include "OgreSharedPtrWrapper.h"

typedef unsigned int VertexElementAccessor;

class HardwareBufferFormat
{
public:
   HardwareBufferFormat()
      : vertexSize_( 0 )
   {
   }

   VertexElementAccessor addElement( Ogre::VertexElementType theType,  
                                     Ogre::VertexElementSemantic semantic,
                                     unsigned int index = 0 )
   {
      Ogre::VertexElement element( 0, vertexSize_, theType, semantic, index );
      elements_.push_back( element );

      VertexElementAccessor accessor = element.getOffset();
      vertexSize_ += element.getSize();
      return accessor;
   }

   unsigned int getVertexSize() const
   {
      return vertexSize_;
   }

   void setElements( Ogre::VertexDeclaration *declaration,
                     unsigned int source )
   {
      for ( int index =0; index < elements_.size(); ++index )
      {
         const Ogre::VertexElement &element = elements_[index];
         declaration->addElement( source, element.getOffset(), element.getType(),
                                  element.getSemantic(), element.getIndex() );
      }
   }



private:
   std::deque<Ogre::VertexElement> elements_;
   unsigned int vertexSize_;
};


class HardwareBufferProxy
{
public:
   HardwareBufferProxy( void *buffer,
                        HardwareBufferFormat *format )
      : buffer_( static_cast<unsigned char *>(buffer) )
      , vertexSizeInByte_( format->getVertexSize() )
   {
   }

   void setFloat1( unsigned int index,
                   VertexElementAccessor accessor,
                   float f1 )
   {
      Ogre::Real *dest = getElementPointer<Ogre::Real>( index, accessor );
      dest[0] = f1;
   }

   void setFloat2( unsigned int index,
                   VertexElementAccessor accessor,
                   float f1,
                   float f2 )
   {
      Ogre::Real *dest = getElementPointer<Ogre::Real>( index, accessor );
      dest[0] = f1;
      dest[1] = f2;
   }

   void setFloat3( unsigned int index,
                   VertexElementAccessor accessor,
                   const Ogre::Vector3 &vector )
   {
      Ogre::Real *dest = getElementPointer<Ogre::Real>( index, accessor );
      dest[0] = vector.x;
      dest[1] = vector.y;
      dest[2] = vector.z;
   }

private:
   template<typename T>
   T *getElementPointer( unsigned int index,
                         VertexElementAccessor accessor )
   {
      return reinterpret_cast<T *>( buffer_ + index * vertexSizeInByte_ + accessor );
   }

private:
   unsigned char *buffer_;
   unsigned int vertexSizeInByte_;
};


inline void 
VertexDeclaration_setElements( Ogre::VertexDeclaration *declaration,
                               unsigned int source, 
                               HardwareBufferFormat *format )
{
   format->setElements( declaration, source );
}

inline HardwareBufferProxy
HardwareBuffer_lock( Ogre::HardwareBuffer *hardwareBuffer,
                     Ogre::HardwareBuffer::LockOptions options,
                     HardwareBufferFormat *format )
{
   return HardwareBufferProxy( hardwareBuffer->lock( options ), format );
}



#if 0 ///////////////////////////// DISABLED CODE BELOW: GCCXML internal compiler error!


// SharedPtr support
// Because the shared pointer are subsclass of SharedPtr, we need to expose them

namespace boost { namespace python {

// Used by boost::python to extract the pointed type
template<> 
struct pointee< Ogre::HardwareIndexBufferSharedPtr >
{
   typedef Ogre::HardwareIndexBuffer type;
};


// Used by boost::python to get the actual pointer
Ogre::HardwareIndexBuffer *get_pointer( const Ogre::HardwareIndexBufferSharedPtr &p ) 
{
   if ( p.isNull() )
      return 0;
   return p.get();
}


// Used by boost::python to extract the pointed type
template<> 
struct pointee< Ogre::HardwareVertexBufferSharedPtr >
{
   typedef Ogre::HardwareVertexBuffer type;
};


// Used by boost::python to get the actual pointer
Ogre::HardwareVertexBuffer *get_pointer( const Ogre::HardwareVertexBufferSharedPtr &p ) 
{
   if ( p.isNull() )
      return 0;
   return p.get();
}

} }

#endif



#endif // PYOGRE_HARDWAREBUFFERWRAPPER_H_INCLUDED