*/
216 | /** Controllers */ }
217 | .dg.main {
218 | /** Scrollbar */ }
219 | .dg.main::-webkit-scrollbar {
220 | width: 5px;
221 | background: #1a1a1a; }
222 | .dg.main::-webkit-scrollbar-corner {
223 | height: 0;
224 | display: none; }
225 | .dg.main::-webkit-scrollbar-thumb {
226 | border-radius: 5px;
227 | background: #676767; }
228 | .dg li:not(.folder) {
229 | background: #1a1a1a;
230 | border-bottom: 1px solid #2c2c2c; }
231 | .dg li.save-row {
232 | line-height: 25px;
233 | background: #dad5cb;
234 | border: 0; }
235 | .dg li.save-row select {
236 | margin-left: 5px;
237 | width: 108px; }
238 | .dg li.save-row .button {
239 | margin-left: 5px;
240 | margin-top: 1px;
241 | border-radius: 2px;
242 | font-size: 9px;
243 | line-height: 7px;
244 | padding: 4px 4px 5px 4px;
245 | background: #c5bdad;
246 | color: #fff;
247 | text-shadow: 0 1px 0 #b0a58f;
248 | box-shadow: 0 -1px 0 #b0a58f;
249 | cursor: pointer; }
250 | .dg li.save-row .button.gears {
251 | background: #c5bdad url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAsAAAANCAYAAAB/9ZQ7AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAQJJREFUeNpiYKAU/P//PwGIC/ApCABiBSAW+I8AClAcgKxQ4T9hoMAEUrxx2QSGN6+egDX+/vWT4e7N82AMYoPAx/evwWoYoSYbACX2s7KxCxzcsezDh3evFoDEBYTEEqycggWAzA9AuUSQQgeYPa9fPv6/YWm/Acx5IPb7ty/fw+QZblw67vDs8R0YHyQhgObx+yAJkBqmG5dPPDh1aPOGR/eugW0G4vlIoTIfyFcA+QekhhHJhPdQxbiAIguMBTQZrPD7108M6roWYDFQiIAAv6Aow/1bFwXgis+f2LUAynwoIaNcz8XNx3Dl7MEJUDGQpx9gtQ8YCueB+D26OECAAQDadt7e46D42QAAAABJRU5ErkJggg==) 2px 1px no-repeat;
252 | height: 7px;
253 | width: 8px; }
254 | .dg li.save-row .button:hover {
255 | background-color: #bab19e;
256 | box-shadow: 0 -1px 0 #b0a58f; }
257 | .dg li.folder {
258 | border-bottom: 0; }
259 | .dg li.title {
260 | padding-left: 16px;
261 | background: #000 url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlI+hKgFxoCgAOw==) 6px 10px no-repeat;
262 | cursor: pointer;
263 | border-bottom: 1px solid rgba(255, 255, 255, 0.2); }
264 | .dg .closed li.title {
265 | background-image: url(data:image/gif;base64,R0lGODlhBQAFAJEAAP////Pz8////////yH5BAEAAAIALAAAAAAFAAUAAAIIlGIWqMCbWAEAOw==); }
266 | .dg .cr.boolean {
267 | border-left: 3px solid #806787; }
268 | .dg .cr.color {
269 | border-left: 3px solid; }
270 | .dg .cr.function {
271 | border-left: 3px solid #e61d5f; }
272 | .dg .cr.number {
273 | border-left: 3px solid #2FA1D6; }
274 | .dg .cr.number input[type=text] {
275 | color: #2FA1D6; }
276 | .dg .cr.string {
277 | border-left: 3px solid #1ed36f; }
278 | .dg .cr.string input[type=text] {
279 | color: #1ed36f; }
280 | .dg .cr.function:hover, .dg .cr.boolean:hover {
281 | background: #111; }
282 | .dg .c input[type=text] {
283 | background: #303030;
284 | outline: none; }
285 | .dg .c input[type=text]:hover {
286 | background: #3c3c3c; }
287 | .dg .c input[type=text]:focus {
288 | background: #494949;
289 | color: #fff; }
290 | .dg .c .slider {
291 | background: #303030;
292 | cursor: ew-resize; }
293 | .dg .c .slider-fg {
294 | background: #2FA1D6;
295 | max-width: 100%; }
296 | .dg .c .slider:hover {
297 | background: #3c3c3c; }
298 | .dg .c .slider:hover .slider-fg {
299 | background: #44abda; }
300 |
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/CNAME:
--------------------------------------------------------------------------------
1 | glmatrix.net
2 |
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/LICENSE.md:
--------------------------------------------------------------------------------
1 | Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE.
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/VERSION:
--------------------------------------------------------------------------------
1 | 2.4.0
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/src/gl-matrix.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileoverview gl-matrix - High performance matrix and vector operations
3 | * @author Brandon Jones
4 | * @author Colin MacKenzie IV
5 | * @version 2.4.0
6 | */
7 |
8 | /* Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
9 |
10 | Permission is hereby granted, free of charge, to any person obtaining a copy
11 | of this software and associated documentation files (the "Software"), to deal
12 | in the Software without restriction, including without limitation the rights
13 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14 | copies of the Software, and to permit persons to whom the Software is
15 | furnished to do so, subject to the following conditions:
16 |
17 | The above copyright notice and this permission notice shall be included in
18 | all copies or substantial portions of the Software.
19 |
20 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26 | THE SOFTWARE. */
27 | // END HEADER
28 |
29 | import * as glMatrix from "./gl-matrix/common";
30 | import * as mat2 from "./gl-matrix/mat2";
31 | import * as mat2d from "./gl-matrix/mat2d";
32 | import * as mat3 from "./gl-matrix/mat3";
33 | import * as mat4 from "./gl-matrix/mat4";
34 | import * as quat from "./gl-matrix/quat";
35 | import * as vec2 from "./gl-matrix/vec2";
36 | import * as vec3 from "./gl-matrix/vec3";
37 | import * as vec4 from "./gl-matrix/vec4";
38 |
39 | export {
40 | glMatrix,
41 | mat2, mat2d, mat3, mat4,
42 | quat,
43 | vec2, vec3, vec4,
44 | };
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/src/gl-matrix/common.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE. */
20 |
21 | /**
22 | * Common utilities
23 | * @module glMatrix
24 | */
25 |
26 | // Configuration Constants
27 | export const EPSILON = 0.000001;
28 | export let ARRAY_TYPE = (typeof Float32Array !== 'undefined') ? Float32Array : Array;
29 | export const RANDOM = Math.random;
30 |
31 | /**
32 | * Sets the type of array used when creating new vectors and matrices
33 | *
34 | * @param {Type} type Array type, such as Float32Array or Array
35 | */
36 | export function setMatrixArrayType(type) {
37 | ARRAY_TYPE = type;
38 | }
39 |
40 | const degree = Math.PI / 180;
41 |
42 | /**
43 | * Convert Degree To Radian
44 | *
45 | * @param {Number} a Angle in Degrees
46 | */
47 | export function toRadian(a) {
48 | return a * degree;
49 | }
50 |
51 | /**
52 | * Tests whether or not the arguments have approximately the same value, within an absolute
53 | * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
54 | * than or equal to 1.0, and a relative tolerance is used for larger values)
55 | *
56 | * @param {Number} a The first number to test.
57 | * @param {Number} b The second number to test.
58 | * @returns {Boolean} True if the numbers are approximately equal, false otherwise.
59 | */
60 | export function equals(a, b) {
61 | return Math.abs(a - b) <= EPSILON*Math.max(1.0, Math.abs(a), Math.abs(b));
62 | }
63 |
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/src/gl-matrix/mat2.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE. */
20 |
21 | import * as glMatrix from "./common"
22 |
23 | /**
24 | * 2x2 Matrix
25 | * @module mat2
26 | */
27 |
28 | /**
29 | * Creates a new identity mat2
30 | *
31 | * @returns {mat2} a new 2x2 matrix
32 | */
33 | export function create() {
34 | let out = new glMatrix.ARRAY_TYPE(4);
35 | out[0] = 1;
36 | out[1] = 0;
37 | out[2] = 0;
38 | out[3] = 1;
39 | return out;
40 | }
41 |
42 | /**
43 | * Creates a new mat2 initialized with values from an existing matrix
44 | *
45 | * @param {mat2} a matrix to clone
46 | * @returns {mat2} a new 2x2 matrix
47 | */
48 | export function clone(a) {
49 | let out = new glMatrix.ARRAY_TYPE(4);
50 | out[0] = a[0];
51 | out[1] = a[1];
52 | out[2] = a[2];
53 | out[3] = a[3];
54 | return out;
55 | }
56 |
57 | /**
58 | * Copy the values from one mat2 to another
59 | *
60 | * @param {mat2} out the receiving matrix
61 | * @param {mat2} a the source matrix
62 | * @returns {mat2} out
63 | */
64 | export function copy(out, a) {
65 | out[0] = a[0];
66 | out[1] = a[1];
67 | out[2] = a[2];
68 | out[3] = a[3];
69 | return out;
70 | }
71 |
72 | /**
73 | * Set a mat2 to the identity matrix
74 | *
75 | * @param {mat2} out the receiving matrix
76 | * @returns {mat2} out
77 | */
78 | export function identity(out) {
79 | out[0] = 1;
80 | out[1] = 0;
81 | out[2] = 0;
82 | out[3] = 1;
83 | return out;
84 | }
85 |
86 | /**
87 | * Create a new mat2 with the given values
88 | *
89 | * @param {Number} m00 Component in column 0, row 0 position (index 0)
90 | * @param {Number} m01 Component in column 0, row 1 position (index 1)
91 | * @param {Number} m10 Component in column 1, row 0 position (index 2)
92 | * @param {Number} m11 Component in column 1, row 1 position (index 3)
93 | * @returns {mat2} out A new 2x2 matrix
94 | */
95 | export function fromValues(m00, m01, m10, m11) {
96 | let out = new glMatrix.ARRAY_TYPE(4);
97 | out[0] = m00;
98 | out[1] = m01;
99 | out[2] = m10;
100 | out[3] = m11;
101 | return out;
102 | }
103 |
104 | /**
105 | * Set the components of a mat2 to the given values
106 | *
107 | * @param {mat2} out the receiving matrix
108 | * @param {Number} m00 Component in column 0, row 0 position (index 0)
109 | * @param {Number} m01 Component in column 0, row 1 position (index 1)
110 | * @param {Number} m10 Component in column 1, row 0 position (index 2)
111 | * @param {Number} m11 Component in column 1, row 1 position (index 3)
112 | * @returns {mat2} out
113 | */
114 | export function set(out, m00, m01, m10, m11) {
115 | out[0] = m00;
116 | out[1] = m01;
117 | out[2] = m10;
118 | out[3] = m11;
119 | return out;
120 | }
121 |
122 | /**
123 | * Transpose the values of a mat2
124 | *
125 | * @param {mat2} out the receiving matrix
126 | * @param {mat2} a the source matrix
127 | * @returns {mat2} out
128 | */
129 | export function transpose(out, a) {
130 | // If we are transposing ourselves we can skip a few steps but have to cache
131 | // some values
132 | if (out === a) {
133 | let a1 = a[1];
134 | out[1] = a[2];
135 | out[2] = a1;
136 | } else {
137 | out[0] = a[0];
138 | out[1] = a[2];
139 | out[2] = a[1];
140 | out[3] = a[3];
141 | }
142 |
143 | return out;
144 | }
145 |
146 | /**
147 | * Inverts a mat2
148 | *
149 | * @param {mat2} out the receiving matrix
150 | * @param {mat2} a the source matrix
151 | * @returns {mat2} out
152 | */
153 | export function invert(out, a) {
154 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
155 |
156 | // Calculate the determinant
157 | let det = a0 * a3 - a2 * a1;
158 |
159 | if (!det) {
160 | return null;
161 | }
162 | det = 1.0 / det;
163 |
164 | out[0] = a3 * det;
165 | out[1] = -a1 * det;
166 | out[2] = -a2 * det;
167 | out[3] = a0 * det;
168 |
169 | return out;
170 | }
171 |
172 | /**
173 | * Calculates the adjugate of a mat2
174 | *
175 | * @param {mat2} out the receiving matrix
176 | * @param {mat2} a the source matrix
177 | * @returns {mat2} out
178 | */
179 | export function adjoint(out, a) {
180 | // Caching this value is nessecary if out == a
181 | let a0 = a[0];
182 | out[0] = a[3];
183 | out[1] = -a[1];
184 | out[2] = -a[2];
185 | out[3] = a0;
186 |
187 | return out;
188 | }
189 |
190 | /**
191 | * Calculates the determinant of a mat2
192 | *
193 | * @param {mat2} a the source matrix
194 | * @returns {Number} determinant of a
195 | */
196 | export function determinant(a) {
197 | return a[0] * a[3] - a[2] * a[1];
198 | }
199 |
200 | /**
201 | * Multiplies two mat2's
202 | *
203 | * @param {mat2} out the receiving matrix
204 | * @param {mat2} a the first operand
205 | * @param {mat2} b the second operand
206 | * @returns {mat2} out
207 | */
208 | export function multiply(out, a, b) {
209 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
210 | let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
211 | out[0] = a0 * b0 + a2 * b1;
212 | out[1] = a1 * b0 + a3 * b1;
213 | out[2] = a0 * b2 + a2 * b3;
214 | out[3] = a1 * b2 + a3 * b3;
215 | return out;
216 | }
217 |
218 | /**
219 | * Rotates a mat2 by the given angle
220 | *
221 | * @param {mat2} out the receiving matrix
222 | * @param {mat2} a the matrix to rotate
223 | * @param {Number} rad the angle to rotate the matrix by
224 | * @returns {mat2} out
225 | */
226 | export function rotate(out, a, rad) {
227 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
228 | let s = Math.sin(rad);
229 | let c = Math.cos(rad);
230 | out[0] = a0 * c + a2 * s;
231 | out[1] = a1 * c + a3 * s;
232 | out[2] = a0 * -s + a2 * c;
233 | out[3] = a1 * -s + a3 * c;
234 | return out;
235 | }
236 |
237 | /**
238 | * Scales the mat2 by the dimensions in the given vec2
239 | *
240 | * @param {mat2} out the receiving matrix
241 | * @param {mat2} a the matrix to rotate
242 | * @param {vec2} v the vec2 to scale the matrix by
243 | * @returns {mat2} out
244 | **/
245 | export function scale(out, a, v) {
246 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
247 | let v0 = v[0], v1 = v[1];
248 | out[0] = a0 * v0;
249 | out[1] = a1 * v0;
250 | out[2] = a2 * v1;
251 | out[3] = a3 * v1;
252 | return out;
253 | }
254 |
255 | /**
256 | * Creates a matrix from a given angle
257 | * This is equivalent to (but much faster than):
258 | *
259 | * mat2.identity(dest);
260 | * mat2.rotate(dest, dest, rad);
261 | *
262 | * @param {mat2} out mat2 receiving operation result
263 | * @param {Number} rad the angle to rotate the matrix by
264 | * @returns {mat2} out
265 | */
266 | export function fromRotation(out, rad) {
267 | let s = Math.sin(rad);
268 | let c = Math.cos(rad);
269 | out[0] = c;
270 | out[1] = s;
271 | out[2] = -s;
272 | out[3] = c;
273 | return out;
274 | }
275 |
276 | /**
277 | * Creates a matrix from a vector scaling
278 | * This is equivalent to (but much faster than):
279 | *
280 | * mat2.identity(dest);
281 | * mat2.scale(dest, dest, vec);
282 | *
283 | * @param {mat2} out mat2 receiving operation result
284 | * @param {vec2} v Scaling vector
285 | * @returns {mat2} out
286 | */
287 | export function fromScaling(out, v) {
288 | out[0] = v[0];
289 | out[1] = 0;
290 | out[2] = 0;
291 | out[3] = v[1];
292 | return out;
293 | }
294 |
295 | /**
296 | * Returns a string representation of a mat2
297 | *
298 | * @param {mat2} a matrix to represent as a string
299 | * @returns {String} string representation of the matrix
300 | */
301 | export function str(a) {
302 | return 'mat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';
303 | }
304 |
305 | /**
306 | * Returns Frobenius norm of a mat2
307 | *
308 | * @param {mat2} a the matrix to calculate Frobenius norm of
309 | * @returns {Number} Frobenius norm
310 | */
311 | export function frob(a) {
312 | return(Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2)))
313 | }
314 |
315 | /**
316 | * Returns L, D and U matrices (Lower triangular, Diagonal and Upper triangular) by factorizing the input matrix
317 | * @param {mat2} L the lower triangular matrix
318 | * @param {mat2} D the diagonal matrix
319 | * @param {mat2} U the upper triangular matrix
320 | * @param {mat2} a the input matrix to factorize
321 | */
322 |
323 | export function LDU(L, D, U, a) {
324 | L[2] = a[2]/a[0];
325 | U[0] = a[0];
326 | U[1] = a[1];
327 | U[3] = a[3] - L[2] * U[1];
328 | return [L, D, U];
329 | }
330 |
331 | /**
332 | * Adds two mat2's
333 | *
334 | * @param {mat2} out the receiving matrix
335 | * @param {mat2} a the first operand
336 | * @param {mat2} b the second operand
337 | * @returns {mat2} out
338 | */
339 | export function add(out, a, b) {
340 | out[0] = a[0] + b[0];
341 | out[1] = a[1] + b[1];
342 | out[2] = a[2] + b[2];
343 | out[3] = a[3] + b[3];
344 | return out;
345 | }
346 |
347 | /**
348 | * Subtracts matrix b from matrix a
349 | *
350 | * @param {mat2} out the receiving matrix
351 | * @param {mat2} a the first operand
352 | * @param {mat2} b the second operand
353 | * @returns {mat2} out
354 | */
355 | export function subtract(out, a, b) {
356 | out[0] = a[0] - b[0];
357 | out[1] = a[1] - b[1];
358 | out[2] = a[2] - b[2];
359 | out[3] = a[3] - b[3];
360 | return out;
361 | }
362 |
363 | /**
364 | * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
365 | *
366 | * @param {mat2} a The first matrix.
367 | * @param {mat2} b The second matrix.
368 | * @returns {Boolean} True if the matrices are equal, false otherwise.
369 | */
370 | export function exactEquals(a, b) {
371 | return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
372 | }
373 |
374 | /**
375 | * Returns whether or not the matrices have approximately the same elements in the same position.
376 | *
377 | * @param {mat2} a The first matrix.
378 | * @param {mat2} b The second matrix.
379 | * @returns {Boolean} True if the matrices are equal, false otherwise.
380 | */
381 | export function equals(a, b) {
382 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
383 | let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
384 | return (Math.abs(a0 - b0) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
385 | Math.abs(a1 - b1) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
386 | Math.abs(a2 - b2) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&
387 | Math.abs(a3 - b3) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a3), Math.abs(b3)));
388 | }
389 |
390 | /**
391 | * Multiply each element of the matrix by a scalar.
392 | *
393 | * @param {mat2} out the receiving matrix
394 | * @param {mat2} a the matrix to scale
395 | * @param {Number} b amount to scale the matrix's elements by
396 | * @returns {mat2} out
397 | */
398 | export function multiplyScalar(out, a, b) {
399 | out[0] = a[0] * b;
400 | out[1] = a[1] * b;
401 | out[2] = a[2] * b;
402 | out[3] = a[3] * b;
403 | return out;
404 | }
405 |
406 | /**
407 | * Adds two mat2's after multiplying each element of the second operand by a scalar value.
408 | *
409 | * @param {mat2} out the receiving vector
410 | * @param {mat2} a the first operand
411 | * @param {mat2} b the second operand
412 | * @param {Number} scale the amount to scale b's elements by before adding
413 | * @returns {mat2} out
414 | */
415 | export function multiplyScalarAndAdd(out, a, b, scale) {
416 | out[0] = a[0] + (b[0] * scale);
417 | out[1] = a[1] + (b[1] * scale);
418 | out[2] = a[2] + (b[2] * scale);
419 | out[3] = a[3] + (b[3] * scale);
420 | return out;
421 | }
422 |
423 | /**
424 | * Alias for {@link mat2.multiply}
425 | * @function
426 | */
427 | export const mul = multiply;
428 |
429 | /**
430 | * Alias for {@link mat2.subtract}
431 | * @function
432 | */
433 | export const sub = subtract;
434 |
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/src/gl-matrix/mat2d.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE. */
20 |
21 | import * as glMatrix from "./common";
22 |
23 | /**
24 | * 2x3 Matrix
25 | * @module mat2d
26 | *
27 | * @description
28 | * A mat2d contains six elements defined as:
29 | *
30 | * [a, c, tx,
31 | * b, d, ty]
32 | *
33 | * This is a short form for the 3x3 matrix:
34 | *
35 | * [a, c, tx,
36 | * b, d, ty,
37 | * 0, 0, 1]
38 | *
39 | * The last row is ignored so the array is shorter and operations are faster.
40 | */
41 |
42 | /**
43 | * Creates a new identity mat2d
44 | *
45 | * @returns {mat2d} a new 2x3 matrix
46 | */
47 | export function create() {
48 | let out = new glMatrix.ARRAY_TYPE(6);
49 | out[0] = 1;
50 | out[1] = 0;
51 | out[2] = 0;
52 | out[3] = 1;
53 | out[4] = 0;
54 | out[5] = 0;
55 | return out;
56 | }
57 |
58 | /**
59 | * Creates a new mat2d initialized with values from an existing matrix
60 | *
61 | * @param {mat2d} a matrix to clone
62 | * @returns {mat2d} a new 2x3 matrix
63 | */
64 | export function clone(a) {
65 | let out = new glMatrix.ARRAY_TYPE(6);
66 | out[0] = a[0];
67 | out[1] = a[1];
68 | out[2] = a[2];
69 | out[3] = a[3];
70 | out[4] = a[4];
71 | out[5] = a[5];
72 | return out;
73 | }
74 |
75 | /**
76 | * Copy the values from one mat2d to another
77 | *
78 | * @param {mat2d} out the receiving matrix
79 | * @param {mat2d} a the source matrix
80 | * @returns {mat2d} out
81 | */
82 | export function copy(out, a) {
83 | out[0] = a[0];
84 | out[1] = a[1];
85 | out[2] = a[2];
86 | out[3] = a[3];
87 | out[4] = a[4];
88 | out[5] = a[5];
89 | return out;
90 | }
91 |
92 | /**
93 | * Set a mat2d to the identity matrix
94 | *
95 | * @param {mat2d} out the receiving matrix
96 | * @returns {mat2d} out
97 | */
98 | export function identity(out) {
99 | out[0] = 1;
100 | out[1] = 0;
101 | out[2] = 0;
102 | out[3] = 1;
103 | out[4] = 0;
104 | out[5] = 0;
105 | return out;
106 | }
107 |
108 | /**
109 | * Create a new mat2d with the given values
110 | *
111 | * @param {Number} a Component A (index 0)
112 | * @param {Number} b Component B (index 1)
113 | * @param {Number} c Component C (index 2)
114 | * @param {Number} d Component D (index 3)
115 | * @param {Number} tx Component TX (index 4)
116 | * @param {Number} ty Component TY (index 5)
117 | * @returns {mat2d} A new mat2d
118 | */
119 | export function fromValues(a, b, c, d, tx, ty) {
120 | let out = new glMatrix.ARRAY_TYPE(6);
121 | out[0] = a;
122 | out[1] = b;
123 | out[2] = c;
124 | out[3] = d;
125 | out[4] = tx;
126 | out[5] = ty;
127 | return out;
128 | }
129 |
130 | /**
131 | * Set the components of a mat2d to the given values
132 | *
133 | * @param {mat2d} out the receiving matrix
134 | * @param {Number} a Component A (index 0)
135 | * @param {Number} b Component B (index 1)
136 | * @param {Number} c Component C (index 2)
137 | * @param {Number} d Component D (index 3)
138 | * @param {Number} tx Component TX (index 4)
139 | * @param {Number} ty Component TY (index 5)
140 | * @returns {mat2d} out
141 | */
142 | export function set(out, a, b, c, d, tx, ty) {
143 | out[0] = a;
144 | out[1] = b;
145 | out[2] = c;
146 | out[3] = d;
147 | out[4] = tx;
148 | out[5] = ty;
149 | return out;
150 | }
151 |
152 | /**
153 | * Inverts a mat2d
154 | *
155 | * @param {mat2d} out the receiving matrix
156 | * @param {mat2d} a the source matrix
157 | * @returns {mat2d} out
158 | */
159 | export function invert(out, a) {
160 | let aa = a[0], ab = a[1], ac = a[2], ad = a[3];
161 | let atx = a[4], aty = a[5];
162 |
163 | let det = aa * ad - ab * ac;
164 | if(!det){
165 | return null;
166 | }
167 | det = 1.0 / det;
168 |
169 | out[0] = ad * det;
170 | out[1] = -ab * det;
171 | out[2] = -ac * det;
172 | out[3] = aa * det;
173 | out[4] = (ac * aty - ad * atx) * det;
174 | out[5] = (ab * atx - aa * aty) * det;
175 | return out;
176 | }
177 |
178 | /**
179 | * Calculates the determinant of a mat2d
180 | *
181 | * @param {mat2d} a the source matrix
182 | * @returns {Number} determinant of a
183 | */
184 | export function determinant(a) {
185 | return a[0] * a[3] - a[1] * a[2];
186 | }
187 |
188 | /**
189 | * Multiplies two mat2d's
190 | *
191 | * @param {mat2d} out the receiving matrix
192 | * @param {mat2d} a the first operand
193 | * @param {mat2d} b the second operand
194 | * @returns {mat2d} out
195 | */
196 | export function multiply(out, a, b) {
197 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4], a5 = a[5];
198 | let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5];
199 | out[0] = a0 * b0 + a2 * b1;
200 | out[1] = a1 * b0 + a3 * b1;
201 | out[2] = a0 * b2 + a2 * b3;
202 | out[3] = a1 * b2 + a3 * b3;
203 | out[4] = a0 * b4 + a2 * b5 + a4;
204 | out[5] = a1 * b4 + a3 * b5 + a5;
205 | return out;
206 | }
207 |
208 | /**
209 | * Rotates a mat2d by the given angle
210 | *
211 | * @param {mat2d} out the receiving matrix
212 | * @param {mat2d} a the matrix to rotate
213 | * @param {Number} rad the angle to rotate the matrix by
214 | * @returns {mat2d} out
215 | */
216 | export function rotate(out, a, rad) {
217 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4], a5 = a[5];
218 | let s = Math.sin(rad);
219 | let c = Math.cos(rad);
220 | out[0] = a0 * c + a2 * s;
221 | out[1] = a1 * c + a3 * s;
222 | out[2] = a0 * -s + a2 * c;
223 | out[3] = a1 * -s + a3 * c;
224 | out[4] = a4;
225 | out[5] = a5;
226 | return out;
227 | }
228 |
229 | /**
230 | * Scales the mat2d by the dimensions in the given vec2
231 | *
232 | * @param {mat2d} out the receiving matrix
233 | * @param {mat2d} a the matrix to translate
234 | * @param {vec2} v the vec2 to scale the matrix by
235 | * @returns {mat2d} out
236 | **/
237 | export function scale(out, a, v) {
238 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4], a5 = a[5];
239 | let v0 = v[0], v1 = v[1];
240 | out[0] = a0 * v0;
241 | out[1] = a1 * v0;
242 | out[2] = a2 * v1;
243 | out[3] = a3 * v1;
244 | out[4] = a4;
245 | out[5] = a5;
246 | return out;
247 | }
248 |
249 | /**
250 | * Translates the mat2d by the dimensions in the given vec2
251 | *
252 | * @param {mat2d} out the receiving matrix
253 | * @param {mat2d} a the matrix to translate
254 | * @param {vec2} v the vec2 to translate the matrix by
255 | * @returns {mat2d} out
256 | **/
257 | export function translate(out, a, v) {
258 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4], a5 = a[5];
259 | let v0 = v[0], v1 = v[1];
260 | out[0] = a0;
261 | out[1] = a1;
262 | out[2] = a2;
263 | out[3] = a3;
264 | out[4] = a0 * v0 + a2 * v1 + a4;
265 | out[5] = a1 * v0 + a3 * v1 + a5;
266 | return out;
267 | }
268 |
269 | /**
270 | * Creates a matrix from a given angle
271 | * This is equivalent to (but much faster than):
272 | *
273 | * mat2d.identity(dest);
274 | * mat2d.rotate(dest, dest, rad);
275 | *
276 | * @param {mat2d} out mat2d receiving operation result
277 | * @param {Number} rad the angle to rotate the matrix by
278 | * @returns {mat2d} out
279 | */
280 | export function fromRotation(out, rad) {
281 | let s = Math.sin(rad), c = Math.cos(rad);
282 | out[0] = c;
283 | out[1] = s;
284 | out[2] = -s;
285 | out[3] = c;
286 | out[4] = 0;
287 | out[5] = 0;
288 | return out;
289 | }
290 |
291 | /**
292 | * Creates a matrix from a vector scaling
293 | * This is equivalent to (but much faster than):
294 | *
295 | * mat2d.identity(dest);
296 | * mat2d.scale(dest, dest, vec);
297 | *
298 | * @param {mat2d} out mat2d receiving operation result
299 | * @param {vec2} v Scaling vector
300 | * @returns {mat2d} out
301 | */
302 | export function fromScaling(out, v) {
303 | out[0] = v[0];
304 | out[1] = 0;
305 | out[2] = 0;
306 | out[3] = v[1];
307 | out[4] = 0;
308 | out[5] = 0;
309 | return out;
310 | }
311 |
312 | /**
313 | * Creates a matrix from a vector translation
314 | * This is equivalent to (but much faster than):
315 | *
316 | * mat2d.identity(dest);
317 | * mat2d.translate(dest, dest, vec);
318 | *
319 | * @param {mat2d} out mat2d receiving operation result
320 | * @param {vec2} v Translation vector
321 | * @returns {mat2d} out
322 | */
323 | export function fromTranslation(out, v) {
324 | out[0] = 1;
325 | out[1] = 0;
326 | out[2] = 0;
327 | out[3] = 1;
328 | out[4] = v[0];
329 | out[5] = v[1];
330 | return out;
331 | }
332 |
333 | /**
334 | * Returns a string representation of a mat2d
335 | *
336 | * @param {mat2d} a matrix to represent as a string
337 | * @returns {String} string representation of the matrix
338 | */
339 | export function str(a) {
340 | return 'mat2d(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' +
341 | a[3] + ', ' + a[4] + ', ' + a[5] + ')';
342 | }
343 |
344 | /**
345 | * Returns Frobenius norm of a mat2d
346 | *
347 | * @param {mat2d} a the matrix to calculate Frobenius norm of
348 | * @returns {Number} Frobenius norm
349 | */
350 | export function frob(a) {
351 | return(Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + 1))
352 | }
353 |
354 | /**
355 | * Adds two mat2d's
356 | *
357 | * @param {mat2d} out the receiving matrix
358 | * @param {mat2d} a the first operand
359 | * @param {mat2d} b the second operand
360 | * @returns {mat2d} out
361 | */
362 | export function add(out, a, b) {
363 | out[0] = a[0] + b[0];
364 | out[1] = a[1] + b[1];
365 | out[2] = a[2] + b[2];
366 | out[3] = a[3] + b[3];
367 | out[4] = a[4] + b[4];
368 | out[5] = a[5] + b[5];
369 | return out;
370 | }
371 |
372 | /**
373 | * Subtracts matrix b from matrix a
374 | *
375 | * @param {mat2d} out the receiving matrix
376 | * @param {mat2d} a the first operand
377 | * @param {mat2d} b the second operand
378 | * @returns {mat2d} out
379 | */
380 | export function subtract(out, a, b) {
381 | out[0] = a[0] - b[0];
382 | out[1] = a[1] - b[1];
383 | out[2] = a[2] - b[2];
384 | out[3] = a[3] - b[3];
385 | out[4] = a[4] - b[4];
386 | out[5] = a[5] - b[5];
387 | return out;
388 | }
389 |
390 | /**
391 | * Multiply each element of the matrix by a scalar.
392 | *
393 | * @param {mat2d} out the receiving matrix
394 | * @param {mat2d} a the matrix to scale
395 | * @param {Number} b amount to scale the matrix's elements by
396 | * @returns {mat2d} out
397 | */
398 | export function multiplyScalar(out, a, b) {
399 | out[0] = a[0] * b;
400 | out[1] = a[1] * b;
401 | out[2] = a[2] * b;
402 | out[3] = a[3] * b;
403 | out[4] = a[4] * b;
404 | out[5] = a[5] * b;
405 | return out;
406 | }
407 |
408 | /**
409 | * Adds two mat2d's after multiplying each element of the second operand by a scalar value.
410 | *
411 | * @param {mat2d} out the receiving vector
412 | * @param {mat2d} a the first operand
413 | * @param {mat2d} b the second operand
414 | * @param {Number} scale the amount to scale b's elements by before adding
415 | * @returns {mat2d} out
416 | */
417 | export function multiplyScalarAndAdd(out, a, b, scale) {
418 | out[0] = a[0] + (b[0] * scale);
419 | out[1] = a[1] + (b[1] * scale);
420 | out[2] = a[2] + (b[2] * scale);
421 | out[3] = a[3] + (b[3] * scale);
422 | out[4] = a[4] + (b[4] * scale);
423 | out[5] = a[5] + (b[5] * scale);
424 | return out;
425 | }
426 |
427 | /**
428 | * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)
429 | *
430 | * @param {mat2d} a The first matrix.
431 | * @param {mat2d} b The second matrix.
432 | * @returns {Boolean} True if the matrices are equal, false otherwise.
433 | */
434 | export function exactEquals(a, b) {
435 | return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5];
436 | }
437 |
438 | /**
439 | * Returns whether or not the matrices have approximately the same elements in the same position.
440 | *
441 | * @param {mat2d} a The first matrix.
442 | * @param {mat2d} b The second matrix.
443 | * @returns {Boolean} True if the matrices are equal, false otherwise.
444 | */
445 | export function equals(a, b) {
446 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], a4 = a[4], a5 = a[5];
447 | let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3], b4 = b[4], b5 = b[5];
448 | return (Math.abs(a0 - b0) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
449 | Math.abs(a1 - b1) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
450 | Math.abs(a2 - b2) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&
451 | Math.abs(a3 - b3) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a3), Math.abs(b3)) &&
452 | Math.abs(a4 - b4) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a4), Math.abs(b4)) &&
453 | Math.abs(a5 - b5) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a5), Math.abs(b5)));
454 | }
455 |
456 | /**
457 | * Alias for {@link mat2d.multiply}
458 | * @function
459 | */
460 | export const mul = multiply;
461 |
462 | /**
463 | * Alias for {@link mat2d.subtract}
464 | * @function
465 | */
466 | export const sub = subtract;
467 |
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/src/gl-matrix/vec2.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE. */
20 |
21 | import * as glMatrix from "./common";
22 |
23 | /**
24 | * 2 Dimensional Vector
25 | * @module vec2
26 | */
27 |
28 | /**
29 | * Creates a new, empty vec2
30 | *
31 | * @returns {vec2} a new 2D vector
32 | */
33 | export function create() {
34 | let out = new glMatrix.ARRAY_TYPE(2);
35 | out[0] = 0;
36 | out[1] = 0;
37 | return out;
38 | }
39 |
40 | /**
41 | * Creates a new vec2 initialized with values from an existing vector
42 | *
43 | * @param {vec2} a vector to clone
44 | * @returns {vec2} a new 2D vector
45 | */
46 | export function clone(a) {
47 | let out = new glMatrix.ARRAY_TYPE(2);
48 | out[0] = a[0];
49 | out[1] = a[1];
50 | return out;
51 | }
52 |
53 | /**
54 | * Creates a new vec2 initialized with the given values
55 | *
56 | * @param {Number} x X component
57 | * @param {Number} y Y component
58 | * @returns {vec2} a new 2D vector
59 | */
60 | export function fromValues(x, y) {
61 | let out = new glMatrix.ARRAY_TYPE(2);
62 | out[0] = x;
63 | out[1] = y;
64 | return out;
65 | }
66 |
67 | /**
68 | * Copy the values from one vec2 to another
69 | *
70 | * @param {vec2} out the receiving vector
71 | * @param {vec2} a the source vector
72 | * @returns {vec2} out
73 | */
74 | export function copy(out, a) {
75 | out[0] = a[0];
76 | out[1] = a[1];
77 | return out;
78 | }
79 |
80 | /**
81 | * Set the components of a vec2 to the given values
82 | *
83 | * @param {vec2} out the receiving vector
84 | * @param {Number} x X component
85 | * @param {Number} y Y component
86 | * @returns {vec2} out
87 | */
88 | export function set(out, x, y) {
89 | out[0] = x;
90 | out[1] = y;
91 | return out;
92 | }
93 |
94 | /**
95 | * Adds two vec2's
96 | *
97 | * @param {vec2} out the receiving vector
98 | * @param {vec2} a the first operand
99 | * @param {vec2} b the second operand
100 | * @returns {vec2} out
101 | */
102 | export function add(out, a, b) {
103 | out[0] = a[0] + b[0];
104 | out[1] = a[1] + b[1];
105 | return out;
106 | }
107 |
108 | /**
109 | * Subtracts vector b from vector a
110 | *
111 | * @param {vec2} out the receiving vector
112 | * @param {vec2} a the first operand
113 | * @param {vec2} b the second operand
114 | * @returns {vec2} out
115 | */
116 | export function subtract(out, a, b) {
117 | out[0] = a[0] - b[0];
118 | out[1] = a[1] - b[1];
119 | return out;
120 | }
121 |
122 | /**
123 | * Multiplies two vec2's
124 | *
125 | * @param {vec2} out the receiving vector
126 | * @param {vec2} a the first operand
127 | * @param {vec2} b the second operand
128 | * @returns {vec2} out
129 | */
130 | export function multiply(out, a, b) {
131 | out[0] = a[0] * b[0];
132 | out[1] = a[1] * b[1];
133 | return out;
134 | };
135 |
136 | /**
137 | * Divides two vec2's
138 | *
139 | * @param {vec2} out the receiving vector
140 | * @param {vec2} a the first operand
141 | * @param {vec2} b the second operand
142 | * @returns {vec2} out
143 | */
144 | export function divide(out, a, b) {
145 | out[0] = a[0] / b[0];
146 | out[1] = a[1] / b[1];
147 | return out;
148 | };
149 |
150 | /**
151 | * Math.ceil the components of a vec2
152 | *
153 | * @param {vec2} out the receiving vector
154 | * @param {vec2} a vector to ceil
155 | * @returns {vec2} out
156 | */
157 | export function ceil(out, a) {
158 | out[0] = Math.ceil(a[0]);
159 | out[1] = Math.ceil(a[1]);
160 | return out;
161 | };
162 |
163 | /**
164 | * Math.floor the components of a vec2
165 | *
166 | * @param {vec2} out the receiving vector
167 | * @param {vec2} a vector to floor
168 | * @returns {vec2} out
169 | */
170 | export function floor(out, a) {
171 | out[0] = Math.floor(a[0]);
172 | out[1] = Math.floor(a[1]);
173 | return out;
174 | };
175 |
176 | /**
177 | * Returns the minimum of two vec2's
178 | *
179 | * @param {vec2} out the receiving vector
180 | * @param {vec2} a the first operand
181 | * @param {vec2} b the second operand
182 | * @returns {vec2} out
183 | */
184 | export function min(out, a, b) {
185 | out[0] = Math.min(a[0], b[0]);
186 | out[1] = Math.min(a[1], b[1]);
187 | return out;
188 | };
189 |
190 | /**
191 | * Returns the maximum of two vec2's
192 | *
193 | * @param {vec2} out the receiving vector
194 | * @param {vec2} a the first operand
195 | * @param {vec2} b the second operand
196 | * @returns {vec2} out
197 | */
198 | export function max(out, a, b) {
199 | out[0] = Math.max(a[0], b[0]);
200 | out[1] = Math.max(a[1], b[1]);
201 | return out;
202 | };
203 |
204 | /**
205 | * Math.round the components of a vec2
206 | *
207 | * @param {vec2} out the receiving vector
208 | * @param {vec2} a vector to round
209 | * @returns {vec2} out
210 | */
211 | export function round (out, a) {
212 | out[0] = Math.round(a[0]);
213 | out[1] = Math.round(a[1]);
214 | return out;
215 | };
216 |
217 | /**
218 | * Scales a vec2 by a scalar number
219 | *
220 | * @param {vec2} out the receiving vector
221 | * @param {vec2} a the vector to scale
222 | * @param {Number} b amount to scale the vector by
223 | * @returns {vec2} out
224 | */
225 | export function scale(out, a, b) {
226 | out[0] = a[0] * b;
227 | out[1] = a[1] * b;
228 | return out;
229 | };
230 |
231 | /**
232 | * Adds two vec2's after scaling the second operand by a scalar value
233 | *
234 | * @param {vec2} out the receiving vector
235 | * @param {vec2} a the first operand
236 | * @param {vec2} b the second operand
237 | * @param {Number} scale the amount to scale b by before adding
238 | * @returns {vec2} out
239 | */
240 | export function scaleAndAdd(out, a, b, scale) {
241 | out[0] = a[0] + (b[0] * scale);
242 | out[1] = a[1] + (b[1] * scale);
243 | return out;
244 | };
245 |
246 | /**
247 | * Calculates the euclidian distance between two vec2's
248 | *
249 | * @param {vec2} a the first operand
250 | * @param {vec2} b the second operand
251 | * @returns {Number} distance between a and b
252 | */
253 | export function distance(a, b) {
254 | var x = b[0] - a[0],
255 | y = b[1] - a[1];
256 | return Math.sqrt(x*x + y*y);
257 | };
258 |
259 | /**
260 | * Calculates the squared euclidian distance between two vec2's
261 | *
262 | * @param {vec2} a the first operand
263 | * @param {vec2} b the second operand
264 | * @returns {Number} squared distance between a and b
265 | */
266 | export function squaredDistance(a, b) {
267 | var x = b[0] - a[0],
268 | y = b[1] - a[1];
269 | return x*x + y*y;
270 | };
271 |
272 | /**
273 | * Calculates the length of a vec2
274 | *
275 | * @param {vec2} a vector to calculate length of
276 | * @returns {Number} length of a
277 | */
278 | export function length(a) {
279 | var x = a[0],
280 | y = a[1];
281 | return Math.sqrt(x*x + y*y);
282 | };
283 |
284 | /**
285 | * Calculates the squared length of a vec2
286 | *
287 | * @param {vec2} a vector to calculate squared length of
288 | * @returns {Number} squared length of a
289 | */
290 | export function squaredLength (a) {
291 | var x = a[0],
292 | y = a[1];
293 | return x*x + y*y;
294 | };
295 |
296 | /**
297 | * Negates the components of a vec2
298 | *
299 | * @param {vec2} out the receiving vector
300 | * @param {vec2} a vector to negate
301 | * @returns {vec2} out
302 | */
303 | export function negate(out, a) {
304 | out[0] = -a[0];
305 | out[1] = -a[1];
306 | return out;
307 | };
308 |
309 | /**
310 | * Returns the inverse of the components of a vec2
311 | *
312 | * @param {vec2} out the receiving vector
313 | * @param {vec2} a vector to invert
314 | * @returns {vec2} out
315 | */
316 | export function inverse(out, a) {
317 | out[0] = 1.0 / a[0];
318 | out[1] = 1.0 / a[1];
319 | return out;
320 | };
321 |
322 | /**
323 | * Normalize a vec2
324 | *
325 | * @param {vec2} out the receiving vector
326 | * @param {vec2} a vector to normalize
327 | * @returns {vec2} out
328 | */
329 | export function normalize(out, a) {
330 | var x = a[0],
331 | y = a[1];
332 | var len = x*x + y*y;
333 | if (len > 0) {
334 | //TODO: evaluate use of glm_invsqrt here?
335 | len = 1 / Math.sqrt(len);
336 | out[0] = a[0] * len;
337 | out[1] = a[1] * len;
338 | }
339 | return out;
340 | };
341 |
342 | /**
343 | * Calculates the dot product of two vec2's
344 | *
345 | * @param {vec2} a the first operand
346 | * @param {vec2} b the second operand
347 | * @returns {Number} dot product of a and b
348 | */
349 | export function dot(a, b) {
350 | return a[0] * b[0] + a[1] * b[1];
351 | };
352 |
353 | /**
354 | * Computes the cross product of two vec2's
355 | * Note that the cross product must by definition produce a 3D vector
356 | *
357 | * @param {vec3} out the receiving vector
358 | * @param {vec2} a the first operand
359 | * @param {vec2} b the second operand
360 | * @returns {vec3} out
361 | */
362 | export function cross(out, a, b) {
363 | var z = a[0] * b[1] - a[1] * b[0];
364 | out[0] = out[1] = 0;
365 | out[2] = z;
366 | return out;
367 | };
368 |
369 | /**
370 | * Performs a linear interpolation between two vec2's
371 | *
372 | * @param {vec2} out the receiving vector
373 | * @param {vec2} a the first operand
374 | * @param {vec2} b the second operand
375 | * @param {Number} t interpolation amount between the two inputs
376 | * @returns {vec2} out
377 | */
378 | export function lerp(out, a, b, t) {
379 | var ax = a[0],
380 | ay = a[1];
381 | out[0] = ax + t * (b[0] - ax);
382 | out[1] = ay + t * (b[1] - ay);
383 | return out;
384 | };
385 |
386 | /**
387 | * Generates a random vector with the given scale
388 | *
389 | * @param {vec2} out the receiving vector
390 | * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned
391 | * @returns {vec2} out
392 | */
393 | export function random(out, scale) {
394 | scale = scale || 1.0;
395 | var r = glMatrix.RANDOM() * 2.0 * Math.PI;
396 | out[0] = Math.cos(r) * scale;
397 | out[1] = Math.sin(r) * scale;
398 | return out;
399 | };
400 |
401 | /**
402 | * Transforms the vec2 with a mat2
403 | *
404 | * @param {vec2} out the receiving vector
405 | * @param {vec2} a the vector to transform
406 | * @param {mat2} m matrix to transform with
407 | * @returns {vec2} out
408 | */
409 | export function transformMat2(out, a, m) {
410 | var x = a[0],
411 | y = a[1];
412 | out[0] = m[0] * x + m[2] * y;
413 | out[1] = m[1] * x + m[3] * y;
414 | return out;
415 | };
416 |
417 | /**
418 | * Transforms the vec2 with a mat2d
419 | *
420 | * @param {vec2} out the receiving vector
421 | * @param {vec2} a the vector to transform
422 | * @param {mat2d} m matrix to transform with
423 | * @returns {vec2} out
424 | */
425 | export function transformMat2d(out, a, m) {
426 | var x = a[0],
427 | y = a[1];
428 | out[0] = m[0] * x + m[2] * y + m[4];
429 | out[1] = m[1] * x + m[3] * y + m[5];
430 | return out;
431 | };
432 |
433 | /**
434 | * Transforms the vec2 with a mat3
435 | * 3rd vector component is implicitly '1'
436 | *
437 | * @param {vec2} out the receiving vector
438 | * @param {vec2} a the vector to transform
439 | * @param {mat3} m matrix to transform with
440 | * @returns {vec2} out
441 | */
442 | export function transformMat3(out, a, m) {
443 | var x = a[0],
444 | y = a[1];
445 | out[0] = m[0] * x + m[3] * y + m[6];
446 | out[1] = m[1] * x + m[4] * y + m[7];
447 | return out;
448 | };
449 |
450 | /**
451 | * Transforms the vec2 with a mat4
452 | * 3rd vector component is implicitly '0'
453 | * 4th vector component is implicitly '1'
454 | *
455 | * @param {vec2} out the receiving vector
456 | * @param {vec2} a the vector to transform
457 | * @param {mat4} m matrix to transform with
458 | * @returns {vec2} out
459 | */
460 | export function transformMat4(out, a, m) {
461 | let x = a[0];
462 | let y = a[1];
463 | out[0] = m[0] * x + m[4] * y + m[12];
464 | out[1] = m[1] * x + m[5] * y + m[13];
465 | return out;
466 | }
467 |
468 | /**
469 | * Returns a string representation of a vector
470 | *
471 | * @param {vec2} a vector to represent as a string
472 | * @returns {String} string representation of the vector
473 | */
474 | export function str(a) {
475 | return 'vec2(' + a[0] + ', ' + a[1] + ')';
476 | }
477 |
478 | /**
479 | * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)
480 | *
481 | * @param {vec2} a The first vector.
482 | * @param {vec2} b The second vector.
483 | * @returns {Boolean} True if the vectors are equal, false otherwise.
484 | */
485 | export function exactEquals(a, b) {
486 | return a[0] === b[0] && a[1] === b[1];
487 | }
488 |
489 | /**
490 | * Returns whether or not the vectors have approximately the same elements in the same position.
491 | *
492 | * @param {vec2} a The first vector.
493 | * @param {vec2} b The second vector.
494 | * @returns {Boolean} True if the vectors are equal, false otherwise.
495 | */
496 | export function equals(a, b) {
497 | let a0 = a[0], a1 = a[1];
498 | let b0 = b[0], b1 = b[1];
499 | return (Math.abs(a0 - b0) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
500 | Math.abs(a1 - b1) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a1), Math.abs(b1)));
501 | }
502 |
503 | /**
504 | * Alias for {@link vec2.length}
505 | * @function
506 | */
507 | export const len = length;
508 |
509 | /**
510 | * Alias for {@link vec2.subtract}
511 | * @function
512 | */
513 | export const sub = subtract;
514 |
515 | /**
516 | * Alias for {@link vec2.multiply}
517 | * @function
518 | */
519 | export const mul = multiply;
520 |
521 | /**
522 | * Alias for {@link vec2.divide}
523 | * @function
524 | */
525 | export const div = divide;
526 |
527 | /**
528 | * Alias for {@link vec2.distance}
529 | * @function
530 | */
531 | export const dist = distance;
532 |
533 | /**
534 | * Alias for {@link vec2.squaredDistance}
535 | * @function
536 | */
537 | export const sqrDist = squaredDistance;
538 |
539 | /**
540 | * Alias for {@link vec2.squaredLength}
541 | * @function
542 | */
543 | export const sqrLen = squaredLength;
544 |
545 | /**
546 | * Perform some operation over an array of vec2s.
547 | *
548 | * @param {Array} a the array of vectors to iterate over
549 | * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed
550 | * @param {Number} offset Number of elements to skip at the beginning of the array
551 | * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array
552 | * @param {Function} fn Function to call for each vector in the array
553 | * @param {Object} [arg] additional argument to pass to fn
554 | * @returns {Array} a
555 | * @function
556 | */
557 | export const forEach = (function() {
558 | let vec = create();
559 |
560 | return function(a, stride, offset, count, fn, arg) {
561 | let i, l;
562 | if(!stride) {
563 | stride = 2;
564 | }
565 |
566 | if(!offset) {
567 | offset = 0;
568 | }
569 |
570 | if(count) {
571 | l = Math.min((count * stride) + offset, a.length);
572 | } else {
573 | l = a.length;
574 | }
575 |
576 | for(i = offset; i < l; i += stride) {
577 | vec[0] = a[i]; vec[1] = a[i+1];
578 | fn(vec, vec, arg);
579 | a[i] = vec[0]; a[i+1] = vec[1];
580 | }
581 |
582 | return a;
583 | };
584 | })();
585 |
--------------------------------------------------------------------------------
/lib/gl-matrix-2.4.0/src/gl-matrix/vec4.js:
--------------------------------------------------------------------------------
1 | /* Copyright (c) 2015, Brandon Jones, Colin MacKenzie IV.
2 |
3 | Permission is hereby granted, free of charge, to any person obtaining a copy
4 | of this software and associated documentation files (the "Software"), to deal
5 | in the Software without restriction, including without limitation the rights
6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 | copies of the Software, and to permit persons to whom the Software is
8 | furnished to do so, subject to the following conditions:
9 |
10 | The above copyright notice and this permission notice shall be included in
11 | all copies or substantial portions of the Software.
12 |
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19 | THE SOFTWARE. */
20 |
21 | import * as glMatrix from "./common";
22 |
23 | /**
24 | * 4 Dimensional Vector
25 | * @module vec4
26 | */
27 |
28 | /**
29 | * Creates a new, empty vec4
30 | *
31 | * @returns {vec4} a new 4D vector
32 | */
33 | export function create() {
34 | let out = new glMatrix.ARRAY_TYPE(4);
35 | out[0] = 0;
36 | out[1] = 0;
37 | out[2] = 0;
38 | out[3] = 0;
39 | return out;
40 | }
41 |
42 | /**
43 | * Creates a new vec4 initialized with values from an existing vector
44 | *
45 | * @param {vec4} a vector to clone
46 | * @returns {vec4} a new 4D vector
47 | */
48 | export function clone(a) {
49 | let out = new glMatrix.ARRAY_TYPE(4);
50 | out[0] = a[0];
51 | out[1] = a[1];
52 | out[2] = a[2];
53 | out[3] = a[3];
54 | return out;
55 | }
56 |
57 | /**
58 | * Creates a new vec4 initialized with the given values
59 | *
60 | * @param {Number} x X component
61 | * @param {Number} y Y component
62 | * @param {Number} z Z component
63 | * @param {Number} w W component
64 | * @returns {vec4} a new 4D vector
65 | */
66 | export function fromValues(x, y, z, w) {
67 | let out = new glMatrix.ARRAY_TYPE(4);
68 | out[0] = x;
69 | out[1] = y;
70 | out[2] = z;
71 | out[3] = w;
72 | return out;
73 | }
74 |
75 | /**
76 | * Copy the values from one vec4 to another
77 | *
78 | * @param {vec4} out the receiving vector
79 | * @param {vec4} a the source vector
80 | * @returns {vec4} out
81 | */
82 | export function copy(out, a) {
83 | out[0] = a[0];
84 | out[1] = a[1];
85 | out[2] = a[2];
86 | out[3] = a[3];
87 | return out;
88 | }
89 |
90 | /**
91 | * Set the components of a vec4 to the given values
92 | *
93 | * @param {vec4} out the receiving vector
94 | * @param {Number} x X component
95 | * @param {Number} y Y component
96 | * @param {Number} z Z component
97 | * @param {Number} w W component
98 | * @returns {vec4} out
99 | */
100 | export function set(out, x, y, z, w) {
101 | out[0] = x;
102 | out[1] = y;
103 | out[2] = z;
104 | out[3] = w;
105 | return out;
106 | }
107 |
108 | /**
109 | * Adds two vec4's
110 | *
111 | * @param {vec4} out the receiving vector
112 | * @param {vec4} a the first operand
113 | * @param {vec4} b the second operand
114 | * @returns {vec4} out
115 | */
116 | export function add(out, a, b) {
117 | out[0] = a[0] + b[0];
118 | out[1] = a[1] + b[1];
119 | out[2] = a[2] + b[2];
120 | out[3] = a[3] + b[3];
121 | return out;
122 | }
123 |
124 | /**
125 | * Subtracts vector b from vector a
126 | *
127 | * @param {vec4} out the receiving vector
128 | * @param {vec4} a the first operand
129 | * @param {vec4} b the second operand
130 | * @returns {vec4} out
131 | */
132 | export function subtract(out, a, b) {
133 | out[0] = a[0] - b[0];
134 | out[1] = a[1] - b[1];
135 | out[2] = a[2] - b[2];
136 | out[3] = a[3] - b[3];
137 | return out;
138 | }
139 |
140 | /**
141 | * Multiplies two vec4's
142 | *
143 | * @param {vec4} out the receiving vector
144 | * @param {vec4} a the first operand
145 | * @param {vec4} b the second operand
146 | * @returns {vec4} out
147 | */
148 | export function multiply(out, a, b) {
149 | out[0] = a[0] * b[0];
150 | out[1] = a[1] * b[1];
151 | out[2] = a[2] * b[2];
152 | out[3] = a[3] * b[3];
153 | return out;
154 | }
155 |
156 | /**
157 | * Divides two vec4's
158 | *
159 | * @param {vec4} out the receiving vector
160 | * @param {vec4} a the first operand
161 | * @param {vec4} b the second operand
162 | * @returns {vec4} out
163 | */
164 | export function divide(out, a, b) {
165 | out[0] = a[0] / b[0];
166 | out[1] = a[1] / b[1];
167 | out[2] = a[2] / b[2];
168 | out[3] = a[3] / b[3];
169 | return out;
170 | }
171 |
172 | /**
173 | * Math.ceil the components of a vec4
174 | *
175 | * @param {vec4} out the receiving vector
176 | * @param {vec4} a vector to ceil
177 | * @returns {vec4} out
178 | */
179 | export function ceil(out, a) {
180 | out[0] = Math.ceil(a[0]);
181 | out[1] = Math.ceil(a[1]);
182 | out[2] = Math.ceil(a[2]);
183 | out[3] = Math.ceil(a[3]);
184 | return out;
185 | }
186 |
187 | /**
188 | * Math.floor the components of a vec4
189 | *
190 | * @param {vec4} out the receiving vector
191 | * @param {vec4} a vector to floor
192 | * @returns {vec4} out
193 | */
194 | export function floor(out, a) {
195 | out[0] = Math.floor(a[0]);
196 | out[1] = Math.floor(a[1]);
197 | out[2] = Math.floor(a[2]);
198 | out[3] = Math.floor(a[3]);
199 | return out;
200 | }
201 |
202 | /**
203 | * Returns the minimum of two vec4's
204 | *
205 | * @param {vec4} out the receiving vector
206 | * @param {vec4} a the first operand
207 | * @param {vec4} b the second operand
208 | * @returns {vec4} out
209 | */
210 | export function min(out, a, b) {
211 | out[0] = Math.min(a[0], b[0]);
212 | out[1] = Math.min(a[1], b[1]);
213 | out[2] = Math.min(a[2], b[2]);
214 | out[3] = Math.min(a[3], b[3]);
215 | return out;
216 | }
217 |
218 | /**
219 | * Returns the maximum of two vec4's
220 | *
221 | * @param {vec4} out the receiving vector
222 | * @param {vec4} a the first operand
223 | * @param {vec4} b the second operand
224 | * @returns {vec4} out
225 | */
226 | export function max(out, a, b) {
227 | out[0] = Math.max(a[0], b[0]);
228 | out[1] = Math.max(a[1], b[1]);
229 | out[2] = Math.max(a[2], b[2]);
230 | out[3] = Math.max(a[3], b[3]);
231 | return out;
232 | }
233 |
234 | /**
235 | * Math.round the components of a vec4
236 | *
237 | * @param {vec4} out the receiving vector
238 | * @param {vec4} a vector to round
239 | * @returns {vec4} out
240 | */
241 | export function round(out, a) {
242 | out[0] = Math.round(a[0]);
243 | out[1] = Math.round(a[1]);
244 | out[2] = Math.round(a[2]);
245 | out[3] = Math.round(a[3]);
246 | return out;
247 | }
248 |
249 | /**
250 | * Scales a vec4 by a scalar number
251 | *
252 | * @param {vec4} out the receiving vector
253 | * @param {vec4} a the vector to scale
254 | * @param {Number} b amount to scale the vector by
255 | * @returns {vec4} out
256 | */
257 | export function scale(out, a, b) {
258 | out[0] = a[0] * b;
259 | out[1] = a[1] * b;
260 | out[2] = a[2] * b;
261 | out[3] = a[3] * b;
262 | return out;
263 | }
264 |
265 | /**
266 | * Adds two vec4's after scaling the second operand by a scalar value
267 | *
268 | * @param {vec4} out the receiving vector
269 | * @param {vec4} a the first operand
270 | * @param {vec4} b the second operand
271 | * @param {Number} scale the amount to scale b by before adding
272 | * @returns {vec4} out
273 | */
274 | export function scaleAndAdd(out, a, b, scale) {
275 | out[0] = a[0] + (b[0] * scale);
276 | out[1] = a[1] + (b[1] * scale);
277 | out[2] = a[2] + (b[2] * scale);
278 | out[3] = a[3] + (b[3] * scale);
279 | return out;
280 | }
281 |
282 | /**
283 | * Calculates the euclidian distance between two vec4's
284 | *
285 | * @param {vec4} a the first operand
286 | * @param {vec4} b the second operand
287 | * @returns {Number} distance between a and b
288 | */
289 | export function distance(a, b) {
290 | let x = b[0] - a[0];
291 | let y = b[1] - a[1];
292 | let z = b[2] - a[2];
293 | let w = b[3] - a[3];
294 | return Math.sqrt(x*x + y*y + z*z + w*w);
295 | }
296 |
297 | /**
298 | * Calculates the squared euclidian distance between two vec4's
299 | *
300 | * @param {vec4} a the first operand
301 | * @param {vec4} b the second operand
302 | * @returns {Number} squared distance between a and b
303 | */
304 | export function squaredDistance(a, b) {
305 | let x = b[0] - a[0];
306 | let y = b[1] - a[1];
307 | let z = b[2] - a[2];
308 | let w = b[3] - a[3];
309 | return x*x + y*y + z*z + w*w;
310 | }
311 |
312 | /**
313 | * Calculates the length of a vec4
314 | *
315 | * @param {vec4} a vector to calculate length of
316 | * @returns {Number} length of a
317 | */
318 | export function length(a) {
319 | let x = a[0];
320 | let y = a[1];
321 | let z = a[2];
322 | let w = a[3];
323 | return Math.sqrt(x*x + y*y + z*z + w*w);
324 | }
325 |
326 | /**
327 | * Calculates the squared length of a vec4
328 | *
329 | * @param {vec4} a vector to calculate squared length of
330 | * @returns {Number} squared length of a
331 | */
332 | export function squaredLength(a) {
333 | let x = a[0];
334 | let y = a[1];
335 | let z = a[2];
336 | let w = a[3];
337 | return x*x + y*y + z*z + w*w;
338 | }
339 |
340 | /**
341 | * Negates the components of a vec4
342 | *
343 | * @param {vec4} out the receiving vector
344 | * @param {vec4} a vector to negate
345 | * @returns {vec4} out
346 | */
347 | export function negate(out, a) {
348 | out[0] = -a[0];
349 | out[1] = -a[1];
350 | out[2] = -a[2];
351 | out[3] = -a[3];
352 | return out;
353 | }
354 |
355 | /**
356 | * Returns the inverse of the components of a vec4
357 | *
358 | * @param {vec4} out the receiving vector
359 | * @param {vec4} a vector to invert
360 | * @returns {vec4} out
361 | */
362 | export function inverse(out, a) {
363 | out[0] = 1.0 / a[0];
364 | out[1] = 1.0 / a[1];
365 | out[2] = 1.0 / a[2];
366 | out[3] = 1.0 / a[3];
367 | return out;
368 | }
369 |
370 | /**
371 | * Normalize a vec4
372 | *
373 | * @param {vec4} out the receiving vector
374 | * @param {vec4} a vector to normalize
375 | * @returns {vec4} out
376 | */
377 | export function normalize(out, a) {
378 | let x = a[0];
379 | let y = a[1];
380 | let z = a[2];
381 | let w = a[3];
382 | let len = x*x + y*y + z*z + w*w;
383 | if (len > 0) {
384 | len = 1 / Math.sqrt(len);
385 | out[0] = x * len;
386 | out[1] = y * len;
387 | out[2] = z * len;
388 | out[3] = w * len;
389 | }
390 | return out;
391 | }
392 |
393 | /**
394 | * Calculates the dot product of two vec4's
395 | *
396 | * @param {vec4} a the first operand
397 | * @param {vec4} b the second operand
398 | * @returns {Number} dot product of a and b
399 | */
400 | export function dot(a, b) {
401 | return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
402 | }
403 |
404 | /**
405 | * Performs a linear interpolation between two vec4's
406 | *
407 | * @param {vec4} out the receiving vector
408 | * @param {vec4} a the first operand
409 | * @param {vec4} b the second operand
410 | * @param {Number} t interpolation amount between the two inputs
411 | * @returns {vec4} out
412 | */
413 | export function lerp(out, a, b, t) {
414 | let ax = a[0];
415 | let ay = a[1];
416 | let az = a[2];
417 | let aw = a[3];
418 | out[0] = ax + t * (b[0] - ax);
419 | out[1] = ay + t * (b[1] - ay);
420 | out[2] = az + t * (b[2] - az);
421 | out[3] = aw + t * (b[3] - aw);
422 | return out;
423 | }
424 |
425 | /**
426 | * Generates a random vector with the given scale
427 | *
428 | * @param {vec4} out the receiving vector
429 | * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned
430 | * @returns {vec4} out
431 | */
432 | export function random(out, vectorScale) {
433 | vectorScale = vectorScale || 1.0;
434 |
435 | //TODO: This is a pretty awful way of doing this. Find something better.
436 | out[0] = glMatrix.RANDOM();
437 | out[1] = glMatrix.RANDOM();
438 | out[2] = glMatrix.RANDOM();
439 | out[3] = glMatrix.RANDOM();
440 | normalize(out, out);
441 | scale(out, out, vectorScale);
442 | return out;
443 | }
444 |
445 | /**
446 | * Transforms the vec4 with a mat4.
447 | *
448 | * @param {vec4} out the receiving vector
449 | * @param {vec4} a the vector to transform
450 | * @param {mat4} m matrix to transform with
451 | * @returns {vec4} out
452 | */
453 | export function transformMat4(out, a, m) {
454 | let x = a[0], y = a[1], z = a[2], w = a[3];
455 | out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
456 | out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
457 | out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
458 | out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
459 | return out;
460 | }
461 |
462 | /**
463 | * Transforms the vec4 with a quat
464 | *
465 | * @param {vec4} out the receiving vector
466 | * @param {vec4} a the vector to transform
467 | * @param {quat} q quaternion to transform with
468 | * @returns {vec4} out
469 | */
470 | export function transformQuat(out, a, q) {
471 | let x = a[0], y = a[1], z = a[2];
472 | let qx = q[0], qy = q[1], qz = q[2], qw = q[3];
473 |
474 | // calculate quat * vec
475 | let ix = qw * x + qy * z - qz * y;
476 | let iy = qw * y + qz * x - qx * z;
477 | let iz = qw * z + qx * y - qy * x;
478 | let iw = -qx * x - qy * y - qz * z;
479 |
480 | // calculate result * inverse quat
481 | out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
482 | out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
483 | out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
484 | out[3] = a[3];
485 | return out;
486 | }
487 |
488 | /**
489 | * Returns a string representation of a vector
490 | *
491 | * @param {vec4} a vector to represent as a string
492 | * @returns {String} string representation of the vector
493 | */
494 | export function str(a) {
495 | return 'vec4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';
496 | }
497 |
498 | /**
499 | * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
500 | *
501 | * @param {vec4} a The first vector.
502 | * @param {vec4} b The second vector.
503 | * @returns {Boolean} True if the vectors are equal, false otherwise.
504 | */
505 | export function exactEquals(a, b) {
506 | return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
507 | }
508 |
509 | /**
510 | * Returns whether or not the vectors have approximately the same elements in the same position.
511 | *
512 | * @param {vec4} a The first vector.
513 | * @param {vec4} b The second vector.
514 | * @returns {Boolean} True if the vectors are equal, false otherwise.
515 | */
516 | export function equals(a, b) {
517 | let a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3];
518 | let b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3];
519 | return (Math.abs(a0 - b0) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&
520 | Math.abs(a1 - b1) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a1), Math.abs(b1)) &&
521 | Math.abs(a2 - b2) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a2), Math.abs(b2)) &&
522 | Math.abs(a3 - b3) <= glMatrix.EPSILON*Math.max(1.0, Math.abs(a3), Math.abs(b3)));
523 | }
524 |
525 | /**
526 | * Alias for {@link vec4.subtract}
527 | * @function
528 | */
529 | export const sub = subtract;
530 |
531 | /**
532 | * Alias for {@link vec4.multiply}
533 | * @function
534 | */
535 | export const mul = multiply;
536 |
537 | /**
538 | * Alias for {@link vec4.divide}
539 | * @function
540 | */
541 | export const div = divide;
542 |
543 | /**
544 | * Alias for {@link vec4.distance}
545 | * @function
546 | */
547 | export const dist = distance;
548 |
549 | /**
550 | * Alias for {@link vec4.squaredDistance}
551 | * @function
552 | */
553 | export const sqrDist = squaredDistance;
554 |
555 | /**
556 | * Alias for {@link vec4.length}
557 | * @function
558 | */
559 | export const len = length;
560 |
561 | /**
562 | * Alias for {@link vec4.squaredLength}
563 | * @function
564 | */
565 | export const sqrLen = squaredLength;
566 |
567 | /**
568 | * Perform some operation over an array of vec4s.
569 | *
570 | * @param {Array} a the array of vectors to iterate over
571 | * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed
572 | * @param {Number} offset Number of elements to skip at the beginning of the array
573 | * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array
574 | * @param {Function} fn Function to call for each vector in the array
575 | * @param {Object} [arg] additional argument to pass to fn
576 | * @returns {Array} a
577 | * @function
578 | */
579 | export const forEach = (function() {
580 | let vec = create();
581 |
582 | return function(a, stride, offset, count, fn, arg) {
583 | let i, l;
584 | if(!stride) {
585 | stride = 4;
586 | }
587 |
588 | if(!offset) {
589 | offset = 0;
590 | }
591 |
592 | if(count) {
593 | l = Math.min((count * stride) + offset, a.length);
594 | } else {
595 | l = a.length;
596 | }
597 |
598 | for(i = offset; i < l; i += stride) {
599 | vec[0] = a[i]; vec[1] = a[i+1]; vec[2] = a[i+2]; vec[3] = a[i+3];
600 | fn(vec, vec, arg);
601 | a[i] = vec[0]; a[i+1] = vec[1]; a[i+2] = vec[2]; a[i+3] = vec[3];
602 | }
603 |
604 | return a;
605 | };
606 | })();
607 |
--------------------------------------------------------------------------------
/sketches/ConstructionCubes.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
61 |
62 |
63 |
124 |
125 |
126 |
127 |
128 |
129 |
133 |
134 |
364 |
365 |
366 |
367 |
368 |
369 |
--------------------------------------------------------------------------------
/sketches/Cubes_FBO.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
61 |
62 |
63 |
87 |
88 |
89 |
90 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
117 |
118 |
389 |
390 |
391 |
392 |
393 |
394 |
--------------------------------------------------------------------------------
/sketches/Cubes_VBO_Test.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
55 |
56 |
57 |
72 |
73 |
74 |
75 |
76 |
77 |
81 |
82 |
266 |
267 |
268 |
269 |
270 |
271 |
--------------------------------------------------------------------------------
/sketches/GeometryPrimitives.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
63 |
64 |
65 |
147 |
148 |
149 |
150 |
151 |
152 |
157 |
158 |
427 |
428 |
429 |
430 |
431 |
432 |
--------------------------------------------------------------------------------
/sketches/HilbertCurve.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
72 |
73 |
74 |
103 |
104 |
105 |
106 |
107 |
108 |
113 |
114 |
359 |
360 |
361 |
362 |
363 |
364 |
--------------------------------------------------------------------------------
/sketches/Quads_VBO_Test.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
55 |
56 |
57 |
72 |
73 |
74 |
75 |
76 |
77 |
81 |
82 |
238 |
239 |
240 |
241 |
242 |
243 |
--------------------------------------------------------------------------------
/sketches/Smoothstep.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
64 |
65 |
66 |
67 |
68 |
69 |
102 |
103 |
104 |
105 |
106 |
107 |
111 |
112 |
270 |
271 |
272 |
273 |
274 |
275 |
--------------------------------------------------------------------------------
/sketches/SubdivisionPrimitives.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
63 |
64 |
65 |
151 |
152 |
153 |
154 |
155 |
156 |
161 |
162 |
428 |
429 |
430 |
431 |
432 |
433 |
--------------------------------------------------------------------------------
/sketches/depthmap.js:
--------------------------------------------------------------------------------
1 | /**
2 | *
3 | * dw-webgl-sketchbook: https://github.com/diwi/dw-webgl-sketchbook
4 | *
5 | * Copyright 2018 by Thomas Diewald, https://www.thomasdiewald.com
6 | *
7 | * MIT License: https://opensource.org/licenses/MIT
8 | *
9 | */
10 |
11 |
12 |
13 | class DepthMap {
14 |
15 | constructor(app){
16 | this.app = app;
17 |
18 | var vs, fs;
19 |
20 | fs = document.getElementById("webgl2.fs_texdisplay").textContent;
21 | this.shaderDisplay = new Dw.Shader(gl, {fs:fs});
22 |
23 | vs = document.getElementById("webgl2.vs_depthmap").textContent;
24 | fs = document.getElementById("webgl2.fs_depthmap").textContent;
25 | this.shader = new Dw.Shader(gl, {vs:vs, fs:fs});
26 |
27 | var dim = 1024;
28 | this.def = {
29 | target : gl.TEXTURE_2D,
30 | iformat : gl.DEPTH_COMPONENT16,
31 | format : gl.DEPTH_COMPONENT,
32 | attachment : gl.DEPTH_ATTACHMENT,
33 | type : gl.UNSIGNED_SHORT,
34 | wrap : gl.CLAMP_TO_EDGE,
35 | comparemode: gl.COMPARE_REF_TO_TEXTURE,
36 | filter : [gl.LINEAR, gl.LINEAR],
37 | };
38 |
39 | this.viewdir = new Float32Array(3);
40 |
41 | this.orbit = new Dw.EasyCam(app, {distance: 5000});
42 | // this.orbit.setViewport([10,h-300-10, 300, 300]);
43 |
44 | this.tex = gl.newTexture(dim, dim, this.def);
45 |
46 | this.fbo = gl.newFramebuffer();
47 | this.fbo.setTexture(this.tex);
48 | this.fbo.err();
49 |
50 | this.fbo.begin();
51 | this.fbo.end();
52 |
53 | this.bias = 10.0 * 1000.0 * 1.0 / dim;
54 |
55 | this.mat = {
56 | modelview : newMat(mat4),
57 | projection : newMat(mat4),
58 | };
59 | }
60 |
61 |
62 | enableShadowParam(state){
63 | var tex = this.tex;
64 | tex.bind();
65 | if(state){
66 | gl.texParameteri(tex.target, gl.TEXTURE_MIN_FILTER, tex.filter[0]);
67 | gl.texParameterf(tex.target, gl.TEXTURE_MAG_FILTER, tex.filter[1]);
68 | gl.texParameterf(tex.target, gl.TEXTURE_COMPARE_MODE, tex.comparemode);
69 | } else {
70 | gl.texParameteri(tex.target, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
71 | gl.texParameterf(tex.target, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
72 | gl.texParameterf(tex.target, gl.TEXTURE_COMPARE_MODE, gl.NONE);
73 | }
74 | tex.unbind();
75 | }
76 |
77 | release(){
78 | this.shaderDisplay.release();
79 | this.shader.release();
80 | this.tex.release();
81 | this.fbo.release();
82 | this.orbit.release();
83 | }
84 |
85 | resize(w, h){
86 | this.tex.resize(w, h);
87 | }
88 |
89 | setModelview(dir, distance){
90 | var x = dir[0];
91 | var y = dir[1];
92 | var z = dir[2];
93 | var dd = x*x+y*y+z*z;
94 | if(dd > 0.0 && dd !== 1.0){
95 | dd = distance / Math.sqrt(dd);
96 | x *= dd;
97 | y *= dd;
98 | z *= dd;
99 | }
100 |
101 | this.eye = [-x,-y,-z];
102 | this.center = [0,0,0];
103 | this.up = [0,0,-1];
104 | mat4.lookAt(this.mat.modelview,this. eye, this.center, this.up);
105 | }
106 |
107 | setOrtho(w, h, d){
108 | mat4.ortho(this.mat.projection, -w/2, w/2, -h/2, h/2, 1, d);
109 | }
110 |
111 | setPerspective(fovy, near, far){
112 | mat4.perspective(this.mat.projection, fovy, this.tex.w/this.tex.h, near, far);
113 | mat4.scale(this.mat.projection, this.mat.projection, [1,-1,1]);
114 | }
115 |
116 | create(render_cb){
117 |
118 | this.orbit.update().apply(this.mat.modelview);
119 |
120 | this.viewdir[0] = -depthmap.mat.modelview[ 2];
121 | this.viewdir[1] = -depthmap.mat.modelview[ 6];
122 | this.viewdir[2] = -depthmap.mat.modelview[10];
123 |
124 |
125 | var w = this.tex.w;
126 | var h = this.tex.h;
127 |
128 | this.fbo.begin();
129 |
130 | gl.viewport(0, 0, w, h);
131 | gl.colorMask(false, false, false, false);
132 | gl.depthMask(true);
133 | gl.disable(gl.BLEND);
134 | gl.enable(gl.DEPTH_TEST);
135 | // gl.clearDepth(1.0);
136 | gl.clear(gl.DEPTH_BUFFER_BIT);
137 |
138 | this.shader.begin();
139 | this.shader.pushAttributeLocWarning(false);
140 | this.shader.pushUniformLocWarning(false);
141 | render_cb(this.shader, this.mat);
142 | this.shader.popAttributeLocWarning();
143 | this.shader.popUniformLocWarning();
144 | this.shader.end();
145 | this.fbo.end();
146 | }
147 |
148 | displayTex(){
149 | this.enableShadowParam(false);
150 |
151 | var w_canvas = this.app.canvas.width;
152 | var h_canvas = this.app.canvas.height;
153 |
154 | var viewport = this.orbit.getViewport();
155 |
156 | var w = viewport[2];
157 | var h = viewport[3];
158 | var x = viewport[0];
159 | var y = viewport[1]; y = h_canvas - 1 - y - h;
160 |
161 | var shader = this.shaderDisplay;
162 |
163 | shader.begin();
164 | gl.viewport(x, y, w, h);
165 | gl.colorMask(true, true, true, true);
166 | gl.disable(gl.BLEND);
167 | gl.disable(gl.DEPTH_TEST);
168 | shader.uniformF('xy_off', [x, y]);
169 | shader.uniformF('wh_rcp', [1/w, 1/h]);
170 | shader.uniformT('tex', this.tex);
171 | shader.quad();
172 | shader.end();
173 |
174 | this.enableShadowParam(true);
175 | }
176 |
177 |
178 |
179 | }
--------------------------------------------------------------------------------
/sketches/screenshots/DeconstructionCubes1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/DeconstructionCubes1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/DeconstructionCubes1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/DeconstructionCubes1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/DeconstructionCubes2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/DeconstructionCubes2.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/DeconstructionCubes2_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/DeconstructionCubes2_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/EdgesDisplay.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/EdgesDisplay.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/EdgesDisplay_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/EdgesDisplay_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/GeometryPrimitives.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/GeometryPrimitives.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/GeometryPrimitives_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/GeometryPrimitives_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/HilbertCurve1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/HilbertCurve1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/HilbertCurve1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/HilbertCurve1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/HilbertCurve2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/HilbertCurve2.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/HilbertCurve2_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/HilbertCurve2_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/MengerSponge1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/MengerSponge1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/MengerSponge1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/MengerSponge1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/MengerSponge2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/MengerSponge2.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/MengerSponge2_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/MengerSponge2_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/MengerSponge3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/MengerSponge3.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/NormalsDisplay.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/NormalsDisplay.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/NormalsDisplay_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/NormalsDisplay_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/PerPixelPhong1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/PerPixelPhong1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/PerPixelPhong1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/PerPixelPhong1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/PerPixelPhong_Primitives1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/PerPixelPhong_Primitives1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/PerPixelPhong_Primitives1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/PerPixelPhong_Primitives1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/ReactionDiffusion1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/ReactionDiffusion1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/ReactionDiffusion1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/ReactionDiffusion1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/Smoothstep1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/Smoothstep1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/Smoothstep1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/Smoothstep1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/SubdivisionPrimitives1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/SubdivisionPrimitives1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/SubdivisionPrimitives1_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/SubdivisionPrimitives1_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/SubdivisionPrimitives2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/SubdivisionPrimitives2.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/SubdivisionPrimitives2_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/SubdivisionPrimitives2_small1.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/SubdivisionPrimitives3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/SubdivisionPrimitives3.jpg
--------------------------------------------------------------------------------
/sketches/screenshots/SubdivisionPrimitives3_small1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/diwi/dw-webgl-sketchbook/80e29b8422be8fa6641b3663ee658c68f4b49fc7/sketches/screenshots/SubdivisionPrimitives3_small1.jpg
--------------------------------------------------------------------------------
/sketches/setup_global.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
42 |
43 |
111 |
112 |
113 |
114 |
115 |
--------------------------------------------------------------------------------
/sketches/setup_local.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
42 |
43 |
111 |
112 |
113 |
114 |
115 |
--------------------------------------------------------------------------------