4 Prefix: glu - OpenGL Utils
5 Beschreibung: diese Unit enthält Matrix-Typen und Methoden um diese zu erstellen und zu manipulieren }
12 Classes, SysUtils, ugluVector;
16 TgluMatrix2ub = array[0..1] of TgluVector2ub;
17 TgluMatrix2i = array[0..1] of TgluVector2i;
18 TgluMatrix2f = array[0..1] of TgluVector2f;
19 TgluMatrix2d = array[0..1] of TgluVector2d;
21 TgluMatrix3ub = array[0..2] of TgluVector3ub;
22 TgluMatrix3i = array[0..2] of TgluVector3i;
23 TgluMatrix3f = array[0..2] of TgluVector3f;
24 TgluMatrix3d = array[0..2] of TgluVector3d;
26 TgluMatrix4ub = array[0..3] of TgluVector4ub;
27 TgluMatrix4i = array[0..3] of TgluVector4i;
28 TgluMatrix4f = array[0..3] of TgluVector4f;
29 TgluMatrix4d = array[0..3] of TgluVector4d;
32 PgluMatrix2ub = ^TgluMatrix2ub;
33 PgluMatrix2i = ^TgluMatrix2i;
34 PgluMatrix2f = ^TgluMatrix2f;
35 PgluMatrix2d = ^TgluMatrix2d;
37 PgluMatrix3ub = ^TgluMatrix3ub;
38 PgluMatrix3i = ^TgluMatrix3i;
39 PgluMatrix3f = ^TgluMatrix3f;
40 PgluMatrix3d = ^TgluMatrix3d;
42 PgluMatrix4ub = ^TgluMatrix4ub;
43 PgluMatrix4i = ^TgluMatrix4i;
44 PgluMatrix4f = ^TgluMatrix4f;
45 PgluMatrix4d = ^TgluMatrix4d;
48 function gluMatrix4d(const m: TgluMatrix4f): TgluMatrix4d;
51 function gluMatrixTranslate(const v: TgluVector3f): TgluMatrix4f;
52 function gluMatrixScale(const v: TgluVector3f): TgluMatrix4f; overload;
53 function gluMatrixScale(const s: Single): TgluMatrix4f; overload;
54 function gluMatrixRotate(axis: TgluVector3f; const angle: Single): TgluMatrix4f;
55 function gluMatrixMult(const m1, m2: TgluMatrix4f): TgluMatrix4f;
56 function gluMatrixMultVec(const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
57 function gluMatrixTranspose(const m: TgluMatrix3f): TgluMatrix3f; overload;
58 function gluMatrixTranspose(const m: TgluMatrix4f): TgluMatrix4f; overload;
59 function gluMatrixSubMatrix(const m:TgluMatrix4f; const s, z: Integer): TgluMatrix3f;
60 function gluMatrixDeterminant(const m: TgluMatrix3f): Single; overload;
61 function gluMatrixDeterminant(const m: TgluMatrix4f): Single; overload;
62 function gluMatrixAdjoint(const m: TgluMatrix4f): TgluMatrix4f;
63 function gluMatrixInvert(const m: TgluMatrix4f): TgluMatrix4f;
65 operator * (const m1, m2: TgluMatrix4f): TgluMatrix4f;
66 operator * (const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
67 operator * (const m: TgluMatrix4f; const v: TgluVector3f): TgluVector3f;
74 gluMatrixIdentity: TgluMatrix4f = ((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1));
81 operator * (const m1, m2: TgluMatrix4f): TgluMatrix4f;
83 result := gluMatrixMult(m1, m2);
86 operator * (const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
88 result := gluMatrixMultVec(m, v);
91 operator * (const m: TgluMatrix4f; const v: TgluVector3f): TgluVector3f;
93 result := gluVector3f(gluMatrixMultVec(m, gluVEctor4f(v, 1.0)));
96 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
97 function gluMatrix4d(const m: TgluMatrix4f): TgluMatrix4d;
103 result[i, j] := m[i, j];
106 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
107 //erstellt eine Translationsmatrix
108 //@v: Vektor der Translationsmatrix;
109 function gluMatrixTranslate(const v: TgluVector3f): TgluMatrix4f;
113 result := gluMatrixIdentity;
115 result[3, i] := v[i];
118 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
119 //erstellt eine Skalierungsmatrix
120 //@v: Vektor der Skalierungsmatrix;
121 function gluMatrixScale(const v: TgluVector3f): TgluMatrix4f;
125 result := gluMatrixIdentity;
127 result[i, i] := v[i];
130 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
131 function gluMatrixScale(const s: Single): TgluMatrix4f;
135 result := gluMatrixIdentity;
140 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
141 //erstellt eine Rotationsmatrix;
142 //@axis: Achse um die gedreht werden soll;
143 //@angle: Winkel mit dem gedreht werden soll;
144 function gluMatrixRotate(axis: TgluVector3f; const angle: Single): TgluMatrix4f;
146 X, Y, Z, a, s, c: Single;
148 axis := gluVectorNormalize(axis);
155 result := gluMatrixIdentity;
156 result[maAxisX] := gluVector4f(
157 SQR(X) + (1-SQR(X))*c,
161 result[maAxisY] := gluVector4f(
163 SQR(Y) + (1-SQR(Y))*c,
166 result[maAxisZ] := gluVector4f(
169 SQR(Z) + (1-SQR(Z))*c,
173 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
174 //Mutlipliziert Matrix1 mit Matrix2
175 //@Matrix1: 1. Multiplikator;
176 //@Matrix2: 2. Multiplikator;
177 //@result: Matrix1 * Matrix2
178 function gluMatrixMult(const m1, m2: TgluMatrix4f): TgluMatrix4f;
183 for x := 0 to 3 do begin
184 for y := 0 to 3 do begin
187 sum := sum + m1[i, y] * m2[x, i];
193 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
194 //Multiplizerit eine Matrix mit einem Vektor
195 //@m: Matrix mit der multipliziert werden soll;
196 //@v: Vektor mit dem multipliziert werden soll;
197 //@result: Ergebnis der Multiplikation
198 function gluMatrixMultVec(const m: TgluMatrix4f; const v: TgluVector4f): TgluVector4f;
203 for i := 0 to 3 do begin
206 sum := sum + m[j,i] * v[j];
211 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
212 //berechnet die Transponierte Matrix
213 //@m: Matrix die Transponiert werden soll;
214 //@result: Transponierte Matrix;
215 function gluMatrixTranspose(const m: TgluMatrix3f): TgluMatrix3f;
221 result[i, j] := m[j, i];
224 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
225 //berechnet die Transponierte Matrix
226 //@m: Matrix die Transponiert werden soll;
227 //@result: Transponierte Matrix;
228 function gluMatrixTranspose(const m: TgluMatrix4f): TgluMatrix4f;
234 result[i, j] := m[j, i];
237 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
238 //ermittelt die Untermatrix einer Matrix
239 //@m: Matrix derren Untermatrix berechnet werden soll;
240 //@s: Spalte die gelöscht werden soll;
241 //@z: Zeile die gelöscht werden soll;
242 //@result: Untermatrix von m
243 function gluMatrixSubMatrix(const m: TgluMatrix4f; const s, z: Integer): TgluMatrix3f;
248 for j := 0 to 2 do begin
255 result[i, j] := m[x, y];
259 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
260 //berechnet die Determinante einer Matrix
261 //@m: Matrix derren Determinaten berechnet werden soll;
262 //@result: Determinante von m
263 function gluMatrixDeterminant(const m: TgluMatrix3f): Single;
266 m[0,0] * m[1,1] * m[2,2] +
267 m[1,0] * m[2,1] * m[0,2] +
268 m[2,0] * m[0,1] * m[1,2] -
269 m[2,0] * m[1,1] * m[0,2] -
270 m[1,0] * m[0,1] * m[2,2] -
271 m[0,0] * m[2,1] * m[1,2];
274 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
275 //berechnet die Determinante einer Matrix
276 //@m: Matrix derren Determinaten berechnet werden soll;
277 //@result: Determinante von m
278 function gluMatrixDeterminant(const m: TgluMatrix4f): Single;
284 result := result + power(-1, i) * m[i, 0] * gluMatrixDeterminant(gluMatrixSubMatrix(m, i, 0));
287 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
288 //berechnet die Adjunkte einer Matrix
289 //@m: Matrix derren Adjunkte berechnet werden soll;
290 //@result: Adjunkte von m
291 function gluMatrixAdjoint(const m: TgluMatrix4f): TgluMatrix4f;
297 result[i, j] := power(-1, i+j) * gluMatrixDeterminant(gluMatrixSubMatrix(m, i, j));
298 result := gluMatrixTranspose(result);
301 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
302 //berechnet die inverse Matrix einer Matrix
303 //@m: Matrix derren Inverse berechnet werden soll;
304 //@result: Inverse Matrix von m;
305 function gluMatrixInvert(const m: TgluMatrix4f): TgluMatrix4f;
310 d := gluMatrixDeterminant(m);
311 result := gluMatrixAdjoint(m);
314 result[i,j] := result[i,j] / d;