scenegraph/vtxarray.h

   1 #ifndef AWFUL_SCENEGRAPH_VTXARRAY_H_
   2 #define AWFUL_SCENEGRAPH_VTXARRAY_H_
   3
   4 #include "common.h"
   5 #include "vector2.h"
   6 #include "vector3.h"
   7 #include "rgbcolint.h"
   8 #include <vector>
   9
  10 /***** TODO
  11
  12 This template based vertex buffer is simple, efficient, very flexible and easy to extend. Me like.
  13 It will be a little less clean when it comes to serialization and language bindings however.
  14 For language bindings with swig, specific instances will have to be defined.
  15 Same thing with serialization.
  16
  17
  18 old notes from jerky, probably partially obsolete:
  19
  20 0. Just do a quick and dirty, plain vertex array implementation, implementing
  21 operator[] to access vertices, as well as points 1 and 3 below.
  22
  23 Later (= someday = when I feel like doing it) implement VBO support (points 2, 4 and 5 below)
  24
  25 1. Define vertex attributes (order + type) - All float as it seems the only properly supported
  26 format for speed
  27
  28 2. Make a mmap function (then access vertices with operator[])
  29
  30 3. A "select" or "activate" or "configure" function that makes it the current vertex array (binds the VBO
  31 and setup the vertex arrays)
  32
  33 4. uses only vbos for now. It will be possible to add some transparent fallback to regular vertex arrays
  34 later if needed (VBO is going to be part of the core starting with opengl 1.5, so
  35 it will probably always be available anyway)
  36
  37 5. more to come as I progress and read the VBO docs
  38
  39 */
  40
  41 namespace sluggish
  42 {
  43         class VtxArray : public RefCounted
  44         {
  45                 public:
  46                         virtual void disableStates() const = 0;
  47                         virtual void enableStates() const = 0;
  48                         virtual void bind() const = 0;
  49         };
  50
  51         namespace VtxAttr
  52         {
  53                 // Note: the classes used to represent these types must not be padded.
  54
  55                 class Position
  56                 {
  57                         public:
  58                                 typedef Vec3 type;
  59
  60                                 static void DisableState()
  61                                 {
  62                                         glDisableClientState( GL_VERTEX_ARRAY );
  63                                 }
  64
  65                                 static void EnableState()
  66                                 {
  67                                         glEnableClientState( GL_VERTEX_ARRAY );
  68                                 }
  69
  70                                 static void Bind( const type* pArray_, int Stride_ )
  71                                 {
  72                                         glVertexPointer( 3, GL_FLOAT, Stride_, pArray_ );
  73                                 }
  74                 };
  75
  76                 class Normal
  77                 {
  78                         public:
  79                                 typedef Vec3 type;
  80
  81                                 static void DisableState()
  82                                 {
  83                                         glDisableClientState( GL_NORMAL_ARRAY );
  84                                 }
  85
  86                                 static void EnableState()
  87                                 {
  88                                         glEnableClientState( GL_NORMAL_ARRAY );
  89                                 }
  90
  91                                 static void Bind( const type* pArray_, int Stride_ )
  92                                 {
  93                                         glNormalPointer( GL_FLOAT, Stride_, pArray_ );
  94                                 }
  95                 };
  96
  97                 class Color
  98                 {
  99                         public:
 100                                 typedef RGBColInt type;
 101
 102                                 static void DisableState()
 103                                 {
 104                                         glDisableClientState( GL_COLOR_ARRAY );
 105                                 }
 106
 107                                 static void EnableState()
 108                                 {
 109                                         glEnableClientState( GL_COLOR_ARRAY );
 110                                 }
 111
 112                                 static void Bind( const type* pArray_, int Stride_ )
 113                                 {
 114                                         glColorPointer( 4, GL_UNSIGNED_BYTE, Stride_, pArray_ );
 115                                 }
 116                 };
 117
 118                 class TexCoords
 119                 {
 120                         public:
 121                                 typedef Vec2 type;
 122
 123                                 static void DisableState()
 124                                 {
 125                                         glDisableClientState( GL_TEXTURE_COORD_ARRAY );
 126                                 }
 127
 128                                 static void EnableState()
 129                                 {
 130                                         glEnableClientState( GL_TEXTURE_COORD_ARRAY );
 131                                 }
 132
 133                                 static void Bind( const type* pArray_, int Stride_ )
 134                                 {
 135                                         glTexCoordPointer( 2, GL_FLOAT, Stride_, pArray_ );
 136                                 }
 137                 };
 138         }
 139
 140         template< class A1, class A2 = void, class A3 = void, class A4 = void > class Vertex
 141         {
 142                 public:
 143                         typename A1::type       a1;
 144                         typename A2::type       a2;
 145                         typename A3::type       a3;
 146                         typename A4::type       a4;
 147         };
 148
 149         template< class A1, class A2, class A3 > class Vertex< A1, A2, A3 >
 150         {
 151                 public:
 152                         typename A1::type       a1;
 153                         typename A2::type       a2;
 154                         typename A3::type       a3;
 155         };
 156
 157         template< class A1, class A2 > class Vertex< A1, A2 >
 158         {
 159                 public:
 160                         typename A1::type       a1;
 161                         typename A2::type       a2;
 162         };
 163
 164         template< class A1 > class Vertex< A1 >
 165         {
 166                 public:
 167                         typename A1::type       a1;
 168         };
 169
 170         template< class A1, class A2 = void, class A3 = void, class A4 = void >
 171         class VertexArray : public VtxArray, public std::vector< Vertex< A1, A2, A3, A4 > >
 172         {
 173                 public:
 174                         typedef Vertex< A1, A2, A3, A4 > vertex_type;
 175
 176                         VertexArray( typename std::vector< Vertex< A1, A2, A3, A4 > >::size_type Size_ ) :
 177                                 std::vector< Vertex< A1, A2, A3, A4 > >( Size_ )
 178                         {
 179                         }
 180
 181                         virtual void disableStates() const
 182                         {
 183                                 A1::DisableState();
 184                                 A2::DisableState();
 185                                 A3::DisableState();
 186                                 A4::DisableState();
 187                         }
 188
 189                         virtual void enableStates() const
 190                         {
 191                                 A1::EnableState();
 192                                 A2::EnableState();
 193                                 A3::EnableState();
 194                                 A4::EnableState();
 195                         }
 196
 197                         virtual void bind() const
 198                         {
 199                                 const typename A1::type* pA1Array = &( *this )[0].a1;
 200                                 A1::Bind( pA1Array, sizeof( vertex_type ) );
 201                                 const typename A2::type* pA2Array = &( *this )[0].a2;
 202                                 A2::Bind( pA2Array, sizeof( vertex_type ) );
 203                                 const typename A3::type* pA3Array = &( *this )[0].a3;
 204                                 A3::Bind( pA3Array, sizeof( vertex_type ) );
 205                                 const typename A4::type* pA4Array = &( *this )[0].a4;
 206                                 A4::Bind( pA4Array, sizeof( vertex_type ) );
 207                         }
 208         };
 209
 210         template< class A1, class A2, class A3 >
 211         class VertexArray< A1, A2, A3 > : public VtxArray, public std::vector< Vertex< A1, A2, A3 > >
 212         {
 213                 public:
 214                         typedef Vertex< A1, A2, A3 > vertex_type;
 215
 216                         VertexArray( typename std::vector< Vertex< A1, A2, A3 > >::size_type Size_ ) :
 217                                 std::vector< Vertex< A1, A2, A3 > >( Size_ )
 218                         {
 219                         }
 220
 221                         virtual void disableStates() const
 222                         {
 223                                 A1::DisableState();
 224                                 A2::DisableState();
 225                                 A3::DisableState();
 226                         }
 227
 228                         virtual void enableStates() const
 229                         {
 230                                 A1::EnableState();
 231                                 A2::EnableState();
 232                                 A3::EnableState();
 233                         }
 234
 235                         virtual void bind() const
 236                         {
 237                                 const typename A1::type* pA1Array = &( *this )[0].a1;
 238                                 A1::Bind( pA1Array, sizeof( vertex_type ) );
 239                                 const typename A2::type* pA2Array = &( *this )[0].a2;
 240                                 A2::Bind( pA2Array, sizeof( vertex_type ) );
 241                                 const typename A3::type* pA3Array = &( *this )[0].a3;
 242                                 A3::Bind( pA3Array, sizeof( vertex_type ) );
 243                         }
 244         };
 245
 246         template< class A1, class A2 >
 247         class VertexArray< A1, A2 > : public VtxArray, public std::vector< Vertex< A1, A2 > >
 248         {
 249                 public:
 250                         typedef Vertex< A1, A2 > vertex_type;
 251
 252                         VertexArray( typename std::vector< Vertex< A1, A2 > >::size_type Size_ ) :
 253                                 std::vector< Vertex< A1, A2 > >( Size_ )
 254                         {
 255                         }
 256
 257                         virtual void disableStates() const
 258                         {
 259                                 A1::DisableState();
 260                                 A2::DisableState();
 261                         }
 262
 263                         virtual void enableStates() const
 264                         {
 265                                 A1::EnableState();
 266                                 A2::EnableState();
 267                         }
 268
 269                         virtual void bind() const
 270                         {
 271                                 const typename A1::type* pA1Array = &( *this )[0].a1;
 272                                 A1::Bind( pA1Array, sizeof( vertex_type ) );
 273                                 const typename A2::type* pA2Array = &( *this )[0].a2;
 274                                 A2::Bind( pA2Array, sizeof( vertex_type ) );
 275                         }
 276         };
 277
 278         template< class A1 >
 279         class VertexArray< A1 > : public VtxArray, public std::vector< Vertex< A1 > >
 280         {
 281                 public:
 282                         typedef Vertex< A1 > vertex_type;
 283
 284                         VertexArray( typename std::vector< Vertex< A1 > >::size_type Size_ ) :
 285                                 std::vector< Vertex< A1 > >( Size_ )
 286                         {
 287                         }
 288
 289                         virtual void disableStates() const
 290                         {
 291                                 A1::DisableState();
 292                         }
 293
 294                         virtual void enableStates() const
 295                         {
 296                                 A1::EnableState();
 297                         }
 298
 299                         virtual void bind() const
 300                         {
 301                                 const typename A1::type* pA1Array = &( *this )[0].a1;
 302                                 A1::Bind( pA1Array, sizeof( vertex_type ) );
 303                         }
 304         };
 305 }
 306
 307 #endif