source/core/uniform.h

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