include/scenegraph/VertexBuffer.h

   1 #ifndef AWFUL_SCENEGRAPH_VERTEXBUFFER_H_
   2 #define AWFUL_SCENEGRAPH_VERTEXBUFFER_H_
   3
   4 #include "core/core.h"
   5 #include "scenegraph/scenegraph_export.h"
   6 #include "math/Vector2f.h"
   7 #include "math/Vector3f.h"
   8 #include "math/Vector4f.h"
   9 #include "math/Vector4u8.h"
  10 #include "IndexBuffer.h"
  11 #include <vector>
  12
  13 namespace awful { namespace scenegraph
  14 {
  15         class AWSCENEGRAPH_EXPORT VertexBuffer : public Serializable
  16         {
  17                 public:
  18                         enum e_AttrType
  19                         {
  20                                 at_float,
  21                                 at_double,
  22                                 at_Vector2f,
  23                                 at_Vector3f,
  24                                 at_Vector4f,
  25                                 at_Vector4u8
  26                         };
  27
  28                         enum e_Attr
  29                         {
  30                                 a_Position,
  31                                 a_Normal,
  32                                 a_Color,
  33                                 a_SecondaryColor,
  34                                 a_TexCoord0,
  35                                 a_TexCoord1,
  36                                 a_TexCoord2,
  37                                 a_TexCoord3,
  38                                 a_TexCoord4,
  39                                 a_TexCoord5,
  40                                 a_TexCoord6,
  41                                 a_TexCoord7,
  42                                 a_FogCoord
  43                         };
  44
  45                         VertexBuffer() {}
  46                         VertexBuffer( const Serialization_tag& ) {}
  47
  48                         // Vertex buffer binding and state management
  49                         void bind() const;
  50
  51                         void renderSetup() const
  52                         {
  53                                 if( ms_pBound == this )
  54                                         return;
  55
  56                                 bind();
  57                         }
  58
  59                         static void ClearBound()
  60                         {
  61                                 ms_pBound = static_cast< const VertexBuffer* >( 0 );
  62                         }
  63
  64                         // Vertex layout setup
  65                         void addAttribute( e_AttrType Type, e_Attr Attr );
  66
  67                         // Buffer allocation
  68                         void resize( uint32_t Size )
  69                         {
  70                                 m_Buffer.resize( Size );
  71                         }
  72
  73                         // Buffer access.
  74                         void setFloatAttribute( uint32_t VertexIndex, uint8_t AttributeIndex, float Value )
  75                         {
  76                                 // TODO: throw if the type doesn't match
  77                                 m_Buffer.put( VertexIndex, m_ColumnIndices[AttributeIndex], Value );
  78                         }
  79                         float getFloatAttribute( uint32_t VertexIndex, uint8_t AttributeIndex ) const
  80                         {
  81                                 return m_Buffer.get< float >( VertexIndex, m_ColumnIndices[AttributeIndex] );
  82                         }
  83
  84                         void setDoubleAttribute( uint32_t VertexIndex, uint8_t AttributeIndex, double Value )
  85                         {
  86                                 // TODO: throw if the type doesn't match
  87                                 m_Buffer.put( VertexIndex, m_ColumnIndices[AttributeIndex], Value );
  88                         }
  89                         float getDoubleAttribute( uint32_t VertexIndex, uint8_t AttributeIndex ) const
  90                         {
  91                                 return m_Buffer.get< double >( VertexIndex, m_ColumnIndices[AttributeIndex] );
  92                         }
  93
  94                         void setVector2fAttribute( uint32_t VertexIndex, uint8_t AttributeIndex, const math::Vector2f& Value )
  95                         {
  96                                 // TODO: throw if the type doesn't match
  97                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
  98                                 m_Buffer.put( VertexIndex, attrIndex, Value.x() );
  99                                 m_Buffer.put( VertexIndex, attrIndex + 1, Value.y() );
 100                         }
 101                         math::Vector2f getVector2fAttribute( uint32_t VertexIndex, uint8_t AttributeIndex ) const
 102                         {
 103                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
 104                                 return math::Vector2f( m_Buffer.get< float >( VertexIndex, attrIndex ),
 105                                                                            m_Buffer.get< float >( VertexIndex, attrIndex + 1 ) );
 106                         }
 107
 108                         void setVector3fAttribute( uint32_t VertexIndex, uint8_t AttributeIndex, const math::Vector3f& Value )
 109                         {
 110                                 // TODO: throw if the type doesn't match
 111                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
 112                                 m_Buffer.put( VertexIndex, attrIndex, Value.x() );
 113                                 m_Buffer.put( VertexIndex, attrIndex + 1, Value.y() );
 114                                 m_Buffer.put( VertexIndex, attrIndex + 2, Value.z() );
 115                         }
 116                         math::Vector3f getVector3fAttribute( uint32_t VertexIndex, uint8_t AttributeIndex ) const
 117                         {
 118                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
 119                                 return math::Vector3f( m_Buffer.get< float >( VertexIndex, attrIndex ),
 120                                                                            m_Buffer.get< float >( VertexIndex, attrIndex + 1 ),
 121                                                                            m_Buffer.get< float >( VertexIndex, attrIndex + 2 ) );
 122                         }
 123
 124                         void setVector4fAttribute( uint32_t VertexIndex, uint8_t AttributeIndex, const math::Vector4f& Value )
 125                         {
 126                                 // TODO: throw if the type doesn't match
 127                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
 128                                 m_Buffer.put( VertexIndex, attrIndex, Value.x() );
 129                                 m_Buffer.put( VertexIndex, attrIndex + 1, Value.y() );
 130                                 m_Buffer.put( VertexIndex, attrIndex + 2, Value.z() );
 131                                 m_Buffer.put( VertexIndex, attrIndex + 3, Value.w() );
 132                         }
 133                         math::Vector4f getVector4fAttribute( uint32_t VertexIndex, uint8_t AttributeIndex ) const
 134                         {
 135                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
 136                                 return math::Vector4f( m_Buffer.get< float >( VertexIndex, attrIndex ),
 137                                                                            m_Buffer.get< float >( VertexIndex, attrIndex + 1 ),
 138                                                                            m_Buffer.get< float >( VertexIndex, attrIndex + 2 ),
 139                                                                            m_Buffer.get< float >( VertexIndex, attrIndex + 3 ) );
 140                         }
 141
 142                         void setVector4u8Attribute( uint32_t VertexIndex, uint8_t AttributeIndex, const math::Vector4u8& Value )
 143                         {
 144                                 // TODO: throw if the type doesn't match
 145                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
 146                                 m_Buffer.put( VertexIndex, attrIndex, Value.r() );
 147                                 m_Buffer.put( VertexIndex, attrIndex + 1, Value.g() );
 148                                 m_Buffer.put( VertexIndex, attrIndex + 2, Value.b() );
 149                                 m_Buffer.put( VertexIndex, attrIndex + 3, Value.a() );
 150                         }
 151                         math::Vector4u8 getVector4u8Attribute( uint32_t VertexIndex, uint8_t AttributeIndex ) const
 152                         {
 153                                 uint8_t attrIndex = m_ColumnIndices[AttributeIndex];
 154                                 return math::Vector4u8( m_Buffer.get< uint8_t >( VertexIndex, attrIndex ),
 155                                                                             m_Buffer.get< uint8_t >( VertexIndex, attrIndex + 1 ),
 156                                                                             m_Buffer.get< uint8_t >( VertexIndex, attrIndex + 2 ),
 157                                                                             m_Buffer.get< uint8_t >( VertexIndex, attrIndex + 3 ) );
 158                         }
 159                 private:
 160                         void enableStates() const;
 161                         void disableStates() const;
 162
 163                         static ConstPointer< VertexBuffer > ms_pBound;
 164
 165                         typedef std::pair< e_AttrType, e_Attr > Attribute;
 166                         typedef std::vector< Attribute > AttributeVec;
 167
 168                         template< class C, typename T > friend struct awful::attribute_traits;
 169                         AttributeVec                    m_Attributes;
 170                         std::vector< uint8_t >  m_ColumnIndices;
 171                         DynamicBuffer                   m_Buffer;
 172         };
 173 }}
 174
 175 #endif