source/buffer.h

   1 #ifndef MSP_GL_BUFFER_H_
   2 #define MSP_GL_BUFFER_H_
   3
   4 #include <vector>
   5 #include "gl.h"
   6 #include <msp/gl/extensions/arb_vertex_buffer_object.h>
   7 #include <msp/gl/extensions/arb_uniform_buffer_object.h>
   8
   9 namespace Msp {
  10 namespace GL {
  11
  12 enum BufferType
  13 {
  14         ARRAY_BUFFER         = GL_ARRAY_BUFFER,
  15         ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER,
  16         PIXEL_PACK_BUFFER    = GL_PIXEL_PACK_BUFFER,
  17         PIXEL_UNPACK_BUFFER  = GL_PIXEL_UNPACK_BUFFER,
  18         UNIFORM_BUFFER       = GL_UNIFORM_BUFFER
  19 };
  20
  21 enum BufferUsage
  22 {
  23         STREAM_DRAW  = GL_STREAM_DRAW,
  24         STREAM_READ  = GL_STREAM_READ,
  25         STREAM_COPY  = GL_STREAM_COPY,
  26         STATIC_DRAW  = GL_STATIC_DRAW,
  27         STATIC_READ  = GL_STATIC_READ,
  28         STATIC_COPY  = GL_STATIC_COPY,
  29         DYNAMIC_DRAW = GL_DYNAMIC_DRAW,
  30         DYNAMIC_READ = GL_DYNAMIC_READ,
  31         DYNAMIC_COPY = GL_DYNAMIC_COPY
  32 };
  33
  34 class BufferRange;
  35
  36 /**
  37 A buffer for storing data in GL memory.  Putting vertex and index data in
  38 buffers can improve rendering performance.  The VertexArray, Mesh and
  39 UniformBlock classes contain built-in support for buffers.
  40 */
  41 class Buffer
  42 {
  43         friend class BufferRange;
  44
  45 private:
  46         BufferType type;
  47         BufferUsage usage;
  48         unsigned id;
  49         unsigned size;
  50
  51         static const Buffer *bound[5];
  52
  53 public:
  54         Buffer(BufferType);
  55         ~Buffer();
  56
  57 private:
  58         static void require_buffer_type(BufferType);
  59
  60 public:
  61         /** Sets the usage hint of the buffer.  It will take effect the next time
  62         the buffer's contents are defined. */
  63         void set_usage(BufferUsage);
  64
  65         /** Uploads data into the buffer, completely replacing any previous
  66         contents. */
  67         void data(unsigned, const void *);
  68
  69         /** Overwrites part of the buffer data with new data.  The buffer size can
  70         not be changed with this call. */
  71         void sub_data(unsigned, unsigned, const void *);
  72
  73         unsigned get_size() const { return size; }
  74
  75         BufferRange *create_range(unsigned, unsigned);
  76
  77         /** Binds the buffer in its default slot. */
  78         void bind() const { bind_to(type); }
  79
  80         /** Binds the buffer in an alternate slot. */
  81         void bind_to(BufferType) const;
  82
  83         /** Unbinds the buffer from its default slot. */
  84         void unbind() const { unbind_from(type); }
  85
  86         static const Buffer *current(BufferType t) { return binding(t); }
  87         static void unbind_from(BufferType);
  88 private:
  89         static const Buffer *&binding(BufferType);
  90         static bool set_current(BufferType, const Buffer *);
  91         static void restore(const Buffer *, BufferType);
  92 };
  93
  94
  95 /**
  96 An adaptor for Buffer to make it compatible with Bind.
  97 */
  98 template<BufferType T>
  99 class BufferAlias
 100 {
 101 private:
 102         const Buffer &buffer;
 103
 104 public:
 105         BufferAlias(const Buffer &b): buffer(b) { }
 106
 107         void bind() const { buffer.bind_to(T); }
 108         static const Buffer *current() { return Buffer::current(T); }
 109         static void unbind() { Buffer::unbind_from(T); }
 110 };
 111
 112
 113 /**
 114 A proxy for a subset of a buffer.  Can be bound for use with uniform blocks.
 115 */
 116 class BufferRange
 117 {
 118 private:
 119         Buffer &buffer;
 120         unsigned offset;
 121         unsigned size;
 122
 123         static std::vector<const BufferRange *> bound_uniform;
 124
 125 public:
 126         BufferRange(Buffer &, unsigned, unsigned);
 127
 128         void data(const void *);
 129
 130         void bind_to(BufferType, unsigned);
 131
 132         static const BufferRange *current(BufferType t, unsigned i) { return binding(t, i); }
 133         static void unbind_from(BufferType, unsigned);
 134 private:
 135         static const BufferRange *&binding(BufferType, unsigned);
 136         static bool set_current(BufferType, unsigned, const BufferRange *);
 137
 138 public:
 139         static unsigned get_n_uniform_buffer_bindings();
 140         static unsigned get_uniform_buffer_alignment();
 141 };
 142
 143 } // namespace GL
 144 } // namespace Msp
 145
 146 #endif