]> git.tdb.fi Git - libs/gl.git/blob - source/uniform.h
Use a renderer in the viewer
[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<float, 2> Uniform2f;
88 typedef UniformVector<float, 3> Uniform3f;
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)
104         { std::copy(vp, vp+rows*cols, value); }
105
106         virtual void apply(int index) const
107         { apply(index, 1, value); }
108
109         static void apply(int index, unsigned size, const T *value);
110
111         virtual void store(const Program::UniformInfo &info, void *buffer) const
112         { store(info, buffer, value); }
113
114         static void store(const Program::UniformInfo &info, void *buffer, const T *value)
115         {
116                 for(unsigned i=0; i<cols; ++i)
117                         UniformVector<T, rows>::store(info, reinterpret_cast<char *>(buffer)+i*info.matrix_stride, value+i*rows);
118         }
119
120         virtual UniformMatrix *clone() const
121         { return new UniformMatrix(value); }
122 };
123
124 typedef UniformMatrix<float, 2, 2> UniformMatrix2x2f;
125 typedef UniformMatrix<float, 3, 3> UniformMatrix3x3f;
126 typedef UniformMatrix<float, 4, 4> UniformMatrix4x4f;
127
128
129 template<typename T>
130 class UniformArray: public Uniform
131 {
132 private:
133         typedef typename T::BaseType BaseType;
134         enum { elemsize = sizeof(typename T::Type)/sizeof(typename T::BaseType) };
135
136         BaseType *values;
137         unsigned size;
138
139 public:
140         UniformArray(unsigned n, const BaseType *vp):
141                 size(n)
142         {
143                 values = new BaseType[elemsize*size];
144                 std::copy(vp, vp+elemsize*size, values);
145         }
146
147         ~UniformArray()
148         {
149                 delete[] values;
150         }
151
152         virtual void apply(int index) const
153         { T::apply(index, size, values); }
154
155         virtual void store(const Program::UniformInfo &info, void *buffer) const
156         {
157                 for(unsigned i=0; i<size; ++i)
158                         T::store(info, reinterpret_cast<char *>(buffer)+i*info.array_stride, values+i*elemsize);
159         }
160
161         virtual UniformArray *clone() const
162         { return new UniformArray(size, values); }
163 };
164
165 } // namespace GL
166 } // namespace Msp
167
168 #endif