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         virtual void apply(int index) const
  40         { apply(index, 1, &value); }
  41
  42         static void apply(int, unsigned, const T *);
  43
  44         virtual void store(const Program::UniformInfo &info, void *buffer) const
  45         { store(info, buffer, &value); }
  46
  47         static void store(const Program::UniformInfo &, void *buffer, const T *value)
  48         { *reinterpret_cast<T *>(buffer) = *value; }
  49
  50         virtual UniformScalar *clone() const
  51         { return new UniformScalar(value); }
  52 };
  53
  54 typedef UniformScalar<int> Uniform1i;
  55 typedef UniformScalar<float> Uniform1f;
  56
  57
  58 template<typename T, unsigned vecsize>
  59 class UniformVector: public Uniform
  60 {
  61 public:
  62         typedef T BaseType;
  63         typedef T Type[vecsize];
  64
  65 private:
  66         Type value;
  67
  68 public:
  69         UniformVector(const T *vp)
  70         { std::copy(vp, vp+vecsize, value); }
  71
  72         virtual void apply(int index) const
  73         { apply(index, 1, value); }
  74
  75         static void apply(int index, unsigned size, const T *value);
  76
  77         virtual void store(const Program::UniformInfo &info, void *buffer) const
  78         { store(info, buffer, value); }
  79
  80         static void store(const Program::UniformInfo &, void *buffer, const T *value)
  81         { std::copy(value, value+vecsize, reinterpret_cast<T *>(buffer)); }
  82
  83         virtual UniformVector *clone() const
  84         { return new UniformVector(value); }
  85 };
  86
  87 typedef UniformVector<int, 2> Uniform2i;
  88 typedef UniformVector<float, 2> Uniform2f;
  89 typedef UniformVector<int, 3> Uniform3i;
  90 typedef UniformVector<float, 3> Uniform3f;
  91 typedef UniformVector<int, 4> Uniform4i;
  92 typedef UniformVector<float, 4> Uniform4f;
  93
  94
  95 template<typename T, unsigned rows, unsigned cols>
  96 class UniformMatrix: public Uniform
  97 {
  98 public:
  99         typedef T BaseType;
 100         typedef T Type[rows*cols];
 101
 102 private:
 103         Type value;
 104
 105 public:
 106         UniformMatrix(const T *vp)
 107         { std::copy(vp, vp+rows*cols, value); }
 108
 109         virtual void apply(int index) const
 110         { apply(index, 1, value); }
 111
 112         static void apply(int index, unsigned size, const T *value);
 113
 114         virtual void store(const Program::UniformInfo &info, void *buffer) const
 115         { store(info, buffer, value); }
 116
 117         static void store(const Program::UniformInfo &info, void *buffer, const T *value)
 118         {
 119                 for(unsigned i=0; i<cols; ++i)
 120                         UniformVector<T, rows>::store(info, reinterpret_cast<char *>(buffer)+i*info.matrix_stride, value+i*rows);
 121         }
 122
 123         virtual UniformMatrix *clone() const
 124         { return new UniformMatrix(value); }
 125 };
 126
 127 typedef UniformMatrix<float, 2, 2> UniformMatrix2x2f;
 128 typedef UniformMatrix<float, 3, 3> UniformMatrix3x3f;
 129 typedef UniformMatrix<float, 4, 4> UniformMatrix4x4f;
 130
 131
 132 template<typename T>
 133 class UniformArray: public Uniform
 134 {
 135 private:
 136         typedef typename T::BaseType BaseType;
 137         enum { elemsize = sizeof(typename T::Type)/sizeof(typename T::BaseType) };
 138
 139         BaseType *values;
 140         unsigned size;
 141
 142 public:
 143         UniformArray(unsigned n, const BaseType *vp):
 144                 size(n)
 145         {
 146                 values = new BaseType[elemsize*size];
 147                 std::copy(vp, vp+elemsize*size, values);
 148         }
 149
 150         ~UniformArray()
 151         {
 152                 delete[] values;
 153         }
 154
 155         virtual void apply(int index) const
 156         { T::apply(index, size, values); }
 157
 158         virtual void store(const Program::UniformInfo &info, void *buffer) const
 159         {
 160                 for(unsigned i=0; i<size; ++i)
 161                         T::store(info, reinterpret_cast<char *>(buffer)+i*info.array_stride, values+i*elemsize);
 162         }
 163
 164         virtual UniformArray *clone() const
 165         { return new UniformArray(size, values); }
 166 };
 167
 168 } // namespace GL
 169 } // namespace Msp
 170
 171 #endif