]> git.tdb.fi Git - libs/gl.git/blob - source/uniform.h
Appease the compiler with some extra copy-ctor's and operator='s
[libs/gl.git] / 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