Debian Codegraph @

closure-library/closure/goog/vec/mat4_test.js

raw
1 // Copyright 2011 The Closure Library Authors. All Rights Reserved.
2 // Use of this source code is governed by the Apache License, Version 2.0.
3
4 goog.provide('goog.vec.Mat4Test');
5 goog.setTestOnly('goog.vec.Mat4Test');
6
7 goog.require('goog.vec.Mat4');
8 goog.require('goog.testing.jsunit');
9
10 var randomMat4 = goog.vec.Mat4.createFloat32FromValues(
11 0.8025078773498535,
12 0.7559120655059814,
13 0.15274643898010254,
14 0.19196106493473053,
15 0.0890120416879654,
16 0.15422114729881287,
17 0.09754583984613419,
18 0.44862601161003113,
19 0.9196512699127197,
20 0.5310639142990112,
21 0.8962187170982361,
22 0.280601441860199,
23 0.594650387763977,
24 0.4134795069694519,
25 0.06632178276777267,
26 0.8837796449661255);
27
28 function testDeprecatedConstructor() {
29 var m0 = goog.vec.Mat4.create();
30 assertElementsEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], m0);
31
32 var m1 = goog.vec.Mat4.createFromArray(
33 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
34 assertElementsEquals(
35 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m1);
36
37 var m2 = goog.vec.Mat4.clone(m1);
38 assertElementsEquals(
39 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m1);
40 assertElementsEquals(
41 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m2);
42
43 var m3 = goog.vec.Mat4.createFromValues(
44 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
45 assertElementsEquals(
46 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m3);
47
48 var m4 = goog.vec.Mat4.createIdentity();
49 assertElementsEquals([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], m4);
50 }
51
52 function testConstructor() {
53 var m0 = goog.vec.Mat4.createFloat32();
54 assertElementsEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], m0);
55
56 var m1 = goog.vec.Mat4.createFloat32FromArray(
57 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
58 assertElementsEquals(
59 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m1);
60
61 var m2 = goog.vec.Mat4.clone(m1);
62 assertElementsEquals(
63 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m1);
64 assertElementsEquals(
65 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m2);
66
67 var m3 = goog.vec.Mat4.createFloat32FromValues(
68 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
69 assertElementsEquals(
70 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m3);
71
72 var m4 = goog.vec.Mat4.createIdentity();
73 assertElementsEquals([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], m4);
74 }
75
76 function testSet() {
77 var m0 = goog.vec.Mat4.createFloat32();
78 var m1 = goog.vec.Mat4.createFloat32FromArray(
79 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
80 goog.vec.Mat4.setFromArray(m0, m1);
81 assertElementsEquals(
82 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
83
84 goog.vec.Mat4.setFromValues(
85 m0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17);
86 assertElementsEquals(
87 [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17], m0);
88 }
89
90 function testSetDiagonal() {
91 var m0 = goog.vec.Mat4.createFloat32();
92 goog.vec.Mat4.setDiagonalValues(m0, 1, 2, 3, 4);
93 assertElementsEquals(
94 [1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 4], m0);
95
96 goog.vec.Mat4.setDiagonal(m0, [4, 5, 6, 7]);
97 assertElementsEquals(
98 [4, 0, 0, 0, 0, 5, 0, 0, 0, 0, 6, 0, 0, 0, 0, 7], m0);
99 }
100
101 function testGetDiagonal() {
102 var v0 = goog.vec.Vec4.create();
103 var m0 = goog.vec.Mat4.createFloat32();
104 goog.vec.Mat4.setFromArray(
105 m0, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
106
107 goog.vec.Mat4.getDiagonal(m0, v0);
108 assertElementsEquals([0, 5, 10, 15], v0);
109
110 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
111 goog.vec.Mat4.getDiagonal(m0, v0, 1);
112 assertElementsEquals([4, 9, 14, 0], v0);
113
114 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
115 goog.vec.Mat4.getDiagonal(m0, v0, 2);
116 assertElementsEquals([8, 13, 0, 0], v0);
117
118 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
119 goog.vec.Mat4.getDiagonal(m0, v0, 3);
120 assertElementsEquals([12, 0, 0, 0], v0);
121
122 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
123 goog.vec.Mat4.getDiagonal(m0, v0, 4);
124 assertElementsEquals([0, 0, 0, 0], v0);
125
126 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
127 goog.vec.Mat4.getDiagonal(m0, v0, -1);
128 assertElementsEquals([1, 6, 11, 0], v0);
129
130 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
131 goog.vec.Mat4.getDiagonal(m0, v0, -2);
132 assertElementsEquals([2, 7, 0, 0], v0);
133
134 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
135 goog.vec.Mat4.getDiagonal(m0, v0, -3);
136 assertElementsEquals([3, 0, 0, 0], v0);
137
138 goog.vec.Vec4.setFromArray(v0, [0, 0, 0, 0]);
139 goog.vec.Mat4.getDiagonal(m0, v0, -4);
140 assertElementsEquals([0, 0, 0, 0], v0);
141 }
142
143 function testSetGetColumn() {
144 var m0 = goog.vec.Mat4.createFloat32();
145 goog.vec.Mat4.setColumn(m0, 0, [1, 2, 3, 4]);
146 goog.vec.Mat4.setColumn(m0, 1, [5, 6, 7, 8]);
147 goog.vec.Mat4.setColumn(m0, 2, [9, 10, 11, 12]);
148 goog.vec.Mat4.setColumn(m0, 3, [13, 14, 15, 16]);
149 assertElementsEquals(
150 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
151
152 var v0 = [0, 0, 0, 0];
153 goog.vec.Mat4.getColumn(m0, 0, v0);
154 assertElementsEquals([1, 2, 3, 4], v0);
155 goog.vec.Mat4.getColumn(m0, 1, v0);
156 assertElementsEquals([5, 6, 7, 8], v0);
157 goog.vec.Mat4.getColumn(m0, 2, v0);
158 assertElementsEquals([9, 10, 11, 12], v0);
159 goog.vec.Mat4.getColumn(m0, 3, v0);
160 assertElementsEquals([13, 14, 15, 16], v0);
161 }
162
163 function testSetGetColumns() {
164 var m0 = goog.vec.Mat4.createFloat32();
165 goog.vec.Mat4.setColumns(
166 m0, [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]);
167 assertElementsEquals(
168 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
169
170 var v0 = [0, 0, 0, 0], v1 = [0, 0, 0, 0];
171 var v2 = [0, 0, 0, 0], v3 = [0, 0, 0, 0];
172 goog.vec.Mat4.getColumns(m0, v0, v1, v2, v3);
173 assertElementsEquals([1, 2, 3, 4], v0);
174 assertElementsEquals([5, 6, 7, 8], v1);
175 assertElementsEquals([9, 10, 11, 12], v2);
176 assertElementsEquals([13, 14, 15, 16], v3);
177 }
178
179 function testSetGetRow() {
180 var m0 = goog.vec.Mat4.createFloat32();
181 goog.vec.Mat4.setRow(m0, 0, [1, 2, 3, 4]);
182 goog.vec.Mat4.setRow(m0, 1, [5, 6, 7, 8]);
183 goog.vec.Mat4.setRow(m0, 2, [9, 10, 11, 12]);
184 goog.vec.Mat4.setRow(m0, 3, [13, 14, 15, 16]);
185 assertElementsEquals(
186 [1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16], m0);
187
188 var v0 = [0, 0, 0, 0];
189 goog.vec.Mat4.getRow(m0, 0, v0);
190 assertElementsEquals([1, 2, 3, 4], v0);
191 goog.vec.Mat4.getRow(m0, 1, v0);
192 assertElementsEquals([5, 6, 7, 8], v0);
193 goog.vec.Mat4.getRow(m0, 2, v0);
194 assertElementsEquals([9, 10, 11, 12], v0);
195 goog.vec.Mat4.getRow(m0, 3, v0);
196 assertElementsEquals([13, 14, 15, 16], v0);
197 }
198
199 function testSetGetRows() {
200 var m0 = goog.vec.Mat4.createFloat32();
201 goog.vec.Mat4.setRows(
202 m0, [1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]);
203 assertElementsEquals(
204 [1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16], m0);
205
206 var v0 = [0, 0, 0, 0], v1 = [0, 0, 0, 0];
207 var v2 = [0, 0, 0, 0], v3 = [0, 0, 0, 0];
208 goog.vec.Mat4.getRows(m0, v0, v1, v2, v3);
209 assertElementsEquals([1, 2, 3, 4], v0);
210 assertElementsEquals([5, 6, 7, 8], v1);
211 assertElementsEquals([9, 10, 11, 12], v2);
212 assertElementsEquals([13, 14, 15, 16], v3);
213 }
214
215 function testSetRowMajorArray() {
216 var m0 = goog.vec.Mat4.createFloat32();
217 goog.vec.Mat4.setFromRowMajorArray(
218 m0, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
219 assertElementsEquals(
220 [1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16], m0);
221 }
222
223 function testMakeZero() {
224 var m0 = goog.vec.Mat4.createFloat32FromArray(
225 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
226 assertElementsEquals(
227 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
228 goog.vec.Mat4.makeZero(m0);
229 assertElementsEquals(
230 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], m0);
231 }
232
233 function testMakeIdentity() {
234 var m0 = goog.vec.Mat4.createFloat32();
235 goog.vec.Mat4.makeIdentity(m0);
236 assertElementsEquals(
237 [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1], m0);
238 }
239
240 function testSetGetElement() {
241 var m0 = goog.vec.Mat4.createFloat32();
242 for (var r = 0; r < 4; r++) {
243 for (var c = 0; c < 4; c++) {
244 var value = c * 4 + r + 1;
245 goog.vec.Mat4.setElement(m0, r, c, value);
246 assertEquals(value, goog.vec.Mat4.getElement(m0, r, c));
247 }
248 }
249 assertElementsEquals(
250 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
251 }
252
253 function testAddMat() {
254 var m0 = goog.vec.Mat4.createFloat32FromValues(
255 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
256 var m1 = goog.vec.Mat4.createFloat32FromValues(
257 9, 10, 11, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5, 6, 7, 8);
258 var m2 = goog.vec.Mat4.createFloat32();
259 goog.vec.Mat4.addMat(m0, m1, m2);
260 assertElementsEquals(
261 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
262 assertElementsEquals(
263 [9, 10, 11, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5, 6, 7, 8], m1);
264 assertElementsEquals(
265 [10, 12, 14, 16, 18, 20, 22, 24, 10, 12, 14, 16, 18, 20, 22, 24], m2);
266
267 goog.vec.Mat4.addMat(m0, m1, m0);
268 assertElementsEquals(
269 [9, 10, 11, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5, 6, 7, 8], m1);
270 assertElementsEquals(
271 [10, 12, 14, 16, 18, 20, 22, 24, 10, 12, 14, 16, 18, 20, 22, 24], m0);
272 }
273
274 function testSubMat() {
275 var m0 = goog.vec.Mat4.createFloat32FromValues(
276 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
277 var m1 = goog.vec.Mat4.createFloat32FromValues(
278 9, 10, 11, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5, 6, 7, 8);
279 var m2 = goog.vec.Mat4.createFloat32();
280
281 goog.vec.Mat4.subMat(m0, m1, m2);
282 assertElementsEquals(
283 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
284 assertElementsEquals(
285 [9, 10, 11, 12, 13, 14, 15, 16, 1, 2, 3, 4, 5, 6, 7, 8], m1);
286 assertElementsEquals(
287 [-8, -8, -8, -8, -8, -8, -8, -8, 8, 8, 8, 8, 8, 8, 8, 8], m2);
288
289 goog.vec.Mat4.subMat(m1, m0, m1);
290 assertElementsEquals(
291 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
292 assertElementsEquals(
293 [8, 8, 8, 8, 8, 8, 8, 8, -8, -8, -8, -8, -8, -8, -8, -8], m1);
294 }
295
296 function testMultScalar() {
297 var m0 = goog.vec.Mat4.createFloat32FromValues(
298 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
299 var m1 = goog.vec.Mat4.createFloat32();
300
301 goog.vec.Mat4.multScalar(m0, 2, m1);
302 assertElementsEquals(
303 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m0);
304 assertElementsEquals(
305 [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32], m1);
306
307 goog.vec.Mat4.multScalar(m0, 5, m0);
308 assertElementsEquals(
309 [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80], m0);
310 }
311
312 function testMultMat() {
313 var m0 = goog.vec.Mat4.createFloat32FromValues(
314 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
315 var m1 = goog.vec.Mat4.createFloat32FromValues(
316 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
317 var m2 = goog.vec.Mat4.createFloat32();
318
319 goog.vec.Mat4.multMat(m0, m1, m2);
320 assertElementsEquals(
321 [90, 100, 110, 120, 202, 228, 254, 280,
322 314, 356, 398, 440, 426, 484, 542, 600], m2);
323
324 goog.vec.Mat4.multScalar(m1, 2, m1);
325 goog.vec.Mat4.multMat(m1, m0, m1);
326 assertElementsEquals(
327 [180, 200, 220, 240, 404, 456, 508, 560,
328 628, 712, 796, 880, 852, 968, 1084, 1200], m1);
329 }
330
331 function testTranspose() {
332 var m0 = goog.vec.Mat4.createFloat32FromValues(
333 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
334 var m1 = goog.vec.Mat4.createFloat32();
335 goog.vec.Mat4.transpose(m0, m1);
336 assertElementsEquals(
337 [1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16], m1);
338
339 goog.vec.Mat4.transpose(m1, m1);
340 assertElementsEquals(
341 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], m1);
342 }
343
344 function testDeterminant() {
345 var m0 = goog.vec.Mat4.createFloat32FromValues(
346 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
347 assertEquals(0, goog.vec.Mat4.determinant(m0));
348 assertElementsEquals(
349 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], m0);
350
351 goog.vec.Mat4.setFromValues(
352 m0, 1, 2, 3, 4, 2, 3, 4, 1, 3, 4, 1, 2, 4, 1, 2, 3);
353 assertEquals(160, goog.vec.Mat4.determinant(m0));
354 assertElementsEquals(
355 [1, 2, 3, 4, 2, 3, 4, 1, 3, 4, 1, 2, 4, 1, 2, 3], m0);
356 }
357
358 function testInvert() {
359 var m0 = goog.vec.Mat4.createFloat32FromValues(
360 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1);
361 assertFalse(goog.vec.Mat4.invert(m0, m0));
362 assertElementsEquals(
363 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], m0);
364
365 goog.vec.Mat4.setFromValues(
366 m0, 1, 2, 3, 4, 2, 3, 4, 1, 3, 4, 1, 2, 4, 1, 2, 3);
367 assertTrue(goog.vec.Mat4.invert(m0, m0));
368 assertElementsRoughlyEqual(
369 [-0.225, 0.025, 0.025, 0.275, 0.025, 0.025, 0.275, -0.225,
370 0.025, 0.275, -0.225, 0.025, 0.275, -0.225, 0.025, 0.025], m0,
371 goog.vec.EPSILON);
372
373 goog.vec.Mat4.makeScale(m0, .01, .01, .01);
374 assertTrue(goog.vec.Mat4.invert(m0, m0));
375 var m1 = goog.vec.Mat4.createFloat32();
376 goog.vec.Mat4.makeScale(m1, 100, 100, 100);
377 assertElementsEquals(m1, m0);
378 }
379
380 function testEquals() {
381 var m0 = goog.vec.Mat4.createFloat32FromValues(
382 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
383 var m1 = goog.vec.Mat4.clone(m0);
384 assertTrue(goog.vec.Mat4.equals(m0, m1));
385 assertTrue(goog.vec.Mat4.equals(m1, m0));
386 for (var i = 0; i < 16; i++) {
387 m1[i] = 18;
388 assertFalse(goog.vec.Mat4.equals(m0, m1));
389 assertFalse(goog.vec.Mat4.equals(m1, m0));
390 m1[i] = i + 1;
391 }
392 }
393
394 function testMultVec3() {
395 var m0 = goog.vec.Mat4.createFloat32FromValues(
396 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
397 var v0 = [1, 2, 3];
398 var v1 = [0, 0, 0];
399
400 goog.vec.Mat4.multVec3(m0, v0, v1);
401 assertElementsEquals([1, 2, 3], v0);
402 assertElementsEquals([51, 58, 65], v1);
403
404 goog.vec.Mat4.multVec3(m0, v0, v0);
405 assertElementsEquals([51, 58, 65], v0);
406 }
407
408 function testMultVec3NoTranslate() {
409 var m0 = goog.vec.Mat4.createFloat32FromValues(
410 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
411 var v0 = [1, 2, 3];
412 var v1 = [0, 0, 0];
413
414 goog.vec.Mat4.multVec3NoTranslate(m0, v0, v1);
415 assertElementsEquals([1, 2, 3], v0);
416 assertElementsEquals([38, 44, 50], v1);
417
418 goog.vec.Mat4.multVec3NoTranslate(m0, v0, v0);
419 assertElementsEquals([38, 44, 50], v0);
420 }
421
422 function testMultVec3Projective() {
423 var m0 = goog.vec.Mat4.createFloat32FromValues(
424 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
425 var v0 = [1, 2, 3];
426 var v1 = [0, 0, 0];
427 var invw = 1 / 72;
428
429 goog.vec.Mat4.multVec3Projective(m0, v0, v1);
430 assertElementsEquals([1, 2, 3], v0);
431 assertElementsEquals(
432 [51 * invw, 58 * invw, 65 * invw], v1);
433
434 goog.vec.Mat4.multVec3Projective(m0, v0, v0);
435 assertElementsEquals(
436 [51 * invw, 58 * invw, 65 * invw], v0);
437 }
438
439 function testMultVec4() {
440 var m0 = goog.vec.Mat4.createFloat32FromValues(
441 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
442 var v0 = [1, 2, 3, 4];
443 var v1 = [0, 0, 0, 0];
444
445 goog.vec.Mat4.multVec4(m0, v0, v1);
446 assertElementsEquals([90, 100, 110, 120], v1);
447 goog.vec.Mat4.multVec4(m0, v0, v0);
448 assertElementsEquals([90, 100, 110, 120], v0);
449 }
450
451 function testSetValues() {
452 var a0 = goog.vec.Mat4.createFloat32();
453 assertElementsEquals(
454 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], a0);
455 a0 = goog.vec.Mat4.createFloat32FromArray(
456 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
457 assertElementsEquals(
458 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], a0);
459
460 var a1 = goog.vec.Mat4.createFloat32();
461 goog.vec.Mat4.setDiagonalValues(a1, 1, 2, 3, 4);
462 assertElementsEquals(
463 [1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 4], a1);
464
465 goog.vec.Mat4.setColumnValues(a1, 0, 2, 3, 4, 5);
466 goog.vec.Mat4.setColumnValues(a1, 1, 6, 7, 8, 9);
467 goog.vec.Mat4.setColumnValues(a1, 2, 10, 11, 12, 13);
468 goog.vec.Mat4.setColumnValues(a1, 3, 14, 15, 16, 1);
469 assertElementsEquals(
470 [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1], a1);
471
472 goog.vec.Mat4.setRowValues(a1, 0, 1, 5, 9, 13);
473 goog.vec.Mat4.setRowValues(a1, 1, 2, 6, 10, 14);
474 goog.vec.Mat4.setRowValues(a1, 2, 3, 7, 11, 15);
475 goog.vec.Mat4.setRowValues(a1, 3, 4, 8, 12, 16);
476 assertElementsEquals(
477 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16], a1);
478 }
479
480 function testMakeTranslate() {
481 var m0 = goog.vec.Mat4.createFloat32();
482 goog.vec.Mat4.makeTranslate(m0, 3, 4, 5);
483 assertElementsEquals(
484 [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 3, 4, 5, 1], m0);
485 }
486
487 function testMakeScale() {
488 var m0 = goog.vec.Mat4.createFloat32();
489 goog.vec.Mat4.makeScale(m0, 3, 4, 5);
490 assertElementsEquals(
491 [3, 0, 0, 0, 0, 4, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1], m0);
492 }
493
494 function testMakeRotate() {
495 var m0 = goog.vec.Mat4.createFloat32();
496 goog.vec.Mat4.makeRotate(m0, Math.PI / 2, 0, 0, 1);
497 assertElementsRoughlyEqual(
498 [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
499 m0, goog.vec.EPSILON);
500
501 var m1 = goog.vec.Mat4.createFloat32();
502 goog.vec.Mat4.makeRotate(m1, -Math.PI / 4, 0, 0, 1);
503 goog.vec.Mat4.multMat(m0, m1, m1);
504 assertElementsRoughlyEqual(
505 [0.7071068, 0.7071068, 0, 0,
506 -0.7071068, 0.7071068, 0, 0,
507 0, 0, 1, 0,
508 0, 0, 0, 1],
509 m1, goog.vec.EPSILON);
510 }
511
512 function testMakeRotateX() {
513 var m0 = goog.vec.Mat4.createFloat32();
514 var m1 = goog.vec.Mat4.createFloat32()
515
516 goog.vec.Mat4.makeRotateX(m0, Math.PI / 7);
517 goog.vec.Mat4.makeRotate(m1, Math.PI / 7, 1, 0, 0);
518 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
519 }
520
521 function testMakeRotateY() {
522 var m0 = goog.vec.Mat4.createFloat32();
523 var m1 = goog.vec.Mat4.createFloat32()
524
525 goog.vec.Mat4.makeRotateY(m0, Math.PI / 7);
526 goog.vec.Mat4.makeRotate(m1, Math.PI / 7, 0, 1, 0);
527 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
528 }
529
530 function testMakeRotateZ() {
531 var m0 = goog.vec.Mat4.createFloat32();
532 var m1 = goog.vec.Mat4.createFloat32()
533
534 goog.vec.Mat4.makeRotateZ(m0, Math.PI / 7);
535 goog.vec.Mat4.makeRotate(m1, Math.PI / 7, 0, 0, 1);
536 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
537 }
538
539
540 function testTranslate() {
541 var m0 = goog.vec.Mat4.createIdentity();
542 goog.vec.Mat4.translate(m0, 3, 4, 5);
543 assertElementsEquals(
544 [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 3, 4, 5, 1], m0);
545
546 goog.vec.Mat4.setFromValues(
547 m0, 1, 2, 3, 4, 2, 3, 4, 1, 3, 4, 1, 2, 4, 1, 2, 3);
548
549 var m1 = goog.vec.Mat4.createFloat32();
550 goog.vec.Mat4.makeTranslate(m1, 5, 6, 7);
551 var m2 = goog.vec.Mat4.createFloat32();
552 goog.vec.Mat4.multMat(m0, m1, m2);
553 goog.vec.Mat4.translate(m0, 5, 6, 7);
554 assertElementsEquals(m2, m0);
555 }
556
557 function testScale() {
558 var m0 = goog.vec.Mat4.createIdentity();
559 goog.vec.Mat4.scale(m0, 3, 4, 5);
560 assertElementsEquals([3, 0, 0, 0, 0, 4, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1], m0);
561 }
562
563 function testRotate() {
564 var m0 = goog.vec.Mat4.createIdentity();
565 goog.vec.Mat4.rotate(m0, Math.PI / 2, 0, 0, 1);
566 assertElementsRoughlyEqual(
567 [0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
568 m0, goog.vec.EPSILON);
569
570 goog.vec.Mat4.rotate(m0, -Math.PI / 4, 0, 0, 1);
571 assertElementsRoughlyEqual(
572 [0.7071068, 0.7071068, 0, 0,
573 -0.7071068, 0.7071068, 0, 0,
574 0, 0, 1, 0,
575 0, 0, 0, 1],
576 m0, goog.vec.EPSILON);
577 }
578
579 function testRotateX() {
580 var m0 = goog.vec.Mat4.createFloat32();
581 var m1 = goog.vec.Mat4.createFloat32FromArray(randomMat4)
582
583 goog.vec.Mat4.makeRotateX(m0, Math.PI / 7);
584 goog.vec.Mat4.multMat(m1, m0, m0);
585 goog.vec.Mat4.rotateX(m1, Math.PI / 7);
586 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
587 }
588
589 function testRotateY() {
590 var m0 = goog.vec.Mat4.createFloat32();
591 var m1 = goog.vec.Mat4.createFloat32FromArray(randomMat4)
592
593 goog.vec.Mat4.makeRotateY(m0, Math.PI / 7);
594 goog.vec.Mat4.multMat(m1, m0, m0);
595 goog.vec.Mat4.rotateY(m1, Math.PI / 7);
596 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
597 }
598
599 function testRotateZ() {
600 var m0 = goog.vec.Mat4.createFloat32();
601 var m1 = goog.vec.Mat4.createFloat32FromArray(randomMat4)
602
603 goog.vec.Mat4.makeRotateZ(m0, Math.PI / 7);
604 goog.vec.Mat4.multMat(m1, m0, m0);
605 goog.vec.Mat4.rotateZ(m1, Math.PI / 7);
606 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
607 }
608
609 function testGetTranslation() {
610 var mat = goog.vec.Mat4.createFloat32FromArray(randomMat4);
611 var translation = goog.vec.Vec3.createFloat32();
612 goog.vec.Mat4.getTranslation(mat, translation);
613 assertElementsRoughlyEqual(
614 [0.59465038776, 0.413479506969, 0.0663217827677],
615 translation, goog.vec.EPSILON);
616 }
617
618 function testMakeFrustum() {
619 var m0 = goog.vec.Mat4.createFloat32();
620 goog.vec.Mat4.makeFrustum(m0, -1, 2, -2, 1, .1, 1.1);
621 assertElementsRoughlyEqual(
622 [0.06666666, 0, 0, 0,
623 0, 0.06666666, 0, 0,
624 0.33333333, -0.33333333, -1.2, -1,
625 0, 0, -0.22, 0], m0, goog.vec.EPSILON);
626 }
627
628 function testMakePerspective() {
629 var m0 = goog.vec.Mat4.createFloat32();
630 goog.vec.Mat4.makePerspective(m0, 90 * Math.PI / 180, 2, 0.1, 1.1);
631 assertElementsRoughlyEqual(
632 [0.5, 0, 0, 0, 0, 1, 0, 0, 0, 0, -1.2, -1, 0, 0, -0.22, 0],
633 m0, goog.vec.EPSILON);
634 }
635
636 function testMakeOrtho() {
637 var m0 = goog.vec.Mat4.createFloat32();
638 goog.vec.Mat4.makeOrtho(m0, -1, 2, -2, 1, 0.1, 1.1);
639 assertElementsRoughlyEqual(
640 [0.6666666, 0, 0, 0,
641 0, 0.6666666, 0, 0,
642 0, 0, -2, 0,
643 -0.333333, 0.3333333, -1.2, 1], m0, goog.vec.EPSILON);
644
645 }
646
647 function testMakeEulerZXZ() {
648 var m0 = goog.vec.Mat4.createFloat32();
649 var roll = 0.200982 * 2 * Math.PI;
650 var tilt = 0.915833 * Math.PI;
651 var yaw = 0.839392 * 2 * Math.PI;
652
653 goog.vec.Mat4.makeRotate(m0, roll, 0, 0, 1);
654 goog.vec.Mat4.rotate(m0, tilt, 1, 0, 0);
655 goog.vec.Mat4.rotate(m0, yaw, 0, 0, 1);
656
657 var m1 = goog.vec.Mat4.createFloat32();
658 goog.vec.Mat4.makeEulerZXZ(m1, roll, tilt, yaw);
659 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
660
661
662 var euler = [0, 0, 0];
663 goog.vec.Mat4.toEulerZXZ(m0, euler);
664
665 assertRoughlyEquals(roll, euler[0], goog.vec.EPSILON);
666 assertRoughlyEquals(tilt, euler[1], goog.vec.EPSILON);
667 assertRoughlyEquals(yaw, euler[2], goog.vec.EPSILON);
668
669 // Test negative tilt now.
670 goog.vec.Mat4.makeRotate(m0, roll, 0, 0, 1);
671 goog.vec.Mat4.rotate(m0, -tilt, 1, 0, 0);
672 goog.vec.Mat4.rotate(m0, yaw, 0, 0, 1);
673
674 goog.vec.Mat4.makeEulerZXZ(m1, roll, -tilt, yaw);
675 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
676
677 var euler = [0, 0, 0];
678 goog.vec.Mat4.toEulerZXZ(m0, euler, true);
679
680 assertRoughlyEquals(roll, euler[0], goog.vec.EPSILON);
681 assertRoughlyEquals(-tilt, euler[1], goog.vec.EPSILON);
682 assertRoughlyEquals(yaw, euler[2], goog.vec.EPSILON);
683 }
684
685 function testEulerZXZExtrema() {
686 var m0 = goog.vec.Mat4.createFloat32FromArray(
687 [1, 0, 0, 0, 0, 0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1]);
688 var m1 = goog.vec.Mat4.createFloat32FromArray(
689 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
690
691 var euler = [0, 0, 0];
692 goog.vec.Mat4.toEulerZXZ(m0, euler);
693 assertElementsRoughlyEqual(
694 [Math.PI, Math.PI / 2, Math.PI], euler, goog.vec.EPSILON);
695 goog.vec.Mat4.makeEulerZXZ(m1, euler[0], euler[1], euler[2]);
696 assertElementsRoughlyEqual(m0, m1, goog.vec.EPSILON);
697 }
698
699 function testLookAt() {
700 var viewMatrix = goog.vec.Mat4.createFloat32();
701 goog.vec.Mat4.makeLookAt(
702 viewMatrix, [0, 0, 0], [1, 0, 0], [0, 1, 0]);
703 assertElementsRoughlyEqual(
704 [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1], viewMatrix,
705 goog.vec.EPSILON);
706 }
707
708 function testToLookAt() {
709 // This test does not use the default precision goog.vec.EPSILON due to
710 // precision issues in some browsers leading to flaky tests.
711 var EPSILON = 1e-4;
712
713 var eyeExp = [0, 0, 0];
714 var fwdExp = [1, 0, 0];
715 var upExp = [0, 1, 0];
716
717 var centerExp = [0, 0, 0];
718 goog.vec.Vec3.add(eyeExp, fwdExp, centerExp);
719
720 var view = goog.vec.Mat4.createFloat32();
721 goog.vec.Mat4.makeLookAt(view, eyeExp, centerExp, upExp);
722
723 var eyeRes = [0, 0, 0];
724 var fwdRes = [0, 0, 0];
725 var upRes = [0, 0, 0];
726 goog.vec.Mat4.toLookAt(view, eyeRes, fwdRes, upRes);
727 assertElementsRoughlyEqual(eyeExp, eyeRes, EPSILON);
728 assertElementsRoughlyEqual(fwdExp, fwdRes, EPSILON);
729 assertElementsRoughlyEqual(upExp, upRes, EPSILON);
730 }
731
732 function testLookAtDecomposition() {
733 // This test does not use the default precision goog.vec.EPSILON due to
734 // precision issues in some browsers leading to flaky tests.
735 var EPSILON = 1e-4;
736
737 var viewExp = goog.vec.Mat4.createFloat32();
738 var viewRes = goog.vec.Mat4.createFloat32();
739
740 // Get a valid set of random vectors eye, forward, up by decomposing
741 // a random matrix into a set of lookAt vectors.
742 var tmp = goog.vec.Mat4.createFloat32FromArray(randomMat4);
743 var eyeExp = [0, 0, 0];
744 var fwdExp = [0, 0, 0];
745 var upExp = [0, 0, 0];
746 var centerExp = [0, 0, 0];
747 // Project the random matrix into a real modelview matrix.
748 goog.vec.Mat4.toLookAt(tmp, eyeExp, fwdExp, upExp);
749 goog.vec.Vec3.add(eyeExp, fwdExp, centerExp);
750
751 // Compute the expected modelview matrix from a set of valid random vectors.
752 goog.vec.Mat4.makeLookAt(viewExp, eyeExp, centerExp, upExp);
753
754 var eyeRes = [0, 0, 0];
755 var fwdRes = [0, 0, 0];
756 var upRes = [0, 0, 0];
757 var centerRes = [0, 0, 0];
758 goog.vec.Mat4.toLookAt(viewExp, eyeRes, fwdRes, upRes);
759 goog.vec.Vec3.add(eyeRes, fwdRes, centerRes);
760
761 goog.vec.Mat4.makeLookAt(viewRes, eyeRes, centerRes, upRes);
762
763 assertElementsRoughlyEqual(eyeExp, eyeRes, EPSILON);
764 assertElementsRoughlyEqual(fwdExp, fwdRes, EPSILON);
765 assertElementsRoughlyEqual(upExp, upRes, EPSILON);
766 assertElementsRoughlyEqual(viewExp, viewRes, EPSILON);
767 }