Debian Codegraph @

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

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