1 /** 2 * @fileoverview gl-matrix - High performance matrix and vector operations 3 * @author Brandon Jones 4 * @author Colin MacKenzie IV 5 * @version 2.1.0 6 */ 7 8 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 9 10 Redistribution and use in source and binary forms, with or without modification, 11 are permitted provided that the following conditions are met: 12 13 * Redistributions of source code must retain the above copyright notice, this 14 list of conditions and the following disclaimer. 15 * Redistributions in binary form must reproduce the above copyright notice, 16 this list of conditions and the following disclaimer in the documentation 17 and/or other materials provided with the distribution. 18 19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 20 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 21 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 22 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 23 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 24 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 25 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 26 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 28 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 29 30 31 (function() { 32 "use strict"; 33 34 var shim = {}; 35 if (typeof(exports) === 'undefined') { 36 if(typeof define == 'function' && typeof define.amd == 'object' && define.amd) { 37 shim.exports = {}; 38 define(function() { 39 return shim.exports; 40 }); 41 } else { 42 // gl-matrix lives in a browser, define its namespaces in global 43 shim.exports = window; 44 } 45 } 46 else { 47 // gl-matrix lives in commonjs, define its namespaces in exports 48 shim.exports = exports; 49 } 50 51 (function(exports) { 52 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 53 54 Redistribution and use in source and binary forms, with or without modification, 55 are permitted provided that the following conditions are met: 56 57 * Redistributions of source code must retain the above copyright notice, this 58 list of conditions and the following disclaimer. 59 * Redistributions in binary form must reproduce the above copyright notice, 60 this list of conditions and the following disclaimer in the documentation 61 and/or other materials provided with the distribution. 62 63 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 64 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 65 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 66 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 67 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 68 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 69 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 70 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 71 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 72 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 73 74 75 if(!GLMAT_EPSILON) { 76 var GLMAT_EPSILON = 0.000001; 77 } 78 79 if(!GLMAT_ARRAY_TYPE) { 80 var GLMAT_ARRAY_TYPE = (typeof Float32Array !== 'undefined') ? Float32Array : Array; 81 } 82 83 /** 84 * @class Common utilities 85 * @name glMatrix 86 */ 87 var glMatrix = {}; 88 89 /** 90 * Sets the type of array used when creating new vectors and matricies 91 * 92 * @param {Type} type Array type, such as Float32Array or Array 93 */ 94 glMatrix.setMatrixArrayType = function(type) { 95 GLMAT_ARRAY_TYPE = type; 96 } 97 98 if(typeof(exports) !== 'undefined') { 99 exports.glMatrix = glMatrix; 100 } 101 ; 102 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 103 104 Redistribution and use in source and binary forms, with or without modification, 105 are permitted provided that the following conditions are met: 106 107 * Redistributions of source code must retain the above copyright notice, this 108 list of conditions and the following disclaimer. 109 * Redistributions in binary form must reproduce the above copyright notice, 110 this list of conditions and the following disclaimer in the documentation 111 and/or other materials provided with the distribution. 112 113 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 114 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 115 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 116 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 117 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 118 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 119 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 120 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 121 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 122 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 123 124 /** 125 * @class 2 Dimensional Vector 126 * @name vec2 127 */ 128 129 var vec2 = {}; 130 131 /** 132 * Creates a new, empty vec2 133 * 134 * @returns {vec2} a new 2D vector 135 */ 136 vec2.create = function() { 137 var out = new GLMAT_ARRAY_TYPE(2); 138 out[0] = 0; 139 out[1] = 0; 140 return out; 141 }; 142 143 /** 144 * Creates a new vec2 initialized with values from an existing vector 145 * 146 * @param {vec2} a vector to clone 147 * @returns {vec2} a new 2D vector 148 */ 149 vec2.clone = function(a) { 150 var out = new GLMAT_ARRAY_TYPE(2); 151 out[0] = a[0]; 152 out[1] = a[1]; 153 return out; 154 }; 155 156 /** 157 * Creates a new vec2 initialized with the given values 158 * 159 * @param {Number} x X component 160 * @param {Number} y Y component 161 * @returns {vec2} a new 2D vector 162 */ 163 vec2.fromValues = function(x, y) { 164 var out = new GLMAT_ARRAY_TYPE(2); 165 out[0] = x; 166 out[1] = y; 167 return out; 168 }; 169 170 /** 171 * Copy the values from one vec2 to another 172 * 173 * @param {vec2} out the receiving vector 174 * @param {vec2} a the source vector 175 * @returns {vec2} out 176 */ 177 vec2.copy = function(out, a) { 178 out[0] = a[0]; 179 out[1] = a[1]; 180 return out; 181 }; 182 183 /** 184 * Set the components of a vec2 to the given values 185 * 186 * @param {vec2} out the receiving vector 187 * @param {Number} x X component 188 * @param {Number} y Y component 189 * @returns {vec2} out 190 */ 191 vec2.set = function(out, x, y) { 192 out[0] = x; 193 out[1] = y; 194 return out; 195 }; 196 197 /** 198 * Adds two vec2's 199 * 200 * @param {vec2} out the receiving vector 201 * @param {vec2} a the first operand 202 * @param {vec2} b the second operand 203 * @returns {vec2} out 204 */ 205 vec2.add = function(out, a, b) { 206 out[0] = a[0] + b[0]; 207 out[1] = a[1] + b[1]; 208 return out; 209 }; 210 211 /** 212 * Subtracts two vec2's 213 * 214 * @param {vec2} out the receiving vector 215 * @param {vec2} a the first operand 216 * @param {vec2} b the second operand 217 * @returns {vec2} out 218 */ 219 vec2.subtract = function(out, a, b) { 220 out[0] = a[0] - b[0]; 221 out[1] = a[1] - b[1]; 222 return out; 223 }; 224 225 /** 226 * Alias for {@link vec2.subtract} 227 * @function 228 */ 229 vec2.sub = vec2.subtract; 230 231 /** 232 * Multiplies two vec2's 233 * 234 * @param {vec2} out the receiving vector 235 * @param {vec2} a the first operand 236 * @param {vec2} b the second operand 237 * @returns {vec2} out 238 */ 239 vec2.multiply = function(out, a, b) { 240 out[0] = a[0] * b[0]; 241 out[1] = a[1] * b[1]; 242 return out; 243 }; 244 245 /** 246 * Alias for {@link vec2.multiply} 247 * @function 248 */ 249 vec2.mul = vec2.multiply; 250 251 /** 252 * Divides two vec2's 253 * 254 * @param {vec2} out the receiving vector 255 * @param {vec2} a the first operand 256 * @param {vec2} b the second operand 257 * @returns {vec2} out 258 */ 259 vec2.divide = function(out, a, b) { 260 out[0] = a[0] / b[0]; 261 out[1] = a[1] / b[1]; 262 return out; 263 }; 264 265 /** 266 * Alias for {@link vec2.divide} 267 * @function 268 */ 269 vec2.div = vec2.divide; 270 271 /** 272 * Returns the minimum of two vec2's 273 * 274 * @param {vec2} out the receiving vector 275 * @param {vec2} a the first operand 276 * @param {vec2} b the second operand 277 * @returns {vec2} out 278 */ 279 vec2.min = function(out, a, b) { 280 out[0] = Math.min(a[0], b[0]); 281 out[1] = Math.min(a[1], b[1]); 282 return out; 283 }; 284 285 /** 286 * Returns the maximum of two vec2's 287 * 288 * @param {vec2} out the receiving vector 289 * @param {vec2} a the first operand 290 * @param {vec2} b the second operand 291 * @returns {vec2} out 292 */ 293 vec2.max = function(out, a, b) { 294 out[0] = Math.max(a[0], b[0]); 295 out[1] = Math.max(a[1], b[1]); 296 return out; 297 }; 298 299 /** 300 * Scales a vec2 by a scalar number 301 * 302 * @param {vec2} out the receiving vector 303 * @param {vec2} a the vector to scale 304 * @param {Number} b amount to scale the vector by 305 * @returns {vec2} out 306 */ 307 vec2.scale = function(out, a, b) { 308 out[0] = a[0] * b; 309 out[1] = a[1] * b; 310 return out; 311 }; 312 313 /** 314 * Calculates the euclidian distance between two vec2's 315 * 316 * @param {vec2} a the first operand 317 * @param {vec2} b the second operand 318 * @returns {Number} distance between a and b 319 */ 320 vec2.distance = function(a, b) { 321 var x = b[0] - a[0], 322 y = b[1] - a[1]; 323 return Math.sqrt(x*x + y*y); 324 }; 325 326 /** 327 * Alias for {@link vec2.distance} 328 * @function 329 */ 330 vec2.dist = vec2.distance; 331 332 /** 333 * Calculates the squared euclidian distance between two vec2's 334 * 335 * @param {vec2} a the first operand 336 * @param {vec2} b the second operand 337 * @returns {Number} squared distance between a and b 338 */ 339 vec2.squaredDistance = function(a, b) { 340 var x = b[0] - a[0], 341 y = b[1] - a[1]; 342 return x*x + y*y; 343 }; 344 345 /** 346 * Alias for {@link vec2.squaredDistance} 347 * @function 348 */ 349 vec2.sqrDist = vec2.squaredDistance; 350 351 /** 352 * Calculates the length of a vec2 353 * 354 * @param {vec2} a vector to calculate length of 355 * @returns {Number} length of a 356 */ 357 vec2.length = function (a) { 358 var x = a[0], 359 y = a[1]; 360 return Math.sqrt(x*x + y*y); 361 }; 362 363 /** 364 * Alias for {@link vec2.length} 365 * @function 366 */ 367 vec2.len = vec2.length; 368 369 /** 370 * Calculates the squared length of a vec2 371 * 372 * @param {vec2} a vector to calculate squared length of 373 * @returns {Number} squared length of a 374 */ 375 vec2.squaredLength = function (a) { 376 var x = a[0], 377 y = a[1]; 378 return x*x + y*y; 379 }; 380 381 /** 382 * Alias for {@link vec2.squaredLength} 383 * @function 384 */ 385 vec2.sqrLen = vec2.squaredLength; 386 387 /** 388 * Negates the components of a vec2 389 * 390 * @param {vec2} out the receiving vector 391 * @param {vec2} a vector to negate 392 * @returns {vec2} out 393 */ 394 vec2.negate = function(out, a) { 395 out[0] = -a[0]; 396 out[1] = -a[1]; 397 return out; 398 }; 399 400 /** 401 * Normalize a vec2 402 * 403 * @param {vec2} out the receiving vector 404 * @param {vec2} a vector to normalize 405 * @returns {vec2} out 406 */ 407 vec2.normalize = function(out, a) { 408 var x = a[0], 409 y = a[1]; 410 var len = x*x + y*y; 411 if (len > 0) { 412 //TODO: evaluate use of glm_invsqrt here? 413 len = 1 / Math.sqrt(len); 414 out[0] = a[0] * len; 415 out[1] = a[1] * len; 416 } 417 return out; 418 }; 419 420 /** 421 * Calculates the dot product of two vec2's 422 * 423 * @param {vec2} a the first operand 424 * @param {vec2} b the second operand 425 * @returns {Number} dot product of a and b 426 */ 427 vec2.dot = function (a, b) { 428 return a[0] * b[0] + a[1] * b[1]; 429 }; 430 431 /** 432 * Computes the cross product of two vec2's 433 * Note that the cross product must by definition produce a 3D vector 434 * 435 * @param {vec3} out the receiving vector 436 * @param {vec2} a the first operand 437 * @param {vec2} b the second operand 438 * @returns {vec3} out 439 */ 440 vec2.cross = function(out, a, b) { 441 var z = a[0] * b[1] - a[1] * b[0]; 442 out[0] = out[1] = 0; 443 out[2] = z; 444 return out; 445 }; 446 447 /** 448 * Performs a linear interpolation between two vec2's 449 * 450 * @param {vec2} out the receiving vector 451 * @param {vec2} a the first operand 452 * @param {vec2} b the second operand 453 * @param {Number} t interpolation amount between the two inputs 454 * @returns {vec2} out 455 */ 456 vec2.lerp = function (out, a, b, t) { 457 var ax = a[0], 458 ay = a[1]; 459 out[0] = ax + t * (b[0] - ax); 460 out[1] = ay + t * (b[1] - ay); 461 return out; 462 }; 463 464 /** 465 * Transforms the vec2 with a mat2 466 * 467 * @param {vec2} out the receiving vector 468 * @param {vec2} a the vector to transform 469 * @param {mat2} m matrix to transform with 470 * @returns {vec2} out 471 */ 472 vec2.transformMat2 = function(out, a, m) { 473 var x = a[0], 474 y = a[1]; 475 out[0] = m[0] * x + m[2] * y; 476 out[1] = m[1] * x + m[3] * y; 477 return out; 478 }; 479 480 /** 481 * Transforms the vec2 with a mat2d 482 * 483 * @param {vec2} out the receiving vector 484 * @param {vec2} a the vector to transform 485 * @param {mat2d} m matrix to transform with 486 * @returns {vec2} out 487 */ 488 vec2.transformMat2d = function(out, a, m) { 489 var x = a[0], 490 y = a[1]; 491 out[0] = m[0] * x + m[2] * y + m[4]; 492 out[1] = m[1] * x + m[3] * y + m[5]; 493 return out; 494 }; 495 496 /** 497 * Transforms the vec2 with a mat3 498 * 3rd vector component is implicitly '1' 499 * 500 * @param {vec2} out the receiving vector 501 * @param {vec2} a the vector to transform 502 * @param {mat3} m matrix to transform with 503 * @returns {vec2} out 504 */ 505 vec2.transformMat3 = function(out, a, m) { 506 var x = a[0], 507 y = a[1]; 508 out[0] = m[0] * x + m[3] * y + m[6]; 509 out[1] = m[1] * x + m[4] * y + m[7]; 510 return out; 511 }; 512 513 /** 514 * Transforms the vec2 with a mat4 515 * 3rd vector component is implicitly '0' 516 * 4th vector component is implicitly '1' 517 * 518 * @param {vec2} out the receiving vector 519 * @param {vec2} a the vector to transform 520 * @param {mat4} m matrix to transform with 521 * @returns {vec2} out 522 */ 523 vec2.transformMat4 = function(out, a, m) { 524 var x = a[0], 525 y = a[1]; 526 out[0] = m[0] * x + m[4] * y + m[12]; 527 out[1] = m[1] * x + m[5] * y + m[13]; 528 return out; 529 }; 530 531 /** 532 * Perform some operation over an array of vec2s. 533 * 534 * @param {Array} a the array of vectors to iterate over 535 * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed 536 * @param {Number} offset Number of elements to skip at the beginning of the array 537 * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array 538 * @param {Function} fn Function to call for each vector in the array 539 * @param {Object} [arg] additional argument to pass to fn 540 * @returns {Array} a 541 * @function 542 */ 543 vec2.forEach = (function() { 544 var vec = vec2.create(); 545 546 return function(a, stride, offset, count, fn, arg) { 547 var i, l; 548 if(!stride) { 549 stride = 2; 550 } 551 552 if(!offset) { 553 offset = 0; 554 } 555 556 if(count) { 557 l = Math.min((count * stride) + offset, a.length); 558 } else { 559 l = a.length; 560 } 561 562 for(i = offset; i < l; i += stride) { 563 vec[0] = a[i]; vec[1] = a[i+1]; 564 fn(vec, vec, arg); 565 a[i] = vec[0]; a[i+1] = vec[1]; 566 } 567 568 return a; 569 }; 570 })(); 571 572 /** 573 * Returns a string representation of a vector 574 * 575 * @param {vec2} vec vector to represent as a string 576 * @returns {String} string representation of the vector 577 */ 578 vec2.str = function (a) { 579 return 'vec2(' + a[0] + ', ' + a[1] + ')'; 580 }; 581 582 if(typeof(exports) !== 'undefined') { 583 exports.vec2 = vec2; 584 } 585 ; 586 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 587 588 Redistribution and use in source and binary forms, with or without modification, 589 are permitted provided that the following conditions are met: 590 591 * Redistributions of source code must retain the above copyright notice, this 592 list of conditions and the following disclaimer. 593 * Redistributions in binary form must reproduce the above copyright notice, 594 this list of conditions and the following disclaimer in the documentation 595 and/or other materials provided with the distribution. 596 597 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 598 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 599 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 600 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 601 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 602 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 603 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 604 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 605 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 606 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 607 608 /** 609 * @class 3 Dimensional Vector 610 * @name vec3 611 */ 612 613 var vec3 = {}; 614 615 /** 616 * Creates a new, empty vec3 617 * 618 * @returns {vec3} a new 3D vector 619 */ 620 vec3.create = function() { 621 var out = new GLMAT_ARRAY_TYPE(3); 622 out[0] = 0; 623 out[1] = 0; 624 out[2] = 0; 625 return out; 626 }; 627 628 /** 629 * Creates a new vec3 initialized with values from an existing vector 630 * 631 * @param {vec3} a vector to clone 632 * @returns {vec3} a new 3D vector 633 */ 634 vec3.clone = function(a) { 635 var out = new GLMAT_ARRAY_TYPE(3); 636 out[0] = a[0]; 637 out[1] = a[1]; 638 out[2] = a[2]; 639 return out; 640 }; 641 642 /** 643 * Creates a new vec3 initialized with the given values 644 * 645 * @param {Number} x X component 646 * @param {Number} y Y component 647 * @param {Number} z Z component 648 * @returns {vec3} a new 3D vector 649 */ 650 vec3.fromValues = function(x, y, z) { 651 var out = new GLMAT_ARRAY_TYPE(3); 652 out[0] = x; 653 out[1] = y; 654 out[2] = z; 655 return out; 656 }; 657 658 /** 659 * Copy the values from one vec3 to another 660 * 661 * @param {vec3} out the receiving vector 662 * @param {vec3} a the source vector 663 * @returns {vec3} out 664 */ 665 vec3.copy = function(out, a) { 666 out[0] = a[0]; 667 out[1] = a[1]; 668 out[2] = a[2]; 669 return out; 670 }; 671 672 /** 673 * Set the components of a vec3 to the given values 674 * 675 * @param {vec3} out the receiving vector 676 * @param {Number} x X component 677 * @param {Number} y Y component 678 * @param {Number} z Z component 679 * @returns {vec3} out 680 */ 681 vec3.set = function(out, x, y, z) { 682 out[0] = x; 683 out[1] = y; 684 out[2] = z; 685 return out; 686 }; 687 688 /** 689 * Adds two vec3's 690 * 691 * @param {vec3} out the receiving vector 692 * @param {vec3} a the first operand 693 * @param {vec3} b the second operand 694 * @returns {vec3} out 695 */ 696 vec3.add = function(out, a, b) { 697 out[0] = a[0] + b[0]; 698 out[1] = a[1] + b[1]; 699 out[2] = a[2] + b[2]; 700 return out; 701 }; 702 703 /** 704 * Subtracts two vec3's 705 * 706 * @param {vec3} out the receiving vector 707 * @param {vec3} a the first operand 708 * @param {vec3} b the second operand 709 * @returns {vec3} out 710 */ 711 vec3.subtract = function(out, a, b) { 712 out[0] = a[0] - b[0]; 713 out[1] = a[1] - b[1]; 714 out[2] = a[2] - b[2]; 715 return out; 716 }; 717 718 /** 719 * Alias for {@link vec3.subtract} 720 * @function 721 */ 722 vec3.sub = vec3.subtract; 723 724 /** 725 * Multiplies two vec3's 726 * 727 * @param {vec3} out the receiving vector 728 * @param {vec3} a the first operand 729 * @param {vec3} b the second operand 730 * @returns {vec3} out 731 */ 732 vec3.multiply = function(out, a, b) { 733 out[0] = a[0] * b[0]; 734 out[1] = a[1] * b[1]; 735 out[2] = a[2] * b[2]; 736 return out; 737 }; 738 739 /** 740 * Alias for {@link vec3.multiply} 741 * @function 742 */ 743 vec3.mul = vec3.multiply; 744 745 /** 746 * Divides two vec3's 747 * 748 * @param {vec3} out the receiving vector 749 * @param {vec3} a the first operand 750 * @param {vec3} b the second operand 751 * @returns {vec3} out 752 */ 753 vec3.divide = function(out, a, b) { 754 out[0] = a[0] / b[0]; 755 out[1] = a[1] / b[1]; 756 out[2] = a[2] / b[2]; 757 return out; 758 }; 759 760 /** 761 * Alias for {@link vec3.divide} 762 * @function 763 */ 764 vec3.div = vec3.divide; 765 766 /** 767 * Returns the minimum of two vec3's 768 * 769 * @param {vec3} out the receiving vector 770 * @param {vec3} a the first operand 771 * @param {vec3} b the second operand 772 * @returns {vec3} out 773 */ 774 vec3.min = function(out, a, b) { 775 out[0] = Math.min(a[0], b[0]); 776 out[1] = Math.min(a[1], b[1]); 777 out[2] = Math.min(a[2], b[2]); 778 return out; 779 }; 780 781 /** 782 * Returns the maximum of two vec3's 783 * 784 * @param {vec3} out the receiving vector 785 * @param {vec3} a the first operand 786 * @param {vec3} b the second operand 787 * @returns {vec3} out 788 */ 789 vec3.max = function(out, a, b) { 790 out[0] = Math.max(a[0], b[0]); 791 out[1] = Math.max(a[1], b[1]); 792 out[2] = Math.max(a[2], b[2]); 793 return out; 794 }; 795 796 /** 797 * Scales a vec3 by a scalar number 798 * 799 * @param {vec3} out the receiving vector 800 * @param {vec3} a the vector to scale 801 * @param {Number} b amount to scale the vector by 802 * @returns {vec3} out 803 */ 804 vec3.scale = function(out, a, b) { 805 out[0] = a[0] * b; 806 out[1] = a[1] * b; 807 out[2] = a[2] * b; 808 return out; 809 }; 810 811 /** 812 * Calculates the euclidian distance between two vec3's 813 * 814 * @param {vec3} a the first operand 815 * @param {vec3} b the second operand 816 * @returns {Number} distance between a and b 817 */ 818 vec3.distance = function(a, b) { 819 var x = b[0] - a[0], 820 y = b[1] - a[1], 821 z = b[2] - a[2]; 822 return Math.sqrt(x*x + y*y + z*z); 823 }; 824 825 /** 826 * Alias for {@link vec3.distance} 827 * @function 828 */ 829 vec3.dist = vec3.distance; 830 831 /** 832 * Calculates the squared euclidian distance between two vec3's 833 * 834 * @param {vec3} a the first operand 835 * @param {vec3} b the second operand 836 * @returns {Number} squared distance between a and b 837 */ 838 vec3.squaredDistance = function(a, b) { 839 var x = b[0] - a[0], 840 y = b[1] - a[1], 841 z = b[2] - a[2]; 842 return x*x + y*y + z*z; 843 }; 844 845 /** 846 * Alias for {@link vec3.squaredDistance} 847 * @function 848 */ 849 vec3.sqrDist = vec3.squaredDistance; 850 851 /** 852 * Calculates the length of a vec3 853 * 854 * @param {vec3} a vector to calculate length of 855 * @returns {Number} length of a 856 */ 857 vec3.length = function (a) { 858 var x = a[0], 859 y = a[1], 860 z = a[2]; 861 return Math.sqrt(x*x + y*y + z*z); 862 }; 863 864 /** 865 * Alias for {@link vec3.length} 866 * @function 867 */ 868 vec3.len = vec3.length; 869 870 /** 871 * Calculates the squared length of a vec3 872 * 873 * @param {vec3} a vector to calculate squared length of 874 * @returns {Number} squared length of a 875 */ 876 vec3.squaredLength = function (a) { 877 var x = a[0], 878 y = a[1], 879 z = a[2]; 880 return x*x + y*y + z*z; 881 }; 882 883 /** 884 * Alias for {@link vec3.squaredLength} 885 * @function 886 */ 887 vec3.sqrLen = vec3.squaredLength; 888 889 /** 890 * Negates the components of a vec3 891 * 892 * @param {vec3} out the receiving vector 893 * @param {vec3} a vector to negate 894 * @returns {vec3} out 895 */ 896 vec3.negate = function(out, a) { 897 out[0] = -a[0]; 898 out[1] = -a[1]; 899 out[2] = -a[2]; 900 return out; 901 }; 902 903 /** 904 * Normalize a vec3 905 * 906 * @param {vec3} out the receiving vector 907 * @param {vec3} a vector to normalize 908 * @returns {vec3} out 909 */ 910 vec3.normalize = function(out, a) { 911 var x = a[0], 912 y = a[1], 913 z = a[2]; 914 var len = x*x + y*y + z*z; 915 if (len > 0) { 916 //TODO: evaluate use of glm_invsqrt here? 917 len = 1 / Math.sqrt(len); 918 out[0] = a[0] * len; 919 out[1] = a[1] * len; 920 out[2] = a[2] * len; 921 } 922 return out; 923 }; 924 925 /** 926 * Calculates the dot product of two vec3's 927 * 928 * @param {vec3} a the first operand 929 * @param {vec3} b the second operand 930 * @returns {Number} dot product of a and b 931 */ 932 vec3.dot = function (a, b) { 933 return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; 934 }; 935 936 /** 937 * Computes the cross product of two vec3's 938 * 939 * @param {vec3} out the receiving vector 940 * @param {vec3} a the first operand 941 * @param {vec3} b the second operand 942 * @returns {vec3} out 943 */ 944 vec3.cross = function(out, a, b) { 945 var ax = a[0], ay = a[1], az = a[2], 946 bx = b[0], by = b[1], bz = b[2]; 947 948 out[0] = ay * bz - az * by; 949 out[1] = az * bx - ax * bz; 950 out[2] = ax * by - ay * bx; 951 return out; 952 }; 953 954 /** 955 * Performs a linear interpolation between two vec3's 956 * 957 * @param {vec3} out the receiving vector 958 * @param {vec3} a the first operand 959 * @param {vec3} b the second operand 960 * @param {Number} t interpolation amount between the two inputs 961 * @returns {vec3} out 962 */ 963 vec3.lerp = function (out, a, b, t) { 964 var ax = a[0], 965 ay = a[1], 966 az = a[2]; 967 out[0] = ax + t * (b[0] - ax); 968 out[1] = ay + t * (b[1] - ay); 969 out[2] = az + t * (b[2] - az); 970 return out; 971 }; 972 973 /** 974 * Transforms the vec3 with a mat4. 975 * 4th vector component is implicitly '1' 976 * 977 * @param {vec3} out the receiving vector 978 * @param {vec3} a the vector to transform 979 * @param {mat4} m matrix to transform with 980 * @returns {vec3} out 981 */ 982 vec3.transformMat4 = function(out, a, m) { 983 var x = a[0], y = a[1], z = a[2]; 984 out[0] = m[0] * x + m[4] * y + m[8] * z + m[12]; 985 out[1] = m[1] * x + m[5] * y + m[9] * z + m[13]; 986 out[2] = m[2] * x + m[6] * y + m[10] * z + m[14]; 987 return out; 988 }; 989 990 /** 991 * Transforms the vec3 with a quat 992 * 993 * @param {vec3} out the receiving vector 994 * @param {vec3} a the vector to transform 995 * @param {quat} q quaternion to transform with 996 * @returns {vec3} out 997 */ 998 vec3.transformQuat = function(out, a, q) { 999 var x = a[0], y = a[1], z = a[2], 1000 qx = q[0], qy = q[1], qz = q[2], qw = q[3], 1001 1002 // calculate quat * vec 1003 ix = qw * x + qy * z - qz * y, 1004 iy = qw * y + qz * x - qx * z, 1005 iz = qw * z + qx * y - qy * x, 1006 iw = -qx * x - qy * y - qz * z; 1007 1008 // calculate result * inverse quat 1009 out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; 1010 out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; 1011 out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; 1012 return out; 1013 }; 1014 1015 /** 1016 * Perform some operation over an array of vec3s. 1017 * 1018 * @param {Array} a the array of vectors to iterate over 1019 * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed 1020 * @param {Number} offset Number of elements to skip at the beginning of the array 1021 * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array 1022 * @param {Function} fn Function to call for each vector in the array 1023 * @param {Object} [arg] additional argument to pass to fn 1024 * @returns {Array} a 1025 * @function 1026 */ 1027 vec3.forEach = (function() { 1028 var vec = vec3.create(); 1029 1030 return function(a, stride, offset, count, fn, arg) { 1031 var i, l; 1032 if(!stride) { 1033 stride = 3; 1034 } 1035 1036 if(!offset) { 1037 offset = 0; 1038 } 1039 1040 if(count) { 1041 l = Math.min((count * stride) + offset, a.length); 1042 } else { 1043 l = a.length; 1044 } 1045 1046 for(i = offset; i < l; i += stride) { 1047 vec[0] = a[i]; vec[1] = a[i+1]; vec[2] = a[i+2]; 1048 fn(vec, vec, arg); 1049 a[i] = vec[0]; a[i+1] = vec[1]; a[i+2] = vec[2]; 1050 } 1051 1052 return a; 1053 }; 1054 })(); 1055 1056 /** 1057 * Returns a string representation of a vector 1058 * 1059 * @param {vec3} vec vector to represent as a string 1060 * @returns {String} string representation of the vector 1061 */ 1062 vec3.str = function (a) { 1063 return 'vec3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ')'; 1064 }; 1065 1066 if(typeof(exports) !== 'undefined') { 1067 exports.vec3 = vec3; 1068 } 1069 ; 1070 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 1071 1072 Redistribution and use in source and binary forms, with or without modification, 1073 are permitted provided that the following conditions are met: 1074 1075 * Redistributions of source code must retain the above copyright notice, this 1076 list of conditions and the following disclaimer. 1077 * Redistributions in binary form must reproduce the above copyright notice, 1078 this list of conditions and the following disclaimer in the documentation 1079 and/or other materials provided with the distribution. 1080 1081 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 1082 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 1083 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 1084 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 1085 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 1086 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 1087 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 1088 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 1089 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 1090 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 1091 1092 /** 1093 * @class 4 Dimensional Vector 1094 * @name vec4 1095 */ 1096 1097 var vec4 = {}; 1098 1099 /** 1100 * Creates a new, empty vec4 1101 * 1102 * @returns {vec4} a new 4D vector 1103 */ 1104 vec4.create = function() { 1105 var out = new GLMAT_ARRAY_TYPE(4); 1106 out[0] = 0; 1107 out[1] = 0; 1108 out[2] = 0; 1109 out[3] = 0; 1110 return out; 1111 }; 1112 1113 /** 1114 * Creates a new vec4 initialized with values from an existing vector 1115 * 1116 * @param {vec4} a vector to clone 1117 * @returns {vec4} a new 4D vector 1118 */ 1119 vec4.clone = function(a) { 1120 var out = new GLMAT_ARRAY_TYPE(4); 1121 out[0] = a[0]; 1122 out[1] = a[1]; 1123 out[2] = a[2]; 1124 out[3] = a[3]; 1125 return out; 1126 }; 1127 1128 /** 1129 * Creates a new vec4 initialized with the given values 1130 * 1131 * @param {Number} x X component 1132 * @param {Number} y Y component 1133 * @param {Number} z Z component 1134 * @param {Number} w W component 1135 * @returns {vec4} a new 4D vector 1136 */ 1137 vec4.fromValues = function(x, y, z, w) { 1138 var out = new GLMAT_ARRAY_TYPE(4); 1139 out[0] = x; 1140 out[1] = y; 1141 out[2] = z; 1142 out[3] = w; 1143 return out; 1144 }; 1145 1146 /** 1147 * Copy the values from one vec4 to another 1148 * 1149 * @param {vec4} out the receiving vector 1150 * @param {vec4} a the source vector 1151 * @returns {vec4} out 1152 */ 1153 vec4.copy = function(out, a) { 1154 out[0] = a[0]; 1155 out[1] = a[1]; 1156 out[2] = a[2]; 1157 out[3] = a[3]; 1158 return out; 1159 }; 1160 1161 /** 1162 * Set the components of a vec4 to the given values 1163 * 1164 * @param {vec4} out the receiving vector 1165 * @param {Number} x X component 1166 * @param {Number} y Y component 1167 * @param {Number} z Z component 1168 * @param {Number} w W component 1169 * @returns {vec4} out 1170 */ 1171 vec4.set = function(out, x, y, z, w) { 1172 out[0] = x; 1173 out[1] = y; 1174 out[2] = z; 1175 out[3] = w; 1176 return out; 1177 }; 1178 1179 /** 1180 * Adds two vec4's 1181 * 1182 * @param {vec4} out the receiving vector 1183 * @param {vec4} a the first operand 1184 * @param {vec4} b the second operand 1185 * @returns {vec4} out 1186 */ 1187 vec4.add = function(out, a, b) { 1188 out[0] = a[0] + b[0]; 1189 out[1] = a[1] + b[1]; 1190 out[2] = a[2] + b[2]; 1191 out[3] = a[3] + b[3]; 1192 return out; 1193 }; 1194 1195 /** 1196 * Subtracts two vec4's 1197 * 1198 * @param {vec4} out the receiving vector 1199 * @param {vec4} a the first operand 1200 * @param {vec4} b the second operand 1201 * @returns {vec4} out 1202 */ 1203 vec4.subtract = function(out, a, b) { 1204 out[0] = a[0] - b[0]; 1205 out[1] = a[1] - b[1]; 1206 out[2] = a[2] - b[2]; 1207 out[3] = a[3] - b[3]; 1208 return out; 1209 }; 1210 1211 /** 1212 * Alias for {@link vec4.subtract} 1213 * @function 1214 */ 1215 vec4.sub = vec4.subtract; 1216 1217 /** 1218 * Multiplies two vec4's 1219 * 1220 * @param {vec4} out the receiving vector 1221 * @param {vec4} a the first operand 1222 * @param {vec4} b the second operand 1223 * @returns {vec4} out 1224 */ 1225 vec4.multiply = function(out, a, b) { 1226 out[0] = a[0] * b[0]; 1227 out[1] = a[1] * b[1]; 1228 out[2] = a[2] * b[2]; 1229 out[3] = a[3] * b[3]; 1230 return out; 1231 }; 1232 1233 /** 1234 * Alias for {@link vec4.multiply} 1235 * @function 1236 */ 1237 vec4.mul = vec4.multiply; 1238 1239 /** 1240 * Divides two vec4's 1241 * 1242 * @param {vec4} out the receiving vector 1243 * @param {vec4} a the first operand 1244 * @param {vec4} b the second operand 1245 * @returns {vec4} out 1246 */ 1247 vec4.divide = function(out, a, b) { 1248 out[0] = a[0] / b[0]; 1249 out[1] = a[1] / b[1]; 1250 out[2] = a[2] / b[2]; 1251 out[3] = a[3] / b[3]; 1252 return out; 1253 }; 1254 1255 /** 1256 * Alias for {@link vec4.divide} 1257 * @function 1258 */ 1259 vec4.div = vec4.divide; 1260 1261 /** 1262 * Returns the minimum of two vec4's 1263 * 1264 * @param {vec4} out the receiving vector 1265 * @param {vec4} a the first operand 1266 * @param {vec4} b the second operand 1267 * @returns {vec4} out 1268 */ 1269 vec4.min = function(out, a, b) { 1270 out[0] = Math.min(a[0], b[0]); 1271 out[1] = Math.min(a[1], b[1]); 1272 out[2] = Math.min(a[2], b[2]); 1273 out[3] = Math.min(a[3], b[3]); 1274 return out; 1275 }; 1276 1277 /** 1278 * Returns the maximum of two vec4's 1279 * 1280 * @param {vec4} out the receiving vector 1281 * @param {vec4} a the first operand 1282 * @param {vec4} b the second operand 1283 * @returns {vec4} out 1284 */ 1285 vec4.max = function(out, a, b) { 1286 out[0] = Math.max(a[0], b[0]); 1287 out[1] = Math.max(a[1], b[1]); 1288 out[2] = Math.max(a[2], b[2]); 1289 out[3] = Math.max(a[3], b[3]); 1290 return out; 1291 }; 1292 1293 /** 1294 * Scales a vec4 by a scalar number 1295 * 1296 * @param {vec4} out the receiving vector 1297 * @param {vec4} a the vector to scale 1298 * @param {Number} b amount to scale the vector by 1299 * @returns {vec4} out 1300 */ 1301 vec4.scale = function(out, a, b) { 1302 out[0] = a[0] * b; 1303 out[1] = a[1] * b; 1304 out[2] = a[2] * b; 1305 out[3] = a[3] * b; 1306 return out; 1307 }; 1308 1309 /** 1310 * Calculates the euclidian distance between two vec4's 1311 * 1312 * @param {vec4} a the first operand 1313 * @param {vec4} b the second operand 1314 * @returns {Number} distance between a and b 1315 */ 1316 vec4.distance = function(a, b) { 1317 var x = b[0] - a[0], 1318 y = b[1] - a[1], 1319 z = b[2] - a[2], 1320 w = b[3] - a[3]; 1321 return Math.sqrt(x*x + y*y + z*z + w*w); 1322 }; 1323 1324 /** 1325 * Alias for {@link vec4.distance} 1326 * @function 1327 */ 1328 vec4.dist = vec4.distance; 1329 1330 /** 1331 * Calculates the squared euclidian distance between two vec4's 1332 * 1333 * @param {vec4} a the first operand 1334 * @param {vec4} b the second operand 1335 * @returns {Number} squared distance between a and b 1336 */ 1337 vec4.squaredDistance = function(a, b) { 1338 var x = b[0] - a[0], 1339 y = b[1] - a[1], 1340 z = b[2] - a[2], 1341 w = b[3] - a[3]; 1342 return x*x + y*y + z*z + w*w; 1343 }; 1344 1345 /** 1346 * Alias for {@link vec4.squaredDistance} 1347 * @function 1348 */ 1349 vec4.sqrDist = vec4.squaredDistance; 1350 1351 /** 1352 * Calculates the length of a vec4 1353 * 1354 * @param {vec4} a vector to calculate length of 1355 * @returns {Number} length of a 1356 */ 1357 vec4.length = function (a) { 1358 var x = a[0], 1359 y = a[1], 1360 z = a[2], 1361 w = a[3]; 1362 return Math.sqrt(x*x + y*y + z*z + w*w); 1363 }; 1364 1365 /** 1366 * Alias for {@link vec4.length} 1367 * @function 1368 */ 1369 vec4.len = vec4.length; 1370 1371 /** 1372 * Calculates the squared length of a vec4 1373 * 1374 * @param {vec4} a vector to calculate squared length of 1375 * @returns {Number} squared length of a 1376 */ 1377 vec4.squaredLength = function (a) { 1378 var x = a[0], 1379 y = a[1], 1380 z = a[2], 1381 w = a[3]; 1382 return x*x + y*y + z*z + w*w; 1383 }; 1384 1385 /** 1386 * Alias for {@link vec4.squaredLength} 1387 * @function 1388 */ 1389 vec4.sqrLen = vec4.squaredLength; 1390 1391 /** 1392 * Negates the components of a vec4 1393 * 1394 * @param {vec4} out the receiving vector 1395 * @param {vec4} a vector to negate 1396 * @returns {vec4} out 1397 */ 1398 vec4.negate = function(out, a) { 1399 out[0] = -a[0]; 1400 out[1] = -a[1]; 1401 out[2] = -a[2]; 1402 out[3] = -a[3]; 1403 return out; 1404 }; 1405 1406 /** 1407 * Normalize a vec4 1408 * 1409 * @param {vec4} out the receiving vector 1410 * @param {vec4} a vector to normalize 1411 * @returns {vec4} out 1412 */ 1413 vec4.normalize = function(out, a) { 1414 var x = a[0], 1415 y = a[1], 1416 z = a[2], 1417 w = a[3]; 1418 var len = x*x + y*y + z*z + w*w; 1419 if (len > 0) { 1420 len = 1 / Math.sqrt(len); 1421 out[0] = a[0] * len; 1422 out[1] = a[1] * len; 1423 out[2] = a[2] * len; 1424 out[3] = a[3] * len; 1425 } 1426 return out; 1427 }; 1428 1429 /** 1430 * Calculates the dot product of two vec4's 1431 * 1432 * @param {vec4} a the first operand 1433 * @param {vec4} b the second operand 1434 * @returns {Number} dot product of a and b 1435 */ 1436 vec4.dot = function (a, b) { 1437 return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; 1438 }; 1439 1440 /** 1441 * Performs a linear interpolation between two vec4's 1442 * 1443 * @param {vec4} out the receiving vector 1444 * @param {vec4} a the first operand 1445 * @param {vec4} b the second operand 1446 * @param {Number} t interpolation amount between the two inputs 1447 * @returns {vec4} out 1448 */ 1449 vec4.lerp = function (out, a, b, t) { 1450 var ax = a[0], 1451 ay = a[1], 1452 az = a[2], 1453 aw = a[3]; 1454 out[0] = ax + t * (b[0] - ax); 1455 out[1] = ay + t * (b[1] - ay); 1456 out[2] = az + t * (b[2] - az); 1457 out[3] = aw + t * (b[3] - aw); 1458 return out; 1459 }; 1460 1461 /** 1462 * Transforms the vec4 with a mat4. 1463 * 1464 * @param {vec4} out the receiving vector 1465 * @param {vec4} a the vector to transform 1466 * @param {mat4} m matrix to transform with 1467 * @returns {vec4} out 1468 */ 1469 vec4.transformMat4 = function(out, a, m) { 1470 var x = a[0], y = a[1], z = a[2], w = a[3]; 1471 out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w; 1472 out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w; 1473 out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w; 1474 out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w; 1475 return out; 1476 }; 1477 1478 /** 1479 * Transforms the vec4 with a quat 1480 * 1481 * @param {vec4} out the receiving vector 1482 * @param {vec4} a the vector to transform 1483 * @param {quat} q quaternion to transform with 1484 * @returns {vec4} out 1485 */ 1486 vec4.transformQuat = function(out, a, q) { 1487 var x = a[0], y = a[1], z = a[2], 1488 qx = q[0], qy = q[1], qz = q[2], qw = q[3], 1489 1490 // calculate quat * vec 1491 ix = qw * x + qy * z - qz * y, 1492 iy = qw * y + qz * x - qx * z, 1493 iz = qw * z + qx * y - qy * x, 1494 iw = -qx * x - qy * y - qz * z; 1495 1496 // calculate result * inverse quat 1497 out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; 1498 out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; 1499 out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; 1500 return out; 1501 }; 1502 1503 /** 1504 * Perform some operation over an array of vec4s. 1505 * 1506 * @param {Array} a the array of vectors to iterate over 1507 * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed 1508 * @param {Number} offset Number of elements to skip at the beginning of the array 1509 * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array 1510 * @param {Function} fn Function to call for each vector in the array 1511 * @param {Object} [arg] additional argument to pass to fn 1512 * @returns {Array} a 1513 * @function 1514 */ 1515 vec4.forEach = (function() { 1516 var vec = vec4.create(); 1517 1518 return function(a, stride, offset, count, fn, arg) { 1519 var i, l; 1520 if(!stride) { 1521 stride = 4; 1522 } 1523 1524 if(!offset) { 1525 offset = 0; 1526 } 1527 1528 if(count) { 1529 l = Math.min((count * stride) + offset, a.length); 1530 } else { 1531 l = a.length; 1532 } 1533 1534 for(i = offset; i < l; i += stride) { 1535 vec[0] = a[i]; vec[1] = a[i+1]; vec[2] = a[i+2]; vec[3] = a[i+3]; 1536 fn(vec, vec, arg); 1537 a[i] = vec[0]; a[i+1] = vec[1]; a[i+2] = vec[2]; a[i+3] = vec[3]; 1538 } 1539 1540 return a; 1541 }; 1542 })(); 1543 1544 /** 1545 * Returns a string representation of a vector 1546 * 1547 * @param {vec4} vec vector to represent as a string 1548 * @returns {String} string representation of the vector 1549 */ 1550 vec4.str = function (a) { 1551 return 'vec4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')'; 1552 }; 1553 1554 if(typeof(exports) !== 'undefined') { 1555 exports.vec4 = vec4; 1556 } 1557 ; 1558 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 1559 1560 Redistribution and use in source and binary forms, with or without modification, 1561 are permitted provided that the following conditions are met: 1562 1563 * Redistributions of source code must retain the above copyright notice, this 1564 list of conditions and the following disclaimer. 1565 * Redistributions in binary form must reproduce the above copyright notice, 1566 this list of conditions and the following disclaimer in the documentation 1567 and/or other materials provided with the distribution. 1568 1569 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 1570 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 1571 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 1572 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 1573 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 1574 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 1575 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 1576 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 1577 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 1578 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 1579 1580 /** 1581 * @class 2x2 Matrix 1582 * @name mat2 1583 */ 1584 1585 var mat2 = {}; 1586 1587 /** 1588 * Creates a new identity mat2 1589 * 1590 * @returns {mat2} a new 2x2 matrix 1591 */ 1592 mat2.create = function() { 1593 var out = new GLMAT_ARRAY_TYPE(4); 1594 out[0] = 1; 1595 out[1] = 0; 1596 out[2] = 0; 1597 out[3] = 1; 1598 return out; 1599 }; 1600 1601 /** 1602 * Creates a new mat2 initialized with values from an existing matrix 1603 * 1604 * @param {mat2} a matrix to clone 1605 * @returns {mat2} a new 2x2 matrix 1606 */ 1607 mat2.clone = function(a) { 1608 var out = new GLMAT_ARRAY_TYPE(4); 1609 out[0] = a[0]; 1610 out[1] = a[1]; 1611 out[2] = a[2]; 1612 out[3] = a[3]; 1613 return out; 1614 }; 1615 1616 /** 1617 * Copy the values from one mat2 to another 1618 * 1619 * @param {mat2} out the receiving matrix 1620 * @param {mat2} a the source matrix 1621 * @returns {mat2} out 1622 */ 1623 mat2.copy = function(out, a) { 1624 out[0] = a[0]; 1625 out[1] = a[1]; 1626 out[2] = a[2]; 1627 out[3] = a[3]; 1628 return out; 1629 }; 1630 1631 /** 1632 * Set a mat2 to the identity matrix 1633 * 1634 * @param {mat2} out the receiving matrix 1635 * @returns {mat2} out 1636 */ 1637 mat2.identity = function(out) { 1638 out[0] = 1; 1639 out[1] = 0; 1640 out[2] = 0; 1641 out[3] = 1; 1642 return out; 1643 }; 1644 1645 /** 1646 * Transpose the values of a mat2 1647 * 1648 * @param {mat2} out the receiving matrix 1649 * @param {mat2} a the source matrix 1650 * @returns {mat2} out 1651 */ 1652 mat2.transpose = function(out, a) { 1653 // If we are transposing ourselves we can skip a few steps but have to cache some values 1654 if (out === a) { 1655 var a1 = a[1]; 1656 out[1] = a[2]; 1657 out[2] = a1; 1658 } else { 1659 out[0] = a[0]; 1660 out[1] = a[2]; 1661 out[2] = a[1]; 1662 out[3] = a[3]; 1663 } 1664 1665 return out; 1666 }; 1667 1668 /** 1669 * Inverts a mat2 1670 * 1671 * @param {mat2} out the receiving matrix 1672 * @param {mat2} a the source matrix 1673 * @returns {mat2} out 1674 */ 1675 mat2.invert = function(out, a) { 1676 var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], 1677 1678 // Calculate the determinant 1679 det = a0 * a3 - a2 * a1; 1680 1681 if (!det) { 1682 return null; 1683 } 1684 det = 1.0 / det; 1685 1686 out[0] = a3 * det; 1687 out[1] = -a1 * det; 1688 out[2] = -a2 * det; 1689 out[3] = a0 * det; 1690 1691 return out; 1692 }; 1693 1694 /** 1695 * Calculates the adjugate of a mat2 1696 * 1697 * @param {mat2} out the receiving matrix 1698 * @param {mat2} a the source matrix 1699 * @returns {mat2} out 1700 */ 1701 mat2.adjoint = function(out, a) { 1702 // Caching this value is nessecary if out == a 1703 var a0 = a[0]; 1704 out[0] = a[3]; 1705 out[1] = -a[1]; 1706 out[2] = -a[2]; 1707 out[3] = a0; 1708 1709 return out; 1710 }; 1711 1712 /** 1713 * Calculates the determinant of a mat2 1714 * 1715 * @param {mat2} a the source matrix 1716 * @returns {Number} determinant of a 1717 */ 1718 mat2.determinant = function (a) { 1719 return a[0] * a[3] - a[2] * a[1]; 1720 }; 1721 1722 /** 1723 * Multiplies two mat2's 1724 * 1725 * @param {mat2} out the receiving matrix 1726 * @param {mat2} a the first operand 1727 * @param {mat2} b the second operand 1728 * @returns {mat2} out 1729 */ 1730 mat2.multiply = function (out, a, b) { 1731 var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3]; 1732 var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3]; 1733 out[0] = a0 * b0 + a1 * b2; 1734 out[1] = a0 * b1 + a1 * b3; 1735 out[2] = a2 * b0 + a3 * b2; 1736 out[3] = a2 * b1 + a3 * b3; 1737 return out; 1738 }; 1739 1740 /** 1741 * Alias for {@link mat2.multiply} 1742 * @function 1743 */ 1744 mat2.mul = mat2.multiply; 1745 1746 /** 1747 * Rotates a mat2 by the given angle 1748 * 1749 * @param {mat2} out the receiving matrix 1750 * @param {mat2} a the matrix to rotate 1751 * @param {Number} rad the angle to rotate the matrix by 1752 * @returns {mat2} out 1753 */ 1754 mat2.rotate = function (out, a, rad) { 1755 var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], 1756 s = Math.sin(rad), 1757 c = Math.cos(rad); 1758 out[0] = a0 * c + a1 * s; 1759 out[1] = a0 * -s + a1 * c; 1760 out[2] = a2 * c + a3 * s; 1761 out[3] = a2 * -s + a3 * c; 1762 return out; 1763 }; 1764 1765 /** 1766 * Scales the mat2 by the dimensions in the given vec2 1767 * 1768 * @param {mat2} out the receiving matrix 1769 * @param {mat2} a the matrix to rotate 1770 * @param {vec2} v the vec2 to scale the matrix by 1771 * @returns {mat2} out 1772 **/ 1773 mat2.scale = function(out, a, v) { 1774 var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], 1775 v0 = v[0], v1 = v[1]; 1776 out[0] = a0 * v0; 1777 out[1] = a1 * v1; 1778 out[2] = a2 * v0; 1779 out[3] = a3 * v1; 1780 return out; 1781 }; 1782 1783 /** 1784 * Returns a string representation of a mat2 1785 * 1786 * @param {mat2} mat matrix to represent as a string 1787 * @returns {String} string representation of the matrix 1788 */ 1789 mat2.str = function (a) { 1790 return 'mat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')'; 1791 }; 1792 1793 if(typeof(exports) !== 'undefined') { 1794 exports.mat2 = mat2; 1795 } 1796 ; 1797 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 1798 1799 Redistribution and use in source and binary forms, with or without modification, 1800 are permitted provided that the following conditions are met: 1801 1802 * Redistributions of source code must retain the above copyright notice, this 1803 list of conditions and the following disclaimer. 1804 * Redistributions in binary form must reproduce the above copyright notice, 1805 this list of conditions and the following disclaimer in the documentation 1806 and/or other materials provided with the distribution. 1807 1808 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 1809 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 1810 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 1811 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 1812 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 1813 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 1814 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 1815 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 1816 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 1817 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 1818 1819 /** 1820 * @class 2x3 Matrix 1821 * @name mat2d 1822 * 1823 * @description 1824 * A mat2d contains six elements defined as: 1825 * <pre> 1826 * [a, b, 1827 * c, d, 1828 * tx,ty] 1829 * </pre> 1830 * This is a short form for the 3x3 matrix: 1831 * <pre> 1832 * [a, b, 0 1833 * c, d, 0 1834 * tx,ty,1] 1835 * </pre> 1836 * The last column is ignored so the array is shorter and operations are faster. 1837 */ 1838 1839 var mat2d = {}; 1840 1841 /** 1842 * Creates a new identity mat2d 1843 * 1844 * @returns {mat2d} a new 2x3 matrix 1845 */ 1846 mat2d.create = function() { 1847 var out = new GLMAT_ARRAY_TYPE(6); 1848 out[0] = 1; 1849 out[1] = 0; 1850 out[2] = 0; 1851 out[3] = 1; 1852 out[4] = 0; 1853 out[5] = 0; 1854 return out; 1855 }; 1856 1857 /** 1858 * Creates a new mat2d initialized with values from an existing matrix 1859 * 1860 * @param {mat2d} a matrix to clone 1861 * @returns {mat2d} a new 2x3 matrix 1862 */ 1863 mat2d.clone = function(a) { 1864 var out = new GLMAT_ARRAY_TYPE(6); 1865 out[0] = a[0]; 1866 out[1] = a[1]; 1867 out[2] = a[2]; 1868 out[3] = a[3]; 1869 out[4] = a[4]; 1870 out[5] = a[5]; 1871 return out; 1872 }; 1873 1874 /** 1875 * Copy the values from one mat2d to another 1876 * 1877 * @param {mat2d} out the receiving matrix 1878 * @param {mat2d} a the source matrix 1879 * @returns {mat2d} out 1880 */ 1881 mat2d.copy = function(out, a) { 1882 out[0] = a[0]; 1883 out[1] = a[1]; 1884 out[2] = a[2]; 1885 out[3] = a[3]; 1886 out[4] = a[4]; 1887 out[5] = a[5]; 1888 return out; 1889 }; 1890 1891 /** 1892 * Set a mat2d to the identity matrix 1893 * 1894 * @param {mat2d} out the receiving matrix 1895 * @returns {mat2d} out 1896 */ 1897 mat2d.identity = function(out) { 1898 out[0] = 1; 1899 out[1] = 0; 1900 out[2] = 0; 1901 out[3] = 1; 1902 out[4] = 0; 1903 out[5] = 0; 1904 return out; 1905 }; 1906 1907 /** 1908 * Inverts a mat2d 1909 * 1910 * @param {mat2d} out the receiving matrix 1911 * @param {mat2d} a the source matrix 1912 * @returns {mat2d} out 1913 */ 1914 mat2d.invert = function(out, a) { 1915 var aa = a[0], ab = a[1], ac = a[2], ad = a[3], 1916 atx = a[4], aty = a[5]; 1917 1918 var det = aa * ad - ab * ac; 1919 if(!det){ 1920 return null; 1921 } 1922 det = 1.0 / det; 1923 1924 out[0] = ad * det; 1925 out[1] = -ab * det; 1926 out[2] = -ac * det; 1927 out[3] = aa * det; 1928 out[4] = (ac * aty - ad * atx) * det; 1929 out[5] = (ab * atx - aa * aty) * det; 1930 return out; 1931 }; 1932 1933 /** 1934 * Calculates the determinant of a mat2d 1935 * 1936 * @param {mat2d} a the source matrix 1937 * @returns {Number} determinant of a 1938 */ 1939 mat2d.determinant = function (a) { 1940 return a[0] * a[3] - a[1] * a[2]; 1941 }; 1942 1943 /** 1944 * Multiplies two mat2d's 1945 * 1946 * @param {mat2d} out the receiving matrix 1947 * @param {mat2d} a the first operand 1948 * @param {mat2d} b the second operand 1949 * @returns {mat2d} out 1950 */ 1951 mat2d.multiply = function (out, a, b) { 1952 var aa = a[0], ab = a[1], ac = a[2], ad = a[3], 1953 atx = a[4], aty = a[5], 1954 ba = b[0], bb = b[1], bc = b[2], bd = b[3], 1955 btx = b[4], bty = b[5]; 1956 1957 out[0] = aa*ba + ab*bc; 1958 out[1] = aa*bb + ab*bd; 1959 out[2] = ac*ba + ad*bc; 1960 out[3] = ac*bb + ad*bd; 1961 out[4] = ba*atx + bc*aty + btx; 1962 out[5] = bb*atx + bd*aty + bty; 1963 return out; 1964 }; 1965 1966 /** 1967 * Alias for {@link mat2d.multiply} 1968 * @function 1969 */ 1970 mat2d.mul = mat2d.multiply; 1971 1972 1973 /** 1974 * Rotates a mat2d by the given angle 1975 * 1976 * @param {mat2d} out the receiving matrix 1977 * @param {mat2d} a the matrix to rotate 1978 * @param {Number} rad the angle to rotate the matrix by 1979 * @returns {mat2d} out 1980 */ 1981 mat2d.rotate = function (out, a, rad) { 1982 var aa = a[0], 1983 ab = a[1], 1984 ac = a[2], 1985 ad = a[3], 1986 atx = a[4], 1987 aty = a[5], 1988 st = Math.sin(rad), 1989 ct = Math.cos(rad); 1990 1991 out[0] = aa*ct + ab*st; 1992 out[1] = -aa*st + ab*ct; 1993 out[2] = ac*ct + ad*st; 1994 out[3] = -ac*st + ct*ad; 1995 out[4] = ct*atx + st*aty; 1996 out[5] = ct*aty - st*atx; 1997 return out; 1998 }; 1999 2000 /** 2001 * Scales the mat2d by the dimensions in the given vec2 2002 * 2003 * @param {mat2d} out the receiving matrix 2004 * @param {mat2d} a the matrix to translate 2005 * @param {mat2d} v the vec2 to scale the matrix by 2006 * @returns {mat2d} out 2007 **/ 2008 mat2d.scale = function(out, a, v) { 2009 var vx = v[0], vy = v[1]; 2010 out[0] = a[0] * vx; 2011 out[1] = a[1] * vy; 2012 out[2] = a[2] * vx; 2013 out[3] = a[3] * vy; 2014 out[4] = a[4] * vx; 2015 out[5] = a[5] * vy; 2016 return out; 2017 }; 2018 2019 /** 2020 * Translates the mat2d by the dimensions in the given vec2 2021 * 2022 * @param {mat2d} out the receiving matrix 2023 * @param {mat2d} a the matrix to translate 2024 * @param {mat2d} v the vec2 to translate the matrix by 2025 * @returns {mat2d} out 2026 **/ 2027 mat2d.translate = function(out, a, v) { 2028 out[0] = a[0]; 2029 out[1] = a[1]; 2030 out[2] = a[2]; 2031 out[3] = a[3]; 2032 out[4] = a[4] + v[0]; 2033 out[5] = a[5] + v[1]; 2034 return out; 2035 }; 2036 2037 /** 2038 * Returns a string representation of a mat2d 2039 * 2040 * @param {mat2d} a matrix to represent as a string 2041 * @returns {String} string representation of the matrix 2042 */ 2043 mat2d.str = function (a) { 2044 return 'mat2d(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + 2045 a[3] + ', ' + a[4] + ', ' + a[5] + ')'; 2046 }; 2047 2048 if(typeof(exports) !== 'undefined') { 2049 exports.mat2d = mat2d; 2050 } 2051 ; 2052 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 2053 2054 Redistribution and use in source and binary forms, with or without modification, 2055 are permitted provided that the following conditions are met: 2056 2057 * Redistributions of source code must retain the above copyright notice, this 2058 list of conditions and the following disclaimer. 2059 * Redistributions in binary form must reproduce the above copyright notice, 2060 this list of conditions and the following disclaimer in the documentation 2061 and/or other materials provided with the distribution. 2062 2063 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 2064 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 2065 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 2066 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 2067 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 2068 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 2069 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 2070 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2071 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 2072 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 2073 2074 /** 2075 * @class 3x3 Matrix 2076 * @name mat3 2077 */ 2078 2079 var mat3 = {}; 2080 2081 /** 2082 * Creates a new identity mat3 2083 * 2084 * @returns {mat3} a new 3x3 matrix 2085 */ 2086 mat3.create = function() { 2087 var out = new GLMAT_ARRAY_TYPE(9); 2088 out[0] = 1; 2089 out[1] = 0; 2090 out[2] = 0; 2091 out[3] = 0; 2092 out[4] = 1; 2093 out[5] = 0; 2094 out[6] = 0; 2095 out[7] = 0; 2096 out[8] = 1; 2097 return out; 2098 }; 2099 2100 /** 2101 * Copies the upper-left 3x3 values into the given mat3. 2102 * 2103 * @param {mat3} out the receiving 3x3 matrix 2104 * @param {mat4} a the source 4x4 matrix 2105 * @returns {mat3} out 2106 */ 2107 mat3.fromMat4 = function(out, a) { 2108 out[0] = a[0]; 2109 out[1] = a[1]; 2110 out[2] = a[2]; 2111 out[3] = a[4]; 2112 out[4] = a[5]; 2113 out[5] = a[6]; 2114 out[6] = a[8]; 2115 out[7] = a[9]; 2116 out[8] = a[10]; 2117 return out; 2118 }; 2119 2120 /** 2121 * Creates a new mat3 initialized with values from an existing matrix 2122 * 2123 * @param {mat3} a matrix to clone 2124 * @returns {mat3} a new 3x3 matrix 2125 */ 2126 mat3.clone = function(a) { 2127 var out = new GLMAT_ARRAY_TYPE(9); 2128 out[0] = a[0]; 2129 out[1] = a[1]; 2130 out[2] = a[2]; 2131 out[3] = a[3]; 2132 out[4] = a[4]; 2133 out[5] = a[5]; 2134 out[6] = a[6]; 2135 out[7] = a[7]; 2136 out[8] = a[8]; 2137 return out; 2138 }; 2139 2140 /** 2141 * Copy the values from one mat3 to another 2142 * 2143 * @param {mat3} out the receiving matrix 2144 * @param {mat3} a the source matrix 2145 * @returns {mat3} out 2146 */ 2147 mat3.copy = function(out, a) { 2148 out[0] = a[0]; 2149 out[1] = a[1]; 2150 out[2] = a[2]; 2151 out[3] = a[3]; 2152 out[4] = a[4]; 2153 out[5] = a[5]; 2154 out[6] = a[6]; 2155 out[7] = a[7]; 2156 out[8] = a[8]; 2157 return out; 2158 }; 2159 2160 /** 2161 * Set a mat3 to the identity matrix 2162 * 2163 * @param {mat3} out the receiving matrix 2164 * @returns {mat3} out 2165 */ 2166 mat3.identity = function(out) { 2167 out[0] = 1; 2168 out[1] = 0; 2169 out[2] = 0; 2170 out[3] = 0; 2171 out[4] = 1; 2172 out[5] = 0; 2173 out[6] = 0; 2174 out[7] = 0; 2175 out[8] = 1; 2176 return out; 2177 }; 2178 2179 /** 2180 * Transpose the values of a mat3 2181 * 2182 * @param {mat3} out the receiving matrix 2183 * @param {mat3} a the source matrix 2184 * @returns {mat3} out 2185 */ 2186 mat3.transpose = function(out, a) { 2187 // If we are transposing ourselves we can skip a few steps but have to cache some values 2188 if (out === a) { 2189 var a01 = a[1], a02 = a[2], a12 = a[5]; 2190 out[1] = a[3]; 2191 out[2] = a[6]; 2192 out[3] = a01; 2193 out[5] = a[7]; 2194 out[6] = a02; 2195 out[7] = a12; 2196 } else { 2197 out[0] = a[0]; 2198 out[1] = a[3]; 2199 out[2] = a[6]; 2200 out[3] = a[1]; 2201 out[4] = a[4]; 2202 out[5] = a[7]; 2203 out[6] = a[2]; 2204 out[7] = a[5]; 2205 out[8] = a[8]; 2206 } 2207 2208 return out; 2209 }; 2210 2211 /** 2212 * Inverts a mat3 2213 * 2214 * @param {mat3} out the receiving matrix 2215 * @param {mat3} a the source matrix 2216 * @returns {mat3} out 2217 */ 2218 mat3.invert = function(out, a) { 2219 var a00 = a[0], a01 = a[1], a02 = a[2], 2220 a10 = a[3], a11 = a[4], a12 = a[5], 2221 a20 = a[6], a21 = a[7], a22 = a[8], 2222 2223 b01 = a22 * a11 - a12 * a21, 2224 b11 = -a22 * a10 + a12 * a20, 2225 b21 = a21 * a10 - a11 * a20, 2226 2227 // Calculate the determinant 2228 det = a00 * b01 + a01 * b11 + a02 * b21; 2229 2230 if (!det) { 2231 return null; 2232 } 2233 det = 1.0 / det; 2234 2235 out[0] = b01 * det; 2236 out[1] = (-a22 * a01 + a02 * a21) * det; 2237 out[2] = (a12 * a01 - a02 * a11) * det; 2238 out[3] = b11 * det; 2239 out[4] = (a22 * a00 - a02 * a20) * det; 2240 out[5] = (-a12 * a00 + a02 * a10) * det; 2241 out[6] = b21 * det; 2242 out[7] = (-a21 * a00 + a01 * a20) * det; 2243 out[8] = (a11 * a00 - a01 * a10) * det; 2244 return out; 2245 }; 2246 2247 /** 2248 * Calculates the adjugate of a mat3 2249 * 2250 * @param {mat3} out the receiving matrix 2251 * @param {mat3} a the source matrix 2252 * @returns {mat3} out 2253 */ 2254 mat3.adjoint = function(out, a) { 2255 var a00 = a[0], a01 = a[1], a02 = a[2], 2256 a10 = a[3], a11 = a[4], a12 = a[5], 2257 a20 = a[6], a21 = a[7], a22 = a[8]; 2258 2259 out[0] = (a11 * a22 - a12 * a21); 2260 out[1] = (a02 * a21 - a01 * a22); 2261 out[2] = (a01 * a12 - a02 * a11); 2262 out[3] = (a12 * a20 - a10 * a22); 2263 out[4] = (a00 * a22 - a02 * a20); 2264 out[5] = (a02 * a10 - a00 * a12); 2265 out[6] = (a10 * a21 - a11 * a20); 2266 out[7] = (a01 * a20 - a00 * a21); 2267 out[8] = (a00 * a11 - a01 * a10); 2268 return out; 2269 }; 2270 2271 /** 2272 * Calculates the determinant of a mat3 2273 * 2274 * @param {mat3} a the source matrix 2275 * @returns {Number} determinant of a 2276 */ 2277 mat3.determinant = function (a) { 2278 var a00 = a[0], a01 = a[1], a02 = a[2], 2279 a10 = a[3], a11 = a[4], a12 = a[5], 2280 a20 = a[6], a21 = a[7], a22 = a[8]; 2281 2282 return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20); 2283 }; 2284 2285 /** 2286 * Multiplies two mat3's 2287 * 2288 * @param {mat3} out the receiving matrix 2289 * @param {mat3} a the first operand 2290 * @param {mat3} b the second operand 2291 * @returns {mat3} out 2292 */ 2293 mat3.multiply = function (out, a, b) { 2294 var a00 = a[0], a01 = a[1], a02 = a[2], 2295 a10 = a[3], a11 = a[4], a12 = a[5], 2296 a20 = a[6], a21 = a[7], a22 = a[8], 2297 2298 b00 = b[0], b01 = b[1], b02 = b[2], 2299 b10 = b[3], b11 = b[4], b12 = b[5], 2300 b20 = b[6], b21 = b[7], b22 = b[8]; 2301 2302 out[0] = b00 * a00 + b01 * a10 + b02 * a20; 2303 out[1] = b00 * a01 + b01 * a11 + b02 * a21; 2304 out[2] = b00 * a02 + b01 * a12 + b02 * a22; 2305 2306 out[3] = b10 * a00 + b11 * a10 + b12 * a20; 2307 out[4] = b10 * a01 + b11 * a11 + b12 * a21; 2308 out[5] = b10 * a02 + b11 * a12 + b12 * a22; 2309 2310 out[6] = b20 * a00 + b21 * a10 + b22 * a20; 2311 out[7] = b20 * a01 + b21 * a11 + b22 * a21; 2312 out[8] = b20 * a02 + b21 * a12 + b22 * a22; 2313 return out; 2314 }; 2315 2316 /** 2317 * Alias for {@link mat3.multiply} 2318 * @function 2319 */ 2320 mat3.mul = mat3.multiply; 2321 2322 /** 2323 * Translate a mat3 by the given vector 2324 * 2325 * @param {mat3} out the receiving matrix 2326 * @param {mat3} a the matrix to translate 2327 * @param {vec2} v vector to translate by 2328 * @returns {mat3} out 2329 */ 2330 mat3.translate = function(out, a, v) { 2331 var a00 = a[0], a01 = a[1], a02 = a[2], 2332 a10 = a[3], a11 = a[4], a12 = a[5], 2333 a20 = a[6], a21 = a[7], a22 = a[8], 2334 x = v[0], y = v[1]; 2335 2336 out[0] = a00; 2337 out[1] = a01; 2338 out[2] = a02; 2339 2340 out[3] = a10; 2341 out[4] = a11; 2342 out[5] = a12; 2343 2344 out[6] = x * a00 + y * a10 + a20; 2345 out[7] = x * a01 + y * a11 + a21; 2346 out[8] = x * a02 + y * a12 + a22; 2347 return out; 2348 }; 2349 2350 /** 2351 * Rotates a mat3 by the given angle 2352 * 2353 * @param {mat3} out the receiving matrix 2354 * @param {mat3} a the matrix to rotate 2355 * @param {Number} rad the angle to rotate the matrix by 2356 * @returns {mat3} out 2357 */ 2358 mat3.rotate = function (out, a, rad) { 2359 var a00 = a[0], a01 = a[1], a02 = a[2], 2360 a10 = a[3], a11 = a[4], a12 = a[5], 2361 a20 = a[6], a21 = a[7], a22 = a[8], 2362 2363 s = Math.sin(rad), 2364 c = Math.cos(rad); 2365 2366 out[0] = c * a00 + s * a10; 2367 out[1] = c * a01 + s * a11; 2368 out[2] = c * a02 + s * a12; 2369 2370 out[3] = c * a10 - s * a00; 2371 out[4] = c * a11 - s * a01; 2372 out[5] = c * a12 - s * a02; 2373 2374 out[6] = a20; 2375 out[7] = a21; 2376 out[8] = a22; 2377 return out; 2378 }; 2379 2380 /** 2381 * Scales the mat3 by the dimensions in the given vec2 2382 * 2383 * @param {mat3} out the receiving matrix 2384 * @param {mat3} a the matrix to rotate 2385 * @param {vec2} v the vec2 to scale the matrix by 2386 * @returns {mat3} out 2387 **/ 2388 mat3.scale = function(out, a, v) { 2389 var x = v[0], y = v[2]; 2390 2391 out[0] = x * a[0]; 2392 out[1] = x * a[1]; 2393 out[2] = x * a[2]; 2394 2395 out[3] = y * a[3]; 2396 out[4] = y * a[4]; 2397 out[5] = y * a[5]; 2398 2399 out[6] = a[6]; 2400 out[7] = a[7]; 2401 out[8] = a[8]; 2402 return out; 2403 }; 2404 2405 /** 2406 * Copies the values from a mat2d into a mat3 2407 * 2408 * @param {mat3} out the receiving matrix 2409 * @param {mat3} a the matrix to rotate 2410 * @param {vec2} v the vec2 to scale the matrix by 2411 * @returns {mat3} out 2412 **/ 2413 mat3.fromMat2d = function(out, a) { 2414 out[0] = a[0]; 2415 out[1] = a[1]; 2416 out[2] = 0; 2417 2418 out[3] = a[2]; 2419 out[4] = a[3]; 2420 out[5] = 0; 2421 2422 out[6] = a[4]; 2423 out[7] = a[5]; 2424 out[8] = 1; 2425 return out; 2426 }; 2427 2428 /** 2429 * Calculates a 3x3 matrix from the given quaternion 2430 * 2431 * @param {mat3} out mat3 receiving operation result 2432 * @param {quat} q Quaternion to create matrix from 2433 * 2434 * @returns {mat3} out 2435 */ 2436 mat3.fromQuat = function (out, q) { 2437 var x = q[0], y = q[1], z = q[2], w = q[3], 2438 x2 = x + x, 2439 y2 = y + y, 2440 z2 = z + z, 2441 2442 xx = x * x2, 2443 xy = x * y2, 2444 xz = x * z2, 2445 yy = y * y2, 2446 yz = y * z2, 2447 zz = z * z2, 2448 wx = w * x2, 2449 wy = w * y2, 2450 wz = w * z2; 2451 2452 out[0] = 1 - (yy + zz); 2453 out[1] = xy + wz; 2454 out[2] = xz - wy; 2455 2456 out[3] = xy - wz; 2457 out[4] = 1 - (xx + zz); 2458 out[5] = yz + wx; 2459 2460 out[6] = xz + wy; 2461 out[7] = yz - wx; 2462 out[8] = 1 - (xx + yy); 2463 2464 return out; 2465 }; 2466 2467 /** 2468 * Returns a string representation of a mat3 2469 * 2470 * @param {mat3} mat matrix to represent as a string 2471 * @returns {String} string representation of the matrix 2472 */ 2473 mat3.str = function (a) { 2474 return 'mat3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + 2475 a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + 2476 a[6] + ', ' + a[7] + ', ' + a[8] + ')'; 2477 }; 2478 2479 if(typeof(exports) !== 'undefined') { 2480 exports.mat3 = mat3; 2481 } 2482 ; 2483 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 2484 2485 Redistribution and use in source and binary forms, with or without modification, 2486 are permitted provided that the following conditions are met: 2487 2488 * Redistributions of source code must retain the above copyright notice, this 2489 list of conditions and the following disclaimer. 2490 * Redistributions in binary form must reproduce the above copyright notice, 2491 this list of conditions and the following disclaimer in the documentation 2492 and/or other materials provided with the distribution. 2493 2494 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 2495 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 2496 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 2497 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 2498 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 2499 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 2500 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 2501 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 2502 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 2503 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 2504 2505 /** 2506 * @class 4x4 Matrix 2507 * @name mat4 2508 */ 2509 2510 var mat4 = {}; 2511 2512 /** 2513 * Creates a new identity mat4 2514 * 2515 * @returns {mat4} a new 4x4 matrix 2516 */ 2517 mat4.create = function() { 2518 var out = new GLMAT_ARRAY_TYPE(16); 2519 out[0] = 1; 2520 out[1] = 0; 2521 out[2] = 0; 2522 out[3] = 0; 2523 out[4] = 0; 2524 out[5] = 1; 2525 out[6] = 0; 2526 out[7] = 0; 2527 out[8] = 0; 2528 out[9] = 0; 2529 out[10] = 1; 2530 out[11] = 0; 2531 out[12] = 0; 2532 out[13] = 0; 2533 out[14] = 0; 2534 out[15] = 1; 2535 return out; 2536 }; 2537 2538 /** 2539 * Creates a new mat4 initialized with values from an existing matrix 2540 * 2541 * @param {mat4} a matrix to clone 2542 * @returns {mat4} a new 4x4 matrix 2543 */ 2544 mat4.clone = function(a) { 2545 var out = new GLMAT_ARRAY_TYPE(16); 2546 out[0] = a[0]; 2547 out[1] = a[1]; 2548 out[2] = a[2]; 2549 out[3] = a[3]; 2550 out[4] = a[4]; 2551 out[5] = a[5]; 2552 out[6] = a[6]; 2553 out[7] = a[7]; 2554 out[8] = a[8]; 2555 out[9] = a[9]; 2556 out[10] = a[10]; 2557 out[11] = a[11]; 2558 out[12] = a[12]; 2559 out[13] = a[13]; 2560 out[14] = a[14]; 2561 out[15] = a[15]; 2562 return out; 2563 }; 2564 2565 /** 2566 * Copy the values from one mat4 to another 2567 * 2568 * @param {mat4} out the receiving matrix 2569 * @param {mat4} a the source matrix 2570 * @returns {mat4} out 2571 */ 2572 mat4.copy = function(out, a) { 2573 out[0] = a[0]; 2574 out[1] = a[1]; 2575 out[2] = a[2]; 2576 out[3] = a[3]; 2577 out[4] = a[4]; 2578 out[5] = a[5]; 2579 out[6] = a[6]; 2580 out[7] = a[7]; 2581 out[8] = a[8]; 2582 out[9] = a[9]; 2583 out[10] = a[10]; 2584 out[11] = a[11]; 2585 out[12] = a[12]; 2586 out[13] = a[13]; 2587 out[14] = a[14]; 2588 out[15] = a[15]; 2589 return out; 2590 }; 2591 2592 /** 2593 * Set a mat4 to the identity matrix 2594 * 2595 * @param {mat4} out the receiving matrix 2596 * @returns {mat4} out 2597 */ 2598 mat4.identity = function(out) { 2599 out[0] = 1; 2600 out[1] = 0; 2601 out[2] = 0; 2602 out[3] = 0; 2603 out[4] = 0; 2604 out[5] = 1; 2605 out[6] = 0; 2606 out[7] = 0; 2607 out[8] = 0; 2608 out[9] = 0; 2609 out[10] = 1; 2610 out[11] = 0; 2611 out[12] = 0; 2612 out[13] = 0; 2613 out[14] = 0; 2614 out[15] = 1; 2615 return out; 2616 }; 2617 2618 /** 2619 * Transpose the values of a mat4 2620 * 2621 * @param {mat4} out the receiving matrix 2622 * @param {mat4} a the source matrix 2623 * @returns {mat4} out 2624 */ 2625 mat4.transpose = function(out, a) { 2626 // If we are transposing ourselves we can skip a few steps but have to cache some values 2627 if (out === a) { 2628 var a01 = a[1], a02 = a[2], a03 = a[3], 2629 a12 = a[6], a13 = a[7], 2630 a23 = a[11]; 2631 2632 out[1] = a[4]; 2633 out[2] = a[8]; 2634 out[3] = a[12]; 2635 out[4] = a01; 2636 out[6] = a[9]; 2637 out[7] = a[13]; 2638 out[8] = a02; 2639 out[9] = a12; 2640 out[11] = a[14]; 2641 out[12] = a03; 2642 out[13] = a13; 2643 out[14] = a23; 2644 } else { 2645 out[0] = a[0]; 2646 out[1] = a[4]; 2647 out[2] = a[8]; 2648 out[3] = a[12]; 2649 out[4] = a[1]; 2650 out[5] = a[5]; 2651 out[6] = a[9]; 2652 out[7] = a[13]; 2653 out[8] = a[2]; 2654 out[9] = a[6]; 2655 out[10] = a[10]; 2656 out[11] = a[14]; 2657 out[12] = a[3]; 2658 out[13] = a[7]; 2659 out[14] = a[11]; 2660 out[15] = a[15]; 2661 } 2662 2663 return out; 2664 }; 2665 2666 /** 2667 * Inverts a mat4 2668 * 2669 * @param {mat4} out the receiving matrix 2670 * @param {mat4} a the source matrix 2671 * @returns {mat4} out 2672 */ 2673 mat4.invert = function(out, a) { 2674 var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3], 2675 a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7], 2676 a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11], 2677 a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15], 2678 2679 b00 = a00 * a11 - a01 * a10, 2680 b01 = a00 * a12 - a02 * a10, 2681 b02 = a00 * a13 - a03 * a10, 2682 b03 = a01 * a12 - a02 * a11, 2683 b04 = a01 * a13 - a03 * a11, 2684 b05 = a02 * a13 - a03 * a12, 2685 b06 = a20 * a31 - a21 * a30, 2686 b07 = a20 * a32 - a22 * a30, 2687 b08 = a20 * a33 - a23 * a30, 2688 b09 = a21 * a32 - a22 * a31, 2689 b10 = a21 * a33 - a23 * a31, 2690 b11 = a22 * a33 - a23 * a32, 2691 2692 // Calculate the determinant 2693 det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; 2694 2695 if (!det) { 2696 return null; 2697 } 2698 det = 1.0 / det; 2699 2700 out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; 2701 out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; 2702 out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; 2703 out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; 2704 out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; 2705 out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; 2706 out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; 2707 out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; 2708 out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; 2709 out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; 2710 out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; 2711 out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; 2712 out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; 2713 out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; 2714 out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; 2715 out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; 2716 2717 return out; 2718 }; 2719 2720 /** 2721 * Calculates the adjugate of a mat4 2722 * 2723 * @param {mat4} out the receiving matrix 2724 * @param {mat4} a the source matrix 2725 * @returns {mat4} out 2726 */ 2727 mat4.adjoint = function(out, a) { 2728 var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3], 2729 a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7], 2730 a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11], 2731 a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15]; 2732 2733 out[0] = (a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22)); 2734 out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22)); 2735 out[2] = (a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12)); 2736 out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12)); 2737 out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22)); 2738 out[5] = (a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22)); 2739 out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12)); 2740 out[7] = (a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12)); 2741 out[8] = (a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21)); 2742 out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21)); 2743 out[10] = (a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11)); 2744 out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11)); 2745 out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21)); 2746 out[13] = (a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21)); 2747 out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11)); 2748 out[15] = (a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11)); 2749 return out; 2750 }; 2751 2752 /** 2753 * Calculates the determinant of a mat4 2754 * 2755 * @param {mat4} a the source matrix 2756 * @returns {Number} determinant of a 2757 */ 2758 mat4.determinant = function (a) { 2759 var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3], 2760 a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7], 2761 a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11], 2762 a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15], 2763 2764 b00 = a00 * a11 - a01 * a10, 2765 b01 = a00 * a12 - a02 * a10, 2766 b02 = a00 * a13 - a03 * a10, 2767 b03 = a01 * a12 - a02 * a11, 2768 b04 = a01 * a13 - a03 * a11, 2769 b05 = a02 * a13 - a03 * a12, 2770 b06 = a20 * a31 - a21 * a30, 2771 b07 = a20 * a32 - a22 * a30, 2772 b08 = a20 * a33 - a23 * a30, 2773 b09 = a21 * a32 - a22 * a31, 2774 b10 = a21 * a33 - a23 * a31, 2775 b11 = a22 * a33 - a23 * a32; 2776 2777 // Calculate the determinant 2778 return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; 2779 }; 2780 2781 /** 2782 * Multiplies two mat4's 2783 * 2784 * @param {mat4} out the receiving matrix 2785 * @param {mat4} a the first operand 2786 * @param {mat4} b the second operand 2787 * @returns {mat4} out 2788 */ 2789 mat4.multiply = function (out, a, b) { 2790 var a00 = a[0], a01 = a[1], a02 = a[2], a03 = a[3], 2791 a10 = a[4], a11 = a[5], a12 = a[6], a13 = a[7], 2792 a20 = a[8], a21 = a[9], a22 = a[10], a23 = a[11], 2793 a30 = a[12], a31 = a[13], a32 = a[14], a33 = a[15]; 2794 2795 // Cache only the current line of the second matrix 2796 var b0 = b[0], b1 = b[1], b2 = b[2], b3 = b[3]; 2797 out[0] = b0*a00 + b1*a10 + b2*a20 + b3*a30; 2798 out[1] = b0*a01 + b1*a11 + b2*a21 + b3*a31; 2799 out[2] = b0*a02 + b1*a12 + b2*a22 + b3*a32; 2800 out[3] = b0*a03 + b1*a13 + b2*a23 + b3*a33; 2801 2802 b0 = b[4]; b1 = b[5]; b2 = b[6]; b3 = b[7]; 2803 out[4] = b0*a00 + b1*a10 + b2*a20 + b3*a30; 2804 out[5] = b0*a01 + b1*a11 + b2*a21 + b3*a31; 2805 out[6] = b0*a02 + b1*a12 + b2*a22 + b3*a32; 2806 out[7] = b0*a03 + b1*a13 + b2*a23 + b3*a33; 2807 2808 b0 = b[8]; b1 = b[9]; b2 = b[10]; b3 = b[11]; 2809 out[8] = b0*a00 + b1*a10 + b2*a20 + b3*a30; 2810 out[9] = b0*a01 + b1*a11 + b2*a21 + b3*a31; 2811 out[10] = b0*a02 + b1*a12 + b2*a22 + b3*a32; 2812 out[11] = b0*a03 + b1*a13 + b2*a23 + b3*a33; 2813 2814 b0 = b[12]; b1 = b[13]; b2 = b[14]; b3 = b[15]; 2815 out[12] = b0*a00 + b1*a10 + b2*a20 + b3*a30; 2816 out[13] = b0*a01 + b1*a11 + b2*a21 + b3*a31; 2817 out[14] = b0*a02 + b1*a12 + b2*a22 + b3*a32; 2818 out[15] = b0*a03 + b1*a13 + b2*a23 + b3*a33; 2819 return out; 2820 }; 2821 2822 /** 2823 * Alias for {@link mat4.multiply} 2824 * @function 2825 */ 2826 mat4.mul = mat4.multiply; 2827 2828 /** 2829 * Translate a mat4 by the given vector 2830 * 2831 * @param {mat4} out the receiving matrix 2832 * @param {mat4} a the matrix to translate 2833 * @param {vec3} v vector to translate by 2834 * @returns {mat4} out 2835 */ 2836 mat4.translate = function (out, a, v) { 2837 var x = v[0], y = v[1], z = v[2], 2838 a00, a01, a02, a03, 2839 a10, a11, a12, a13, 2840 a20, a21, a22, a23; 2841 2842 if (a === out) { 2843 out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; 2844 out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; 2845 out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; 2846 out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; 2847 } else { 2848 a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3]; 2849 a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7]; 2850 a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11]; 2851 2852 out[0] = a00; out[1] = a01; out[2] = a02; out[3] = a03; 2853 out[4] = a10; out[5] = a11; out[6] = a12; out[7] = a13; 2854 out[8] = a20; out[9] = a21; out[10] = a22; out[11] = a23; 2855 2856 out[12] = a00 * x + a10 * y + a20 * z + a[12]; 2857 out[13] = a01 * x + a11 * y + a21 * z + a[13]; 2858 out[14] = a02 * x + a12 * y + a22 * z + a[14]; 2859 out[15] = a03 * x + a13 * y + a23 * z + a[15]; 2860 } 2861 2862 return out; 2863 }; 2864 2865 /** 2866 * Scales the mat4 by the dimensions in the given vec3 2867 * 2868 * @param {mat4} out the receiving matrix 2869 * @param {mat4} a the matrix to scale 2870 * @param {vec3} v the vec3 to scale the matrix by 2871 * @returns {mat4} out 2872 **/ 2873 mat4.scale = function(out, a, v) { 2874 var x = v[0], y = v[1], z = v[2]; 2875 2876 out[0] = a[0] * x; 2877 out[1] = a[1] * x; 2878 out[2] = a[2] * x; 2879 out[3] = a[3] * x; 2880 out[4] = a[4] * y; 2881 out[5] = a[5] * y; 2882 out[6] = a[6] * y; 2883 out[7] = a[7] * y; 2884 out[8] = a[8] * z; 2885 out[9] = a[9] * z; 2886 out[10] = a[10] * z; 2887 out[11] = a[11] * z; 2888 out[12] = a[12]; 2889 out[13] = a[13]; 2890 out[14] = a[14]; 2891 out[15] = a[15]; 2892 return out; 2893 }; 2894 2895 /** 2896 * Rotates a mat4 by the given angle 2897 * 2898 * @param {mat4} out the receiving matrix 2899 * @param {mat4} a the matrix to rotate 2900 * @param {Number} rad the angle to rotate the matrix by 2901 * @param {vec3} axis the axis to rotate around 2902 * @returns {mat4} out 2903 */ 2904 mat4.rotate = function (out, a, rad, axis) { 2905 var x = axis[0], y = axis[1], z = axis[2], 2906 len = Math.sqrt(x * x + y * y + z * z), 2907 s, c, t, 2908 a00, a01, a02, a03, 2909 a10, a11, a12, a13, 2910 a20, a21, a22, a23, 2911 b00, b01, b02, 2912 b10, b11, b12, 2913 b20, b21, b22; 2914 2915 if (Math.abs(len) < GLMAT_EPSILON) { return null; } 2916 2917 len = 1 / len; 2918 x *= len; 2919 y *= len; 2920 z *= len; 2921 2922 s = Math.sin(rad); 2923 c = Math.cos(rad); 2924 t = 1 - c; 2925 2926 a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3]; 2927 a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7]; 2928 a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11]; 2929 2930 // Construct the elements of the rotation matrix 2931 b00 = x * x * t + c; b01 = y * x * t + z * s; b02 = z * x * t - y * s; 2932 b10 = x * y * t - z * s; b11 = y * y * t + c; b12 = z * y * t + x * s; 2933 b20 = x * z * t + y * s; b21 = y * z * t - x * s; b22 = z * z * t + c; 2934 2935 // Perform rotation-specific matrix multiplication 2936 out[0] = a00 * b00 + a10 * b01 + a20 * b02; 2937 out[1] = a01 * b00 + a11 * b01 + a21 * b02; 2938 out[2] = a02 * b00 + a12 * b01 + a22 * b02; 2939 out[3] = a03 * b00 + a13 * b01 + a23 * b02; 2940 out[4] = a00 * b10 + a10 * b11 + a20 * b12; 2941 out[5] = a01 * b10 + a11 * b11 + a21 * b12; 2942 out[6] = a02 * b10 + a12 * b11 + a22 * b12; 2943 out[7] = a03 * b10 + a13 * b11 + a23 * b12; 2944 out[8] = a00 * b20 + a10 * b21 + a20 * b22; 2945 out[9] = a01 * b20 + a11 * b21 + a21 * b22; 2946 out[10] = a02 * b20 + a12 * b21 + a22 * b22; 2947 out[11] = a03 * b20 + a13 * b21 + a23 * b22; 2948 2949 if (a !== out) { // If the source and destination differ, copy the unchanged last row 2950 out[12] = a[12]; 2951 out[13] = a[13]; 2952 out[14] = a[14]; 2953 out[15] = a[15]; 2954 } 2955 return out; 2956 }; 2957 2958 /** 2959 * Rotates a matrix by the given angle around the X axis 2960 * 2961 * @param {mat4} out the receiving matrix 2962 * @param {mat4} a the matrix to rotate 2963 * @param {Number} rad the angle to rotate the matrix by 2964 * @returns {mat4} out 2965 */ 2966 mat4.rotateX = function (out, a, rad) { 2967 var s = Math.sin(rad), 2968 c = Math.cos(rad), 2969 a10 = a[4], 2970 a11 = a[5], 2971 a12 = a[6], 2972 a13 = a[7], 2973 a20 = a[8], 2974 a21 = a[9], 2975 a22 = a[10], 2976 a23 = a[11]; 2977 2978 if (a !== out) { // If the source and destination differ, copy the unchanged rows 2979 out[0] = a[0]; 2980 out[1] = a[1]; 2981 out[2] = a[2]; 2982 out[3] = a[3]; 2983 out[12] = a[12]; 2984 out[13] = a[13]; 2985 out[14] = a[14]; 2986 out[15] = a[15]; 2987 } 2988 2989 // Perform axis-specific matrix multiplication 2990 out[4] = a10 * c + a20 * s; 2991 out[5] = a11 * c + a21 * s; 2992 out[6] = a12 * c + a22 * s; 2993 out[7] = a13 * c + a23 * s; 2994 out[8] = a20 * c - a10 * s; 2995 out[9] = a21 * c - a11 * s; 2996 out[10] = a22 * c - a12 * s; 2997 out[11] = a23 * c - a13 * s; 2998 return out; 2999 }; 3000 3001 /** 3002 * Rotates a matrix by the given angle around the Y axis 3003 * 3004 * @param {mat4} out the receiving matrix 3005 * @param {mat4} a the matrix to rotate 3006 * @param {Number} rad the angle to rotate the matrix by 3007 * @returns {mat4} out 3008 */ 3009 mat4.rotateY = function (out, a, rad) { 3010 var s = Math.sin(rad), 3011 c = Math.cos(rad), 3012 a00 = a[0], 3013 a01 = a[1], 3014 a02 = a[2], 3015 a03 = a[3], 3016 a20 = a[8], 3017 a21 = a[9], 3018 a22 = a[10], 3019 a23 = a[11]; 3020 3021 if (a !== out) { // If the source and destination differ, copy the unchanged rows 3022 out[4] = a[4]; 3023 out[5] = a[5]; 3024 out[6] = a[6]; 3025 out[7] = a[7]; 3026 out[12] = a[12]; 3027 out[13] = a[13]; 3028 out[14] = a[14]; 3029 out[15] = a[15]; 3030 } 3031 3032 // Perform axis-specific matrix multiplication 3033 out[0] = a00 * c - a20 * s; 3034 out[1] = a01 * c - a21 * s; 3035 out[2] = a02 * c - a22 * s; 3036 out[3] = a03 * c - a23 * s; 3037 out[8] = a00 * s + a20 * c; 3038 out[9] = a01 * s + a21 * c; 3039 out[10] = a02 * s + a22 * c; 3040 out[11] = a03 * s + a23 * c; 3041 return out; 3042 }; 3043 3044 /** 3045 * Rotates a matrix by the given angle around the Z axis 3046 * 3047 * @param {mat4} out the receiving matrix 3048 * @param {mat4} a the matrix to rotate 3049 * @param {Number} rad the angle to rotate the matrix by 3050 * @returns {mat4} out 3051 */ 3052 mat4.rotateZ = function (out, a, rad) { 3053 var s = Math.sin(rad), 3054 c = Math.cos(rad), 3055 a00 = a[0], 3056 a01 = a[1], 3057 a02 = a[2], 3058 a03 = a[3], 3059 a10 = a[4], 3060 a11 = a[5], 3061 a12 = a[6], 3062 a13 = a[7]; 3063 3064 if (a !== out) { // If the source and destination differ, copy the unchanged last row 3065 out[8] = a[8]; 3066 out[9] = a[9]; 3067 out[10] = a[10]; 3068 out[11] = a[11]; 3069 out[12] = a[12]; 3070 out[13] = a[13]; 3071 out[14] = a[14]; 3072 out[15] = a[15]; 3073 } 3074 3075 // Perform axis-specific matrix multiplication 3076 out[0] = a00 * c + a10 * s; 3077 out[1] = a01 * c + a11 * s; 3078 out[2] = a02 * c + a12 * s; 3079 out[3] = a03 * c + a13 * s; 3080 out[4] = a10 * c - a00 * s; 3081 out[5] = a11 * c - a01 * s; 3082 out[6] = a12 * c - a02 * s; 3083 out[7] = a13 * c - a03 * s; 3084 return out; 3085 }; 3086 3087 /** 3088 * Creates a matrix from a quaternion rotation and vector translation 3089 * This is equivalent to (but much faster than): 3090 * 3091 * mat4.identity(dest); 3092 * mat4.translate(dest, vec); 3093 * var quatMat = mat4.create(); 3094 * quat4.toMat4(quat, quatMat); 3095 * mat4.multiply(dest, quatMat); 3096 * 3097 * @param {mat4} out mat4 receiving operation result 3098 * @param {quat4} q Rotation quaternion 3099 * @param {vec3} v Translation vector 3100 * @returns {mat4} out 3101 */ 3102 mat4.fromRotationTranslation = function (out, q, v) { 3103 // Quaternion math 3104 var x = q[0], y = q[1], z = q[2], w = q[3], 3105 x2 = x + x, 3106 y2 = y + y, 3107 z2 = z + z, 3108 3109 xx = x * x2, 3110 xy = x * y2, 3111 xz = x * z2, 3112 yy = y * y2, 3113 yz = y * z2, 3114 zz = z * z2, 3115 wx = w * x2, 3116 wy = w * y2, 3117 wz = w * z2; 3118 3119 out[0] = 1 - (yy + zz); 3120 out[1] = xy + wz; 3121 out[2] = xz - wy; 3122 out[3] = 0; 3123 out[4] = xy - wz; 3124 out[5] = 1 - (xx + zz); 3125 out[6] = yz + wx; 3126 out[7] = 0; 3127 out[8] = xz + wy; 3128 out[9] = yz - wx; 3129 out[10] = 1 - (xx + yy); 3130 out[11] = 0; 3131 out[12] = v[0]; 3132 out[13] = v[1]; 3133 out[14] = v[2]; 3134 out[15] = 1; 3135 3136 return out; 3137 }; 3138 3139 /** 3140 * Calculates a 4x4 matrix from the given quaternion 3141 * 3142 * @param {mat4} out mat4 receiving operation result 3143 * @param {quat} q Quaternion to create matrix from 3144 * 3145 * @returns {mat4} out 3146 */ 3147 mat4.fromQuat = function (out, q) { 3148 var x = q[0], y = q[1], z = q[2], w = q[3], 3149 x2 = x + x, 3150 y2 = y + y, 3151 z2 = z + z, 3152 3153 xx = x * x2, 3154 xy = x * y2, 3155 xz = x * z2, 3156 yy = y * y2, 3157 yz = y * z2, 3158 zz = z * z2, 3159 wx = w * x2, 3160 wy = w * y2, 3161 wz = w * z2; 3162 3163 out[0] = 1 - (yy + zz); 3164 out[1] = xy + wz; 3165 out[2] = xz - wy; 3166 out[3] = 0; 3167 3168 out[4] = xy - wz; 3169 out[5] = 1 - (xx + zz); 3170 out[6] = yz + wx; 3171 out[7] = 0; 3172 3173 out[8] = xz + wy; 3174 out[9] = yz - wx; 3175 out[10] = 1 - (xx + yy); 3176 out[11] = 0; 3177 3178 out[12] = 0; 3179 out[13] = 0; 3180 out[14] = 0; 3181 out[15] = 1; 3182 3183 return out; 3184 }; 3185 3186 /** 3187 * Generates a frustum matrix with the given bounds 3188 * 3189 * @param {mat4} out mat4 frustum matrix will be written into 3190 * @param {Number} left Left bound of the frustum 3191 * @param {Number} right Right bound of the frustum 3192 * @param {Number} bottom Bottom bound of the frustum 3193 * @param {Number} top Top bound of the frustum 3194 * @param {Number} near Near bound of the frustum 3195 * @param {Number} far Far bound of the frustum 3196 * @returns {mat4} out 3197 */ 3198 mat4.frustum = function (out, left, right, bottom, top, near, far) { 3199 var rl = 1 / (right - left), 3200 tb = 1 / (top - bottom), 3201 nf = 1 / (near - far); 3202 out[0] = (near * 2) * rl; 3203 out[1] = 0; 3204 out[2] = 0; 3205 out[3] = 0; 3206 out[4] = 0; 3207 out[5] = (near * 2) * tb; 3208 out[6] = 0; 3209 out[7] = 0; 3210 out[8] = (right + left) * rl; 3211 out[9] = (top + bottom) * tb; 3212 out[10] = (far + near) * nf; 3213 out[11] = -1; 3214 out[12] = 0; 3215 out[13] = 0; 3216 out[14] = (far * near * 2) * nf; 3217 out[15] = 0; 3218 return out; 3219 }; 3220 3221 /** 3222 * Generates a perspective projection matrix with the given bounds 3223 * 3224 * @param {mat4} out mat4 frustum matrix will be written into 3225 * @param {number} fovy Vertical field of view in radians 3226 * @param {number} aspect Aspect ratio. typically viewport width/height 3227 * @param {number} near Near bound of the frustum 3228 * @param {number} far Far bound of the frustum 3229 * @returns {mat4} out 3230 */ 3231 mat4.perspective = function (out, fovy, aspect, near, far) { 3232 var f = 1.0 / Math.tan(fovy / 2), 3233 nf = 1 / (near - far); 3234 out[0] = f / aspect; 3235 out[1] = 0; 3236 out[2] = 0; 3237 out[3] = 0; 3238 out[4] = 0; 3239 out[5] = f; 3240 out[6] = 0; 3241 out[7] = 0; 3242 out[8] = 0; 3243 out[9] = 0; 3244 out[10] = (far + near) * nf; 3245 out[11] = -1; 3246 out[12] = 0; 3247 out[13] = 0; 3248 out[14] = (2 * far * near) * nf; 3249 out[15] = 0; 3250 return out; 3251 }; 3252 3253 /** 3254 * Generates a orthogonal projection matrix with the given bounds 3255 * 3256 * @param {mat4} out mat4 frustum matrix will be written into 3257 * @param {number} left Left bound of the frustum 3258 * @param {number} right Right bound of the frustum 3259 * @param {number} bottom Bottom bound of the frustum 3260 * @param {number} top Top bound of the frustum 3261 * @param {number} near Near bound of the frustum 3262 * @param {number} far Far bound of the frustum 3263 * @returns {mat4} out 3264 */ 3265 mat4.ortho = function (out, left, right, bottom, top, near, far) { 3266 var lr = 1 / (left - right), 3267 bt = 1 / (bottom - top), 3268 nf = 1 / (near - far); 3269 out[0] = -2 * lr; 3270 out[1] = 0; 3271 out[2] = 0; 3272 out[3] = 0; 3273 out[4] = 0; 3274 out[5] = -2 * bt; 3275 out[6] = 0; 3276 out[7] = 0; 3277 out[8] = 0; 3278 out[9] = 0; 3279 out[10] = 2 * nf; 3280 out[11] = 0; 3281 out[12] = (left + right) * lr; 3282 out[13] = (top + bottom) * bt; 3283 out[14] = (far + near) * nf; 3284 out[15] = 1; 3285 return out; 3286 }; 3287 3288 /** 3289 * Generates a look-at matrix with the given eye position, focal point, and up axis 3290 * 3291 * @param {mat4} out mat4 frustum matrix will be written into 3292 * @param {vec3} eye Position of the viewer 3293 * @param {vec3} center Point the viewer is looking at 3294 * @param {vec3} up vec3 pointing up 3295 * @returns {mat4} out 3296 */ 3297 mat4.lookAt = function (out, eye, center, up) { 3298 var x0, x1, x2, y0, y1, y2, z0, z1, z2, len, 3299 eyex = eye[0], 3300 eyey = eye[1], 3301 eyez = eye[2], 3302 upx = up[0], 3303 upy = up[1], 3304 upz = up[2], 3305 centerx = center[0], 3306 centery = center[1], 3307 centerz = center[2]; 3308 3309 if (Math.abs(eyex - centerx) < GLMAT_EPSILON && 3310 Math.abs(eyey - centery) < GLMAT_EPSILON && 3311 Math.abs(eyez - centerz) < GLMAT_EPSILON) { 3312 return mat4.identity(out); 3313 } 3314 3315 z0 = eyex - centerx; 3316 z1 = eyey - centery; 3317 z2 = eyez - centerz; 3318 3319 len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); 3320 z0 *= len; 3321 z1 *= len; 3322 z2 *= len; 3323 3324 x0 = upy * z2 - upz * z1; 3325 x1 = upz * z0 - upx * z2; 3326 x2 = upx * z1 - upy * z0; 3327 len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); 3328 if (!len) { 3329 x0 = 0; 3330 x1 = 0; 3331 x2 = 0; 3332 } else { 3333 len = 1 / len; 3334 x0 *= len; 3335 x1 *= len; 3336 x2 *= len; 3337 } 3338 3339 y0 = z1 * x2 - z2 * x1; 3340 y1 = z2 * x0 - z0 * x2; 3341 y2 = z0 * x1 - z1 * x0; 3342 3343 len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); 3344 if (!len) { 3345 y0 = 0; 3346 y1 = 0; 3347 y2 = 0; 3348 } else { 3349 len = 1 / len; 3350 y0 *= len; 3351 y1 *= len; 3352 y2 *= len; 3353 } 3354 3355 out[0] = x0; 3356 out[1] = y0; 3357 out[2] = z0; 3358 out[3] = 0; 3359 out[4] = x1; 3360 out[5] = y1; 3361 out[6] = z1; 3362 out[7] = 0; 3363 out[8] = x2; 3364 out[9] = y2; 3365 out[10] = z2; 3366 out[11] = 0; 3367 out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); 3368 out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); 3369 out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); 3370 out[15] = 1; 3371 3372 return out; 3373 }; 3374 3375 /** 3376 * Returns a string representation of a mat4 3377 * 3378 * @param {mat4} mat matrix to represent as a string 3379 * @returns {String} string representation of the matrix 3380 */ 3381 mat4.str = function (a) { 3382 return 'mat4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + 3383 a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' + 3384 a[8] + ', ' + a[9] + ', ' + a[10] + ', ' + a[11] + ', ' + 3385 a[12] + ', ' + a[13] + ', ' + a[14] + ', ' + a[15] + ')'; 3386 }; 3387 3388 if(typeof(exports) !== 'undefined') { 3389 exports.mat4 = mat4; 3390 } 3391 ; 3392 /* Copyright (c) 2013, Brandon Jones, Colin MacKenzie IV. All rights reserved. 3393 3394 Redistribution and use in source and binary forms, with or without modification, 3395 are permitted provided that the following conditions are met: 3396 3397 * Redistributions of source code must retain the above copyright notice, this 3398 list of conditions and the following disclaimer. 3399 * Redistributions in binary form must reproduce the above copyright notice, 3400 this list of conditions and the following disclaimer in the documentation 3401 and/or other materials provided with the distribution. 3402 3403 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 3404 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 3405 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 3406 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR 3407 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 3408 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 3409 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 3410 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 3411 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 3412 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ 3413 3414 /** 3415 * @class Quaternion 3416 * @name quat 3417 */ 3418 3419 var quat = {}; 3420 3421 /** 3422 * Creates a new identity quat 3423 * 3424 * @returns {quat} a new quaternion 3425 */ 3426 quat.create = function() { 3427 var out = new GLMAT_ARRAY_TYPE(4); 3428 out[0] = 0; 3429 out[1] = 0; 3430 out[2] = 0; 3431 out[3] = 1; 3432 return out; 3433 }; 3434 3435 /** 3436 * Creates a new quat initialized with values from an existing quaternion 3437 * 3438 * @param {quat} a quaternion to clone 3439 * @returns {quat} a new quaternion 3440 * @function 3441 */ 3442 quat.clone = vec4.clone; 3443 3444 /** 3445 * Creates a new quat initialized with the given values 3446 * 3447 * @param {Number} x X component 3448 * @param {Number} y Y component 3449 * @param {Number} z Z component 3450 * @param {Number} w W component 3451 * @returns {quat} a new quaternion 3452 * @function 3453 */ 3454 quat.fromValues = vec4.fromValues; 3455 3456 /** 3457 * Copy the values from one quat to another 3458 * 3459 * @param {quat} out the receiving quaternion 3460 * @param {quat} a the source quaternion 3461 * @returns {quat} out 3462 * @function 3463 */ 3464 quat.copy = vec4.copy; 3465 3466 /** 3467 * Set the components of a quat to the given values 3468 * 3469 * @param {quat} out the receiving quaternion 3470 * @param {Number} x X component 3471 * @param {Number} y Y component 3472 * @param {Number} z Z component 3473 * @param {Number} w W component 3474 * @returns {quat} out 3475 * @function 3476 */ 3477 quat.set = vec4.set; 3478 3479 /** 3480 * Set a quat to the identity quaternion 3481 * 3482 * @param {quat} out the receiving quaternion 3483 * @returns {quat} out 3484 */ 3485 quat.identity = function(out) { 3486 out[0] = 0; 3487 out[1] = 0; 3488 out[2] = 0; 3489 out[3] = 1; 3490 return out; 3491 }; 3492 3493 /** 3494 * Sets a quat from the given angle and rotation axis, 3495 * then returns it. 3496 * 3497 * @param {quat} out the receiving quaternion 3498 * @param {vec3} axis the axis around which to rotate 3499 * @param {Number} rad the angle in radians 3500 * @returns {quat} out 3501 **/ 3502 quat.setAxisAngle = function(out, axis, rad) { 3503 rad = rad * 0.5; 3504 var s = Math.sin(rad); 3505 out[0] = s * axis[0]; 3506 out[1] = s * axis[1]; 3507 out[2] = s * axis[2]; 3508 out[3] = Math.cos(rad); 3509 return out; 3510 }; 3511 3512 /** 3513 * Adds two quat's 3514 * 3515 * @param {quat} out the receiving quaternion 3516 * @param {quat} a the first operand 3517 * @param {quat} b the second operand 3518 * @returns {quat} out 3519 * @function 3520 */ 3521 quat.add = vec4.add; 3522 3523 /** 3524 * Multiplies two quat's 3525 * 3526 * @param {quat} out the receiving quaternion 3527 * @param {quat} a the first operand 3528 * @param {quat} b the second operand 3529 * @returns {quat} out 3530 */ 3531 quat.multiply = function(out, a, b) { 3532 var ax = a[0], ay = a[1], az = a[2], aw = a[3], 3533 bx = b[0], by = b[1], bz = b[2], bw = b[3]; 3534 3535 out[0] = ax * bw + aw * bx + ay * bz - az * by; 3536 out[1] = ay * bw + aw * by + az * bx - ax * bz; 3537 out[2] = az * bw + aw * bz + ax * by - ay * bx; 3538 out[3] = aw * bw - ax * bx - ay * by - az * bz; 3539 return out; 3540 }; 3541 3542 /** 3543 * Alias for {@link quat.multiply} 3544 * @function 3545 */ 3546 quat.mul = quat.multiply; 3547 3548 /** 3549 * Scales a quat by a scalar number 3550 * 3551 * @param {quat} out the receiving vector 3552 * @param {quat} a the vector to scale 3553 * @param {Number} b amount to scale the vector by 3554 * @returns {quat} out 3555 * @function 3556 */ 3557 quat.scale = vec4.scale; 3558 3559 /** 3560 * Rotates a quaternion by the given angle around the X axis 3561 * 3562 * @param {quat} out quat receiving operation result 3563 * @param {quat} a quat to rotate 3564 * @param {number} rad angle (in radians) to rotate 3565 * @returns {quat} out 3566 */ 3567 quat.rotateX = function (out, a, rad) { 3568 rad *= 0.5; 3569 3570 var ax = a[0], ay = a[1], az = a[2], aw = a[3], 3571 bx = Math.sin(rad), bw = Math.cos(rad); 3572 3573 out[0] = ax * bw + aw * bx; 3574 out[1] = ay * bw + az * bx; 3575 out[2] = az * bw - ay * bx; 3576 out[3] = aw * bw - ax * bx; 3577 return out; 3578 }; 3579 3580 /** 3581 * Rotates a quaternion by the given angle around the Y axis 3582 * 3583 * @param {quat} out quat receiving operation result 3584 * @param {quat} a quat to rotate 3585 * @param {number} rad angle (in radians) to rotate 3586 * @returns {quat} out 3587 */ 3588 quat.rotateY = function (out, a, rad) { 3589 rad *= 0.5; 3590 3591 var ax = a[0], ay = a[1], az = a[2], aw = a[3], 3592 by = Math.sin(rad), bw = Math.cos(rad); 3593 3594 out[0] = ax * bw - az * by; 3595 out[1] = ay * bw + aw * by; 3596 out[2] = az * bw + ax * by; 3597 out[3] = aw * bw - ay * by; 3598 return out; 3599 }; 3600 3601 /** 3602 * Rotates a quaternion by the given angle around the Z axis 3603 * 3604 * @param {quat} out quat receiving operation result 3605 * @param {quat} a quat to rotate 3606 * @param {number} rad angle (in radians) to rotate 3607 * @returns {quat} out 3608 */ 3609 quat.rotateZ = function (out, a, rad) { 3610 rad *= 0.5; 3611 3612 var ax = a[0], ay = a[1], az = a[2], aw = a[3], 3613 bz = Math.sin(rad), bw = Math.cos(rad); 3614 3615 out[0] = ax * bw + ay * bz; 3616 out[1] = ay * bw - ax * bz; 3617 out[2] = az * bw + aw * bz; 3618 out[3] = aw * bw - az * bz; 3619 return out; 3620 }; 3621 3622 /** 3623 * Calculates the W component of a quat from the X, Y, and Z components. 3624 * Assumes that quaternion is 1 unit in length. 3625 * Any existing W component will be ignored. 3626 * 3627 * @param {quat} out the receiving quaternion 3628 * @param {quat} a quat to calculate W component of 3629 * @returns {quat} out 3630 */ 3631 quat.calculateW = function (out, a) { 3632 var x = a[0], y = a[1], z = a[2]; 3633 3634 out[0] = x; 3635 out[1] = y; 3636 out[2] = z; 3637 out[3] = -Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z)); 3638 return out; 3639 }; 3640 3641 /** 3642 * Calculates the dot product of two quat's 3643 * 3644 * @param {quat} a the first operand 3645 * @param {quat} b the second operand 3646 * @returns {Number} dot product of a and b 3647 * @function 3648 */ 3649 quat.dot = vec4.dot; 3650 3651 /** 3652 * Performs a linear interpolation between two quat's 3653 * 3654 * @param {quat} out the receiving quaternion 3655 * @param {quat} a the first operand 3656 * @param {quat} b the second operand 3657 * @param {Number} t interpolation amount between the two inputs 3658 * @returns {quat} out 3659 * @function 3660 */ 3661 quat.lerp = vec4.lerp; 3662 3663 /** 3664 * Performs a spherical linear interpolation between two quat 3665 * 3666 * @param {quat} out the receiving quaternion 3667 * @param {quat} a the first operand 3668 * @param {quat} b the second operand 3669 * @param {Number} t interpolation amount between the two inputs 3670 * @returns {quat} out 3671 */ 3672 quat.slerp = function (out, a, b, t) { 3673 var ax = a[0], ay = a[1], az = a[2], aw = a[3], 3674 bx = b[0], by = b[1], bz = b[2], bw = b[3]; 3675 3676 var cosHalfTheta = ax * bx + ay * by + az * bz + aw * bw, 3677 halfTheta, 3678 sinHalfTheta, 3679 ratioA, 3680 ratioB; 3681 3682 if (Math.abs(cosHalfTheta) >= 1.0) { 3683 if (out !== a) { 3684 out[0] = ax; 3685 out[1] = ay; 3686 out[2] = az; 3687 out[3] = aw; 3688 } 3689 return out; 3690 } 3691 3692 halfTheta = Math.acos(cosHalfTheta); 3693 sinHalfTheta = Math.sqrt(1.0 - cosHalfTheta * cosHalfTheta); 3694 3695 if (Math.abs(sinHalfTheta) < 0.001) { 3696 out[0] = (ax * 0.5 + bx * 0.5); 3697 out[1] = (ay * 0.5 + by * 0.5); 3698 out[2] = (az * 0.5 + bz * 0.5); 3699 out[3] = (aw * 0.5 + bw * 0.5); 3700 return out; 3701 } 3702 3703 ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta; 3704 ratioB = Math.sin(t * halfTheta) / sinHalfTheta; 3705 3706 out[0] = (ax * ratioA + bx * ratioB); 3707 out[1] = (ay * ratioA + by * ratioB); 3708 out[2] = (az * ratioA + bz * ratioB); 3709 out[3] = (aw * ratioA + bw * ratioB); 3710 3711 return out; 3712 }; 3713 3714 /** 3715 * Calculates the inverse of a quat 3716 * 3717 * @param {quat} out the receiving quaternion 3718 * @param {quat} a quat to calculate inverse of 3719 * @returns {quat} out 3720 */ 3721 quat.invert = function(out, a) { 3722 var a0 = a[0], a1 = a[1], a2 = a[2], a3 = a[3], 3723 dot = a0*a0 + a1*a1 + a2*a2 + a3*a3, 3724 invDot = dot ? 1.0/dot : 0; 3725 3726 // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0 3727 3728 out[0] = -a0*invDot; 3729 out[1] = -a1*invDot; 3730 out[2] = -a2*invDot; 3731 out[3] = a3*invDot; 3732 return out; 3733 }; 3734 3735 /** 3736 * Calculates the conjugate of a quat 3737 * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result. 3738 * 3739 * @param {quat} out the receiving quaternion 3740 * @param {quat} a quat to calculate conjugate of 3741 * @returns {quat} out 3742 */ 3743 quat.conjugate = function (out, a) { 3744 out[0] = -a[0]; 3745 out[1] = -a[1]; 3746 out[2] = -a[2]; 3747 out[3] = a[3]; 3748 return out; 3749 }; 3750 3751 /** 3752 * Calculates the length of a quat 3753 * 3754 * @param {quat} a vector to calculate length of 3755 * @returns {Number} length of a 3756 * @function 3757 */ 3758 quat.length = vec4.length; 3759 3760 /** 3761 * Alias for {@link quat.length} 3762 * @function 3763 */ 3764 quat.len = quat.length; 3765 3766 /** 3767 * Calculates the squared length of a quat 3768 * 3769 * @param {quat} a vector to calculate squared length of 3770 * @returns {Number} squared length of a 3771 * @function 3772 */ 3773 quat.squaredLength = vec4.squaredLength; 3774 3775 /** 3776 * Alias for {@link quat.squaredLength} 3777 * @function 3778 */ 3779 quat.sqrLen = quat.squaredLength; 3780 3781 /** 3782 * Normalize a quat 3783 * 3784 * @param {quat} out the receiving quaternion 3785 * @param {quat} a quaternion to normalize 3786 * @returns {quat} out 3787 * @function 3788 */ 3789 quat.normalize = vec4.normalize; 3790 3791 /** 3792 * Creates a quaternion from the given 3x3 rotation matrix. 3793 * 3794 * @param {quat} out the receiving quaternion 3795 * @param {mat3} m rotation matrix 3796 * @returns {quat} out 3797 * @function 3798 */ 3799 quat.fromMat3 = (function() { 3800 var s_iNext = [1,2,0]; 3801 return function(out, m) { 3802 // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes 3803 // article "Quaternion Calculus and Fast Animation". 3804 var fTrace = m[0] + m[4] + m[8]; 3805 var fRoot; 3806 3807 if ( fTrace > 0.0 ) { 3808 // |w| > 1/2, may as well choose w > 1/2 3809 fRoot = Math.sqrt(fTrace + 1.0); // 2w 3810 out[3] = 0.5 * fRoot; 3811 fRoot = 0.5/fRoot; // 1/(4w) 3812 out[0] = (m[7]-m[5])*fRoot; 3813 out[1] = (m[2]-m[6])*fRoot; 3814 out[2] = (m[3]-m[1])*fRoot; 3815 } else { 3816 // |w| <= 1/2 3817 var i = 0; 3818 if ( m[4] > m[0] ) 3819 i = 1; 3820 if ( m[8] > m[i*3+i] ) 3821 i = 2; 3822 var j = s_iNext[i]; 3823 var k = s_iNext[j]; 3824 3825 fRoot = Math.sqrt(m[i*3+i]-m[j*3+j]-m[k*3+k] + 1.0); 3826 out[i] = 0.5 * fRoot; 3827 fRoot = 0.5 / fRoot; 3828 out[3] = (m[k*3+j] - m[j*3+k]) * fRoot; 3829 out[j] = (m[j*3+i] + m[i*3+j]) * fRoot; 3830 out[k] = (m[k*3+i] + m[i*3+k]) * fRoot; 3831 } 3832 3833 return out; 3834 }; 3835 })(); 3836 3837 /** 3838 * Returns a string representation of a quatenion 3839 * 3840 * @param {quat} vec vector to represent as a string 3841 * @returns {String} string representation of the vector 3842 */ 3843 quat.str = function (a) { 3844 return 'quat(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')'; 3845 }; 3846 3847 if(typeof(exports) !== 'undefined') { 3848 exports.quat = quat; 3849 } 3850 ; 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 })(shim.exports); 3865 })(); 3866