source/uniform.h

   1 #ifndef MSP_GL_UNIFORM_H_
   2 #define MSP_GL_UNIFORM_H_
   3
   4 #include <algorithm>
   5 #include "program.h"
   6
   7 namespace Msp {
   8 namespace GL {
   9
  10 class Uniform
  11 {
  12 protected:
  13         Uniform() { }
  14 private:
  15         Uniform(const Uniform &);
  16         Uniform &operator=(const Uniform &);
  17 public:
  18         virtual ~Uniform() { }
  19
  20         virtual void apply(int) const = 0;
  21         virtual void store(const Program::UniformInfo &, void *) const = 0;
  22         virtual Uniform *clone() const = 0;
  23 };
  24
  25
  26 template<typename T>
  27 class UniformScalar: public Uniform
  28 {
  29 public:
  30         typedef T BaseType;
  31         typedef T Type;
  32
  33 private:
  34         Type value;
  35
  36 public:
  37         UniformScalar(Type v): value(v) { }
  38
  39         void set(Type v) { value = v; }
  40
  41         Type get() const { return value; }
  42
  43         virtual void apply(int index) const
  44         { apply(index, 1, &value); }
  45
  46         static void apply(int, unsigned, const T *);
  47
  48         virtual void store(const Program::UniformInfo &info, void *buffer) const
  49         { store(info, buffer, &value); }
  50
  51         static void store(const Program::UniformInfo &, void *buffer, const T *value)
  52         { *reinterpret_cast<T *>(buffer) = *value; }
  53
  54         virtual UniformScalar *clone() const
  55         { return new UniformScalar(value); }
  56 };
  57
  58 typedef UniformScalar<int> Uniform1i;
  59 typedef UniformScalar<float> Uniform1f;
  60
  61
  62 template<typename T, unsigned vecsize>
  63 class UniformVector: public Uniform
  64 {
  65 public:
  66         typedef T BaseType;
  67         typedef T Type[vecsize];
  68
  69 private:
  70         Type value;
  71
  72 public:
  73         UniformVector(const T *vp) { set(vp); }
  74
  75         void set(const T *vp)
  76         { std::copy(vp, vp+vecsize, value); }
  77
  78         BaseType get(unsigned i) const { return value[i]; }
  79
  80         virtual void apply(int index) const
  81         { apply(index, 1, value); }
  82
  83         static void apply(int index, unsigned size, const T *value);
  84
  85         virtual void store(const Program::UniformInfo &info, void *buffer) const
  86         { store(info, buffer, value); }
  87
  88         static void store(const Program::UniformInfo &, void *buffer, const T *value)
  89         { std::copy(value, value+vecsize, reinterpret_cast<T *>(buffer)); }
  90
  91         virtual UniformVector *clone() const
  92         { return new UniformVector(value); }
  93 };
  94
  95 typedef UniformVector<int, 2> Uniform2i;
  96 typedef UniformVector<float, 2> Uniform2f;
  97 typedef UniformVector<int, 3> Uniform3i;
  98 typedef UniformVector<float, 3> Uniform3f;
  99 typedef UniformVector<int, 4> Uniform4i;
 100 typedef UniformVector<float, 4> Uniform4f;
 101
 102
 103 template<typename T, unsigned rows, unsigned cols>
 104 class UniformMatrix: public Uniform
 105 {
 106 public:
 107         typedef T BaseType;
 108         typedef T Type[rows*cols];
 109
 110 private:
 111         Type value;
 112
 113 public:
 114         UniformMatrix(const T *vp) { set(vp); }
 115
 116         void set(const T *vp)
 117         { std::copy(vp, vp+rows*cols, value); }
 118
 119         virtual void apply(int index) const
 120         { apply(index, 1, value); }
 121
 122         static void apply(int index, unsigned size, const T *value);
 123
 124         virtual void store(const Program::UniformInfo &info, void *buffer) const
 125         { store(info, buffer, value); }
 126
 127         static void store(const Program::UniformInfo &info, void *buffer, const T *value)
 128         {
 129                 for(unsigned i=0; i<cols; ++i)
 130                         UniformVector<T, rows>::store(info, reinterpret_cast<char *>(buffer)+i*info.matrix_stride, value+i*rows);
 131         }
 132
 133         virtual UniformMatrix *clone() const
 134         { return new UniformMatrix(value); }
 135 };
 136
 137 // The naming of these types follows the OpenGL convention of columns x rows
 138 typedef UniformMatrix<float, 2, 2> UniformMatrix2x2f;
 139 typedef UniformMatrix<float, 2, 3> UniformMatrix3x2f;
 140 typedef UniformMatrix<float, 2, 4> UniformMatrix4x2f;
 141 typedef UniformMatrix<float, 3, 2> UniformMatrix2x3f;
 142 typedef UniformMatrix<float, 3, 3> UniformMatrix3x3f;
 143 typedef UniformMatrix<float, 3, 4> UniformMatrix4x3f;
 144 typedef UniformMatrix<float, 4, 2> UniformMatrix2x4f;
 145 typedef UniformMatrix<float, 4, 3> UniformMatrix3x4f;
 146 typedef UniformMatrix<float, 4, 4> UniformMatrix4x4f;
 147
 148
 149 template<typename T>
 150 class UniformArray: public Uniform
 151 {
 152 private:
 153         typedef typename T::BaseType BaseType;
 154         enum { elemsize = sizeof(typename T::Type)/sizeof(typename T::BaseType) };
 155
 156         unsigned size_;
 157         BaseType *values;
 158
 159 public:
 160         UniformArray(unsigned n, const BaseType *vp):
 161                 size_(n),
 162                 values(new BaseType[elemsize*size_])
 163         {
 164                 set(vp);
 165         }
 166
 167         ~UniformArray()
 168         {
 169                 delete[] values;
 170         }
 171
 172         unsigned size() const { return size_; }
 173
 174         void set(const BaseType *vp)
 175         { std::copy(vp, vp+elemsize*size_, values); }
 176
 177         virtual void apply(int index) const
 178         { T::apply(index, size_, values); }
 179
 180         virtual void store(const Program::UniformInfo &info, void *buffer) const
 181         {
 182                 for(unsigned i=0; i<size_; ++i)
 183                         T::store(info, reinterpret_cast<char *>(buffer)+i*info.array_stride, values+i*elemsize);
 184         }
 185
 186         virtual UniformArray *clone() const
 187         { return new UniformArray(size_, values); }
 188 };
 189
 190 } // namespace GL
 191 } // namespace Msp
 192
 193 #endif