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
  39         virtual UniformScalar *clone() const
  40         { return new UniformScalar(value); }
  41 };
  42
  43 typedef UniformScalar<int> Uniform1i;
  44 typedef UniformScalar<float> Uniform1f;
  45
  46
  47 template<typename T, unsigned vecsize>
  48 class UniformVector: public Uniform
  49 {
  50 public:
  51         typedef T BaseType;
  52         typedef T Type[vecsize];
  53
  54 private:
  55         Type value;
  56
  57 public:
  58         UniformVector(const T *vp)
  59         { std::copy(vp, vp+vecsize, value); }
  60
  61         virtual void apply(int index) const;
  62
  63         virtual UniformVector *clone() const
  64         { return new UniformVector(value); }
  65 };
  66
  67 typedef UniformVector<float, 2> Uniform2f;
  68 typedef UniformVector<float, 3> Uniform3f;
  69 typedef UniformVector<float, 4> Uniform4f;
  70
  71
  72 template<typename T, unsigned rows, unsigned cols>
  73 class UniformMatrix: public Uniform
  74 {
  75 public:
  76         typedef T BaseType;
  77         typedef T Type[rows*cols];
  78
  79 private:
  80         Type value;
  81
  82 public:
  83         UniformMatrix(const T *vp)
  84         { std::copy(vp, vp+rows*cols, value); }
  85
  86         virtual void apply(int index) const;
  87
  88         virtual UniformMatrix *clone() const
  89         { return new UniformMatrix(value); }
  90 };
  91
  92 typedef UniformMatrix<float, 4, 4> UniformMatrix4x4f;
  93
  94 } // namespace GL
  95 } // namespace Msp
  96
  97 #endif