gfm.opengl.matrixstack source code

1 module gfm.opengl.matrixstack;
2 
3 import std.c.stdlib : malloc, free;
4 
5 import gfm.opengl.opengl;
6 
7 import gfm.math.vector,
8        gfm.math.matrix;
9 
10 /// A matrix stack designed to replace fixed-pipeline matrix stacks.
11 /// This stack always expose both the top element and its inverse.
12 final class MatrixStack(int R, T) if (R == 3 || R == 4)
13 {
14     public
15     {
16         alias Matrix!(T, R, R) matrix_t; /// Type of matrices in the stack. Can be 3x3 or 4x4.
17 
18         /// Creates a matrix stack.
19         /// The stack is initialized with one element, an identity matrix.
20         this(size_t depth = 32) nothrow
21         {
22             assert(depth > 0);
23             size_t memNeeded = matrix_t.sizeof * depth * 2;
24             void* data = malloc(memNeeded * 2);
25             _matrices = cast(matrix_t*)data;
26             _invMatrices = cast(matrix_t*)(data + memNeeded);
27             _top = 0;
28             _depth = depth;
29             loadIdentity();
30         }
31 
32         /// Releases the matrix stack memory.
33         ~this()
34         {
35             if (_matrices !is null)
36             {
37                 ensureNotInGC("MatrixStack");
38                 free(_matrices);
39                 _matrices = null;
40             }
41         }
42         deprecated("Use .destroy instead") void close(){}
43 
44         /// Replacement for $(D glLoadIdentity).
45         void loadIdentity() pure nothrow
46         {
47             _matrices[_top] = matrix_t.identity();
48             _invMatrices[_top] = matrix_t.identity();
49         }
50 
51         /// Replacement for $(D glPushMatrix).
52         void push() pure nothrow
53         {
54             if(_top + 1 >= _depth)
55                 assert(false, "Matrix stack is full");
56 
57             _matrices[_top + 1] = _matrices[_top];
58             _invMatrices[_top + 1] = _invMatrices[_top];
59             ++_top;
60         }
61 
62         /// Replacement for $(D glPopMatrix).
63         void pop() pure nothrow
64         {
65             if (_top <= 0)
66                 assert(false, "Matrix stack is empty");
67 
68             --_top;
69         }
70 
71         /// Returns: Top matrix.
72         /// Replaces $(D glLoadMatrix).
73         matrix_t top() pure const nothrow
74         {
75             return _matrices[_top];
76         }
77 
78         /// Returns: Inverse of top matrix.
79         matrix_t invTop() pure const nothrow
80         {
81             return _invMatrices[_top];
82         }
83 
84         /// Sets top matrix.
85         /// Replaces $(D glLoadMatrix).
86         void setTop(matrix_t m) pure nothrow
87         {
88             _matrices[_top] = m;
89             _invMatrices[_top] = m.inverse();
90         }
91 
92         /// Replacement for $(D glMultMatrix).
93         void mult(matrix_t m) pure nothrow
94         {
95             mult(m, m.inverse());
96         }
97 
98         /// Replacement for $(D glMultMatrix), with provided inverse.
99         void mult(matrix_t m, matrix_t invM) pure nothrow
100         {
101             _matrices[_top] = _matrices[_top] * m;
102             _invMatrices[_top] = invM *_invMatrices[_top];
103         }
104 
105         /// Replacement for $(D glTranslate).
106         void translate(Vector!(T, R-1) v) pure nothrow
107         {
108             mult(matrix_t.translation(v), matrix_t.translation(-v));
109         }
110 
111         /// Replacement for $(D glScale).
112         void scale(Vector!(T, R-1) v) pure nothrow
113         {
114             mult(matrix_t.scaling(v), matrix_t.scaling(1 / v));
115         }
116 
117         static if (R == 4)
118         {
119             /// Replacement for $(D glRotate).
120             /// Warning: Angle is given in radians, unlike the original API.
121             void rotate(T angle, Vector!(T, 3) axis) pure nothrow
122             {
123                 matrix_t rot = matrix_t.rotation(angle, axis);
124                 mult(rot, rot.transposed()); // inversing a rotation matrix is tranposing
125             }
126 
127             /// Replacement for $(D gluPerspective).
128             /// Warning: FOV is given in radians, unlike the original API.
129             void perspective(T FOVInRadians, T aspect, T zNear, T zFar) pure nothrow
130             {
131                 mult(matrix_t.perspective(FOVInRadians, aspect, zNear, zFar));
132             }
133 
134             /// Replacement for $(D glOrtho).
135             void ortho(T left, T right, T bottom, T top, T near, T far) pure nothrow
136             {
137                 mult(matrix_t.orthographic(left, right, bottom, top, near, far));
138             }
139 
140             /// Replacement for $(D gluLookAt).
141             void lookAt(vec3!T eye, vec3!T target, vec3!T up) pure nothrow
142             {
143                 mult(matrix_t.lookAt(eye, target, up));
144             }
145         }
146     }
147 
148     private
149     {
150         size_t _top; // index of top matrix
151         size_t _depth;
152         matrix_t* _matrices;
153         matrix_t* _invMatrices;
154     }
155 }
156 
157 unittest
158 {
159     auto s = new MatrixStack!(4, double)();
160     scope(exit) destroy(s);
161     s.loadIdentity();
162     s.push();
163     s.pop();
164     s.translate(vec3d(4, 5, 6));
165     s.scale(vec3d(0.5));
166 
167 
168     auto t = new MatrixStack!(3, float)();
169     scope(exit) destroy(t);
170     t.loadIdentity();
171     t.push();
172     t.pop();
173     t.translate(vec2f(-4, 5));
174     t.scale(vec2f(0.5));
175 }