source/uniform.h

   1 #ifndef MSP_GL_UNIFORM_H_
   2 #define MSP_GL_UNIFORM_H_
   3
   4 #include <algorithm>
   5
   6 namespace Msp {
   7 namespace GL {
   8
   9 class Uniform
  10 {
  11 protected:
  12         Uniform() { }
  13 private:
  14         Uniform(const Uniform &);
  15         Uniform &operator=(const Uniform &);
  16 public:
  17         virtual ~Uniform() { }
  18
  19         virtual void apply(int) const = 0;
  20         virtual Uniform *clone() const = 0;
  21 };
  22
  23
  24 template<typename T>
  25 class UniformScalar: public Uniform
  26 {
  27 public:
  28         typedef T BaseType;
  29         typedef T Type;
  30
  31 private:
  32         Type value;
  33
  34 public:
  35         UniformScalar(Type v): value(v) { }
  36
  37         virtual void apply(int index) const
  38         { apply(index, 1, &value); }
  39
  40         static void apply(int, unsigned, const T *);
  41
  42         virtual UniformScalar *clone() const
  43         { return new UniformScalar(value); }
  44 };
  45
  46 typedef UniformScalar<int> Uniform1i;
  47 typedef UniformScalar<float> Uniform1f;
  48
  49
  50 template<typename T, unsigned vecsize>
  51 class UniformVector: public Uniform
  52 {
  53 public:
  54         typedef T BaseType;
  55         typedef T Type[vecsize];
  56
  57 private:
  58         Type value;
  59
  60 public:
  61         UniformVector(const T *vp)
  62         { std::copy(vp, vp+vecsize, value); }
  63
  64         virtual void apply(int index) const
  65         { apply(index, 1, value); }
  66
  67         static void apply(int index, unsigned size, const T *value);
  68
  69         virtual UniformVector *clone() const
  70         { return new UniformVector(value); }
  71 };
  72
  73 typedef UniformVector<float, 2> Uniform2f;
  74 typedef UniformVector<float, 3> Uniform3f;
  75 typedef UniformVector<float, 4> Uniform4f;
  76
  77
  78 template<typename T, unsigned rows, unsigned cols>
  79 class UniformMatrix: public Uniform
  80 {
  81 public:
  82         typedef T BaseType;
  83         typedef T Type[rows*cols];
  84
  85 private:
  86         Type value;
  87
  88 public:
  89         UniformMatrix(const T *vp)
  90         { std::copy(vp, vp+rows*cols, value); }
  91
  92         virtual void apply(int index) const
  93         { apply(index, 1, value); }
  94
  95         static void apply(int index, unsigned size, const T *value);
  96
  97         virtual UniformMatrix *clone() const
  98         { return new UniformMatrix(value); }
  99 };
 100
 101 typedef UniformMatrix<float, 4, 4> UniformMatrix4x4f;
 102
 103
 104 template<typename T>
 105 class UniformArray: public Uniform
 106 {
 107 private:
 108         typedef typename T::BaseType BaseType;
 109
 110         BaseType *values;
 111         unsigned size;
 112
 113 public:
 114         UniformArray(unsigned n, const BaseType *vp):
 115                 size(n)
 116         {
 117                 unsigned elemsize = sizeof(typename T::Type)/sizeof(typename T::BaseType);
 118                 values = new BaseType[elemsize*size];
 119                 std::copy(vp, vp+elemsize*size, values);
 120         }
 121
 122         virtual void apply(int index) const
 123         { T::apply(index, size, values); }
 124
 125         virtual UniformArray *clone() const
 126         { return new UniformArray(size, values); }
 127 };
 128
 129 } // namespace GL
 130 } // namespace Msp
 131
 132 #endif