Run results for: WebGL math library comparison

Originally from jsperf webgl-math-library-comparisson A comparisson of several math / vector libraries to be used against webgl. The test is intended to help select the fastest library to use for webgl projects. Libraries Tested: Closure / goog.math, gl-matrix, N3D, Sylvester, vanilla js These results show that the allocation of small temporary objects is practically free in modern browsers. Arrays are still much slower though. With this in mind, an ideal modern webgl math library should use immutable objects for each function call and then have a final conversion to Float32Array function only used when assigning the result to WebGL since allocating ArrayBuffers is also extremely slow.

Go to the benchmark

Run details:

User agent: Mozilla/5.0 (X11; Linux x86_64; rv:83.0) Gecko/20100101 Firefox/83.0

Browser: Firefox 83

Operating system: Linux

Device Platform: Desktop

Date tested: 3 years ago

Test name	Executions per second
Vanilla	12233046.0 Ops/sec
glmatrix	7704914.5 Ops/sec
ES6 class	9602643.0 Ops/sec
No Array	26736608.0 Ops/sec
N3D	9019152.0 Ops/sec
Closure	6747338.5 Ops/sec

HTML Preparation code:

<script src="https://cdn.rawgit.com/google/closure-library/master/closure/goog/base.js"></script>
<script src="http://numericjs.com/lib/numeric-1.2.6.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/gl-matrix/2.3.1/gl-matrix-min.js"></script>
<script>

let index = 0;
const defaultCount = 100000000;
const floatArray = new Float64Array(defaultCount);

var total = 0;
// === Sylvester ===
// Vector and Matrix mathematics modules for JavaScript
// Copyright (c) 2007 James Coglan
// 
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.

var Sylvester = {
  version: '0.1.3',
  precision: 1e-6
};

function Vector() {}
Vector.prototype = {

  // Returns element i of the vector
  e: function(i) {
    return (i < 1 || i > this.elements.length) ? null : this.elements[i-1];
  },

  // Returns the number of elements the vector has
  dimensions: function() {
    return this.elements.length;
  },

  // Returns the modulus ('length') of the vector
  modulus: function() {
    return Math.sqrt(this.dot(this));
  },

  // Returns true iff the vector is equal to the argument
  eql: function(vector) {
    var n = this.elements.length;
    var V = vector.elements || vector;
    if (n != V.length) { return false; }
    do {
      if (Math.abs(this.elements[n-1] - V[n-1]) > Sylvester.precision) { return false; }
    } while (--n);
    return true;
  },

  // Returns a copy of the vector
  dup: function() {
    return Vector.create(this.elements);
  },

  // Maps the vector to another vector according to the given function
  map: function(fn) {
    var elements = [];
    this.each(function(x, i) {
      elements.push(fn(x, i));
    });
    return Vector.create(elements);
  },
  
  // Calls the iterator for each element of the vector in turn
  each: function(fn) {
    var n = this.elements.length, k = n, i;
    do { i = k - n;
      fn(this.elements[i], i+1);
    } while (--n);
  },

  // Returns a new vector created by normalizing the receiver
  toUnitVector: function() {
    var r = this.modulus();
    if (r === 0) { return this.dup(); }
    return this.map(function(x) { return x/r; });
  },

  // Returns the angle between the vector and the argument (also a vector)
  angleFrom: function(vector) {
    var V = vector.elements || vector;
    var n = this.elements.length, k = n, i;
    if (n != V.length) { return null; }
    var dot = 0, mod1 = 0, mod2 = 0;
    // Work things out in parallel to save time
    this.each(function(x, i) {
      dot += x * V[i-1];
      mod1 += x * x;
      mod2 += V[i-1] * V[i-1];
    });
    mod1 = Math.sqrt(mod1); mod2 = Math.sqrt(mod2);
    if (mod1*mod2 === 0) { return null; }
    var theta = dot / (mod1*mod2);
    if (theta < -1) { theta = -1; }
    if (theta > 1) { theta = 1; }
    return Math.acos(theta);
  },

  // Returns true iff the vector is parallel to the argument
  isParallelTo: function(vector) {
    var angle = this.angleFrom(vector);
    return (angle === null) ? null : (angle <= Sylvester.precision);
  },

  // Returns true iff the vector is antiparallel to the argument
  isAntiparallelTo: function(vector) {
    var angle = this.angleFrom(vector);
    return (angle === null) ? null : (Math.abs(angle - Math.PI) <= Sylvester.precision);
  },

  // Returns true iff the vector is perpendicular to the argument
  isPerpendicularTo: function(vector) {
    var dot = this.dot(vector);
    return (dot === null) ? null : (Math.abs(dot) <= Sylvester.precision);
  },

  // Returns the result of adding the argument to the vector
  add: function(vector) {
    var V = vector.elements || vector;
    if (this.elements.length != V.length) { return null; }
    return this.map(function(x, i) { return x + V[i-1]; });
  },

  // Returns the result of subtracting the argument from the vector
  subtract: function(vector) {
    var V = vector.elements || vector;
    if (this.elements.length != V.length) { return null; }
    return this.map(function(x, i) { return x - V[i-1]; });
  },

  // Returns the result of multiplying the elements of the vector by the argument
  multiply: function(k) {
    return this.map(function(x) { return x*k; });
  },

  x: function(k) { return this.multiply(k); },

  // Returns the scalar product of the vector with the argument
  // Both vectors must have equal dimensionality
  dot: function(vector) {
    var V = vector.elements || vector;
    var i, product = 0, n = this.elements.length;
    if (n != V.length) { return null; }
    do { product += this.elements[n-1] * V[n-1]; } while (--n);
    return product;
  },

  // Returns the vector product of the vector with the argument
  // Both vectors must have dimensionality 3
  cross: function(vector) {
    var B = vector.elements || vector;
    if (this.elements.length != 3 || B.length != 3) { return null; }
    var A = this.elements;
    return Vector.create([
      (A[1] * B[2]) - (A[2] * B[1]),
      (A[2] * B[0]) - (A[0] * B[2]),
      (A[0] * B[1]) - (A[1] * B[0])
    ]);
  },

  // Returns the (absolute) largest element of the vector
  max: function() {
    var m = 0, n = this.elements.length, k = n, i;
    do { i = k - n;
      if (Math.abs(this.elements[i]) > Math.abs(m)) { m = this.elements[i]; }
    } while (--n);
    return m;
  },

  // Returns the index of the first match found
  indexOf: function(x) {
    var index = null, n = this.elements.length, k = n, i;
    do { i = k - n;
      if (index === null && this.elements[i] == x) {
        index = i + 1;
      }
    } while (--n);
    return index;
  },

  // Returns a diagonal matrix with the vector's elements as its diagonal elements
  toDiagonalMatrix: function() {
    return Matrix.Diagonal(this.elements);
  },

  // Returns the result of rounding the elements of the vector
  round: function() {
    return this.map(function(x) { return Math.round(x); });
  },

  // Returns a copy of the vector with elements set to the given value if they
  // differ from it by less than Sylvester.precision
  snapTo: function(x) {
    return this.map(function(y) {
      return (Math.abs(y - x) <= Sylvester.precision) ? x : y;
    });
  },

  // Returns the vector's distance from the argument, when considered as a point in space
  distanceFrom: function(obj) {
    if (obj.anchor) { return obj.distanceFrom(this); }
    var V = obj.elements || obj;
    if (V.length != this.elements.length) { return null; }
    var sum = 0, part;
    this.each(function(x, i) {
      part = x - V[i-1];
      sum += part * part;
    });
    return Math.sqrt(sum);
  },

  // Returns true if the vector is point on the given line
  liesOn: function(line) {
    return line.contains(this);
  },

  // Return true iff the vector is a point in the given plane
  liesIn: function(plane) {
    return plane.contains(this);
  },

  // Rotates the vector about the given object. The object should be a 
  // point if the vector is 2D, and a line if it is 3D. Be careful with line directions!
  rotate: function(t, obj) {
    var V, R, x, y, z;
    switch (this.elements.length) {
      case 2:
        V = obj.elements || obj;
        if (V.length != 2) { return null; }
        R = Matrix.Rotation(t).elements;
        x = this.elements[0] - V[0];
        y = this.elements[1] - V[1];
        return Vector.create([
          V[0] + R[0][0] * x + R[0][1] * y,
          V[1] + R[1][0] * x + R[1][1] * y
        ]);
        break;
      case 3:
        if (!obj.direction) { return null; }
        var C = obj.pointClosestTo(this).elements;
        R = Matrix.Rotation(t, obj.direction).elements;
        x = this.elements[0] - C[0];
        y = this.elements[1] - C[1];
        z = this.elements[2] - C[2];
        return Vector.create([
          C[0] + R[0][0] * x + R[0][1] * y + R[0][2] * z,
          C[1] + R[1][0] * x + R[1][1] * y + R[1][2] * z,
          C[2] + R[2][0] * x + R[2][1] * y + R[2][2] * z
        ]);
        break;
      default:
        return null;
    }
  },

  // Returns the result of reflecting the point in the given point, line or plane
  reflectionIn: function(obj) {
    if (obj.anchor) {
      // obj is a plane or line
      var P = this.elements.slice();
      var C = obj.pointClosestTo(P).elements;
      return Vector.create([C[0] + (C[0] - P[0]), C[1] + (C[1] - P[1]), C[2] + (C[2] - (P[2] || 0))]);
    } else {
      // obj is a point
      var Q = obj.elements || obj;
      if (this.elements.length != Q.length) { return null; }
      return this.map(function(x, i) { return Q[i-1] + (Q[i-1] - x); });
    }
  },

  // Utility to make sure vectors are 3D. If they are 2D, a zero z-component is added
  to3D: function() {
    var V = this.dup();
    switch (V.elements.length) {
      case 3: break;
      case 2: V.elements.push(0); break;
      default: return null;
    }
    return V;
  },

  // Returns a string representation of the vector
  inspect: function() {
    return '[' + this.elements.join(', ') + ']';
  },

  // Set vector's elements from an array
  setElements: function(els) {
    this.elements = (els.elements || els).slice();
    return this;
  }
};
  
// Constructor function
Vector.create = function(elements) {
  var V = new Vector();
  return V.setElements(elements);
};

// i, j, k unit vectors
Vector.i = Vector.create([1,0,0]);
Vector.j = Vector.create([0,1,0]);
Vector.k = Vector.create([0,0,1]);

// Random vector of size n
Vector.Random = function(n) {
  var elements = [];
  do { elements.push(Math.random());
  } while (--n);
  return Vector.create(elements);
};

// Vector filled with zeros
Vector.Zero = function(n) {
  var elements = [];
  do { elements.push(0);
  } while (--n);
  return Vector.create(elements);
};



function Matrix() {}
Matrix.prototype = {

  // Returns element (i,j) of the matrix
  e: function(i,j) {
    if (i < 1 || i > this.elements.length || j < 1 || j > this.elements[0].length) { return null; }
    return this.elements[i-1][j-1];
  },

  // Returns row k of the matrix as a vector
  row: function(i) {
    if (i > this.elements.length) { return null; }
    return Vector.create(this.elements[i-1]);
  },

  // Returns column k of the matrix as a vector
  col: function(j) {
    if (j > this.elements[0].length) { return null; }
    var col = [], n = this.elements.length, k = n, i;
    do { i = k - n;
      col.push(this.elements[i][j-1]);
    } while (--n);
    return Vector.create(col);
  },

  // Returns the number of rows/columns the matrix has
  dimensions: function() {
    return {rows: this.elements.length, cols: this.elements[0].length};
  },

  // Returns the number of rows in the matrix
  rows: function() {
    return this.elements.length;
  },

  // Returns the number of columns in the matrix
  cols: function() {
    return this.elements[0].length;
  },

  // Returns true iff the matrix is equal to the argument. You can supply
  // a vector as the argument, in which case the receiver must be a
  // one-column matrix equal to the vector.
  eql: function(matrix) {
    var M = matrix.elements || matrix;
    if (typeof(M[0][0]) == 'undefined') { M = Matrix.create(M).elements; }
    if (this.elements.length != M.length ||
        this.elements[0].length != M[0].length) { return false; }
    var ni = this.elements.length, ki = ni, i, nj, kj = this.elements[0].length, j;
    do { i = ki - ni;
      nj = kj;
      do { j = kj - nj;
        if (Math.abs(this.elements[i][j] - M[i][j]) > Sylvester.precision) { return false; }
      } while (--nj);
    } while (--ni);
    return true;
  },

  // Returns a copy of the matrix
  dup: function() {
    return Matrix.create(this.elements);
  },

  // Maps the matrix to another matrix (of the same dimensions) according to the given function
  map: function(fn) {
    var els = [], ni = this.elements.length, ki = ni, i, nj, kj = this.elements[0].length, j;
    do { i = ki - ni;
      nj = kj;
      els[i] = [];
      do { j = kj - nj;
        els[i][j] = fn(this.elements[i][j], i + 1, j + 1);
      } while (--nj);
    } while (--ni);
    return Matrix.create(els);
  },

  // Returns true iff the argument has the same dimensions as the matrix
  isSameSizeAs: function(matrix) {
    var M = matrix.elements || matrix;
    if (typeof(M[0][0]) == 'undefined') { M = Matrix.create(M).elements; }
    return (this.elements.length == M.length &&
        this.elements[0].length == M[0].length);
  },

  // Returns the result of adding the argument to the matrix
  add: function(matrix) {
    var M = matrix.elements || matrix;
    if (typeof(M[0][0]) == 'undefined') { M = Matrix.create(M).elements; }
    if (!this.isSameSizeAs(M)) { return null; }
    return this.map(function(x, i, j) { return x + M[i-1][j-1]; });
  },

  // Returns the result of subtracting the argument from the matrix
  subtract: function(matrix) {
    var M = matrix.elements || matrix;
    if (typeof(M[0][0]) == 'undefined') { M = Matrix.create(M).elements; }
    if (!this.isSameSizeAs(M)) { return null; }
    return this.map(function(x, i, j) { return x - M[i-1][j-1]; });
  },

  // Returns true iff the matrix can multiply the argument from the left
  canMultiplyFromLeft: function(matrix) {
    var M = matrix.elements || matrix;
    if (typeof(M[0][0]) == 'undefined') { M = Matrix.create(M).elements; }
    // this.columns should equal matrix.rows
    return (this.elements[0].length == M.length);
  },

  // Returns the result of multiplying the matrix from the right by the argument.
  // If the argument is a scalar then just multiply all the elements. If the argument is
  // a vector, a vector is returned, which saves you having to remember calling
  // col(1) on the result.
  multiply: function(matrix) {
    if (!matrix.elements) {
      return this.map(function(x) { return x * matrix; });
    }
    var returnVector = matrix.modulus ? true : false;
    var M = matrix.elements || matrix;
    if (typeof(M[0][0]) == 'undefined') { M = Matrix.create(M).elements; }
    if (!this.canMultiplyFromLeft(M)) { return null; }
    var ni = this.elements.length, ki = ni, i, nj, kj = M[0].length, j;
    var cols = this.elements[0].length, elements = [], sum, nc, c;
    do { i = ki - ni;
      elements[i] = [];
      nj = kj;
      do { j = kj - nj;
        sum = 0;
        nc = cols;
        do { c = cols - nc;
          sum += this.elements[i][c] * M[c][j];
        } while (--nc);
        elements[i][j] = sum;
      } while (--nj);
    } while (--ni);
    var M = Matrix.create(elements);
    return returnVector ? M.col(1) : M;
  },

  x: function(matrix) { return this.multiply(matrix); },

  // Returns a submatrix taken from the matrix
  // Argument order is: start row, start col, nrows, ncols
  // Element selection wraps if the required index is outside the matrix's bounds, so you could
  // use this to perform row/column cycling or copy-augmenting.
  minor: function(a, b, c, d) {
    var elements = [], ni = c, i, nj, j;
    var rows = this.elements.length, cols = this.elements[0].length;
    do { i = c - ni;
      elements[i] = [];
      nj = d;
      do { j = d - nj;
        elements[i][j] = this.elements[(a+i-1)%rows][(b+j-1)%cols];
      } while (--nj);
    } while (--ni);
    return Matrix.create(elements);
  },

  // Returns the transpose of the matrix
  transpose: function() {
    var rows = this.elements.length, cols = this.elements[0].length;
    var elements = [], ni = cols, i, nj, j;
    do { i = cols - ni;
      elements[i] = [];
      nj = rows;
      do { j = rows - nj;
        elements[i][j] = this.elements[j][i];
      } while (--nj);
    } while (--ni);
    return Matrix.create(elements);
  },

  // Returns true iff the matrix is square
  isSquare: function() {
    return (this.elements.length == this.elements[0].length);
  },

  // Returns the (absolute) largest element of the matrix
  max: function() {
    var m = 0, ni = this.elements.length, ki = ni, i, nj, kj = this.elements[0].length, j;
    do { i = ki - ni;
      nj = kj;
      do { j = kj - nj;
        if (Math.abs(this.elements[i][j]) > Math.abs(m)) { m = this.elements[i][j]; }
      } while (--nj);
    } while (--ni);
    return m;
  },

  // Returns the indeces of the first match found by reading row-by-row from left to right
  indexOf: function(x) {
    var index = null, ni = this.elements.length, ki = ni, i, nj, kj = this.elements[0].length, j;
    do { i = ki - ni;
      nj = kj;
      do { j = kj - nj;
        if (this.elements[i][j] == x) { return {i: i+1, j: j+1}; }
      } while (--nj);
    } while (--ni);
    return null;
  },

  // If the matrix is square, returns the diagonal elements as a vector.
  // Otherwise, returns null.
  diagonal: function() {
    if (!this.isSquare) { return null; }
    var els = [], n = this.elements.length, k = n, i;
    do { i = k - n;
      els.push(this.elements[i][i]);
    } while (--n);
    return Vector.create(els);
  },

  // Make the matrix upper (right) triangular by Gaussian elimination.
  // This method only adds multiples of rows to other rows. No rows are
  // scaled up or switched, and the determinant is preserved.
  toRightTriangular: function() {
    var M = this.dup(), els;
    var n = this.elements.length, k = n, i, np, kp = this.elements[0].length, p;
    do { i = k - n;
      if (M.elements[i][i] == 0) {
        for (j = i + 1; j < k; j++) {
          if (M.elements[j][i] != 0) {
            els = []; np = kp;
            do { p = kp - np;
              els.push(M.elements[i][p] + M.elements[j][p]);
            } while (--np);
            M.elements[i] = els;
            break;
          }
        }
      }
      if (M.elements[i][i] != 0) {
        for (j = i + 1; j < k; j++) {
          var multiplier = M.elements[j][i] / M.elements[i][i];
          els = []; np = kp;
          do { p = kp - np;
            // Elements with column numbers up to an including the number
            // of the row that we're subtracting can safely be set straight to
            // zero, since that's the point of this routine and it avoids having
            // to loop over and correct rounding errors later
            els.push(p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier);
          } while (--np);
          M.elements[j] = els;
        }
      }
    } while (--n);
    return M;
  },

  toUpperTriangular: function() { return this.toRightTriangular(); },

  // Returns the determinant for square matrices
  determinant: function() {
    if (!this.isSquare()) { return null; }
    var M = this.toRightTriangular();
    var det = M.elements[0][0], n = M.elements.length - 1, k = n, i;
    do { i = k - n + 1;
      det = det * M.elements[i][i];
    } while (--n);
    return det;
  },

  det: function() { return this.determinant(); },

  // Returns true iff the matrix is singular
  isSingular: function() {
    return (this.isSquare() && this.determinant() === 0);
  },

  // Returns the trace for square matrices
  trace: function() {
    if (!this.isSquare()) { return null; }
    var tr = this.elements[0][0], n = this.elements.length - 1, k = n, i;
    do { i = k - n + 1;
      tr += this.elements[i][i];
    } while (--n);
    return tr;
  },

  tr: function() { return this.trace(); },

  // Returns the rank of the matrix
  rank: function() {
    var M = this.toRightTriangular(), rank = 0;
    var ni = this.elements.length, ki = ni, i, nj, kj = this.elements[0].length, j;
    do { i = ki - ni;
      nj = kj;
      do { j = kj - nj;
        if (Math.abs(M.elements[i][j]) > Sylvester.precision) { rank++; break; }
      } while (--nj);
    } while (--ni);
    return rank;
  },
  
  rk: function() { return this.rank(); },

  // Returns the result of attaching the given argument to the right-hand side of the matrix
  augment: function(matrix) {
    var M = matrix.elements || matrix;
    if (typeof(M[0][0]) == 'undefined') { M = Matrix.create(M).elements; }
    var T = this.dup(), cols = T.elements[0].length;
    var ni = T.elements.length, ki = ni, i, nj, kj = M[0].length, j;
    if (ni != M.length) { return null; }
    do { i = ki - ni;
      nj = kj;
      do { j = kj - nj;
        T.elements[i][cols + j] = M[i][j];
      } while (--nj);
    } while (--ni);
    return T;
  },

  // Returns the inverse (if one exists) using Gauss-Jordan
  inverse: function() {
    if (!this.isSquare() || this.isSingular()) { return null; }
    var ni = this.elements.length, ki = ni, i, j;
    var M = this.augment(Matrix.I(ni)).toRightTriangular();
    var np, kp = M.elements[0].length, p, els, divisor;
    var inverse_elements = [], new_element;
    // Matrix is non-singular so there will be no zeros on the diagonal
    // Cycle through rows from last to first
    do { i = ni - 1;
      // First, normalise diagonal elements to 1
      els = []; np = kp;
      inverse_elements[i] = [];
      divisor = M.elements[i][i];
      do { p = kp - np;
        new_element = M.elements[i][p] / divisor;
        els.push(new_element);
        // Shuffle of the current row of the right hand side into the results
        // array as it will not be modified by later runs through this loop
        if (p >= ki) { inverse_elements[i].push(new_element); }
      } while (--np);
      M.elements[i] = els;
      // Then, subtract this row from those above it to
      // give the identity matrix on the left hand side
      for (j = 0; j < i; j++) {
        els = []; np = kp;
        do { p = kp - np;
          els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i]);
        } while (--np);
        M.elements[j] = els;
      }
    } while (--ni);
    return Matrix.create(inverse_elements);
  },

  inv: function() { return this.inverse(); },

  // Returns the result of rounding all the elements
  round: function() {
    return this.map(function(x) { return Math.round(x); });
  },

  // Returns a copy of the matrix with elements set to the given value if they
  // differ from it by less than Sylvester.precision
  snapTo: function(x) {
    return this.map(function(p) {
      return (Math.abs(p - x) <= Sylvester.precision) ? x : p;
    });
  },

  // Returns a string representation of the matrix
  inspect: function() {
    var matrix_rows = [];
    var n = this.elements.length, k = n, i;
    do { i = k - n;
      matrix_rows.push(Vector.create(this.elements[i]).inspect());
    } while (--n);
    return matrix_rows.join('\n');
  },

  // Set the matrix's elements from an array. If the argument passed
  // is a vector, the resulting matrix will be a single column.
  setElements: function(els) {
    var i, elements = els.elements || els;
    if (typeof(elements[0][0]) != 'undefined') {
      var ni = elements.length, ki = ni, nj, kj, j;
      this.elements = [];
      do { i = ki - ni;
        nj = elements[i].length; kj = nj;
        this.elements[i] = [];
        do { j = kj - nj;
          this.elements[i][j] = elements[i][j];
        } while (--nj);
      } while(--ni);
      return this;
    }
    var n = elements.length, k = n;
    this.elements = [];
    do { i = k - n;
      this.elements.push([elements[i]]);
    } while (--n);
    return this;
  }
};

// Constructor function
Matrix.create = function(elements) {
  var M = new Matrix();
  return M.setElements(elements);
};

// Identity matrix of size n
Matrix.I = function(n) {
  var els = [], k = n, i, nj, j;
  do { i = k - n;
    els[i] = []; nj = k;
    do { j = k - nj;
      els[i][j] = (i == j) ? 1 : 0;
    } while (--nj);
  } while (--n);
  return Matrix.create(els);
};

// Diagonal matrix - all off-diagonal elements are zero
Matrix.Diagonal = function(elements) {
  var n = elements.length, k = n, i;
  var M = Matrix.I(n);
  do { i = k - n;
    M.elements[i][i] = elements[i];
  } while (--n);
  return M;
};

// Rotation matrix about some axis. If no axis is
// supplied, assume we're after a 2D transform
Matrix.Rotation = function(theta, a) {
  if (!a) {
    return Matrix.create([
      [Math.cos(theta),  -Math.sin(theta)],
      [Math.sin(theta),   Math.cos(theta)]
    ]);
  }
  var axis = a.dup();
  if (axis.elements.length != 3) { return null; }
  var mod = axis.modulus();
  var x = axis.elements[0]/mod, y = axis.elements[1]/mod, z = axis.elements[2]/mod;
  var s = Math.sin(theta), c = Math.cos(theta), t = 1 - c;
  // Formula derived here: http://www.gamedev.net/reference/articles/article1199.asp
  // That proof rotates the co-ordinate system so theta
  // becomes -theta and sin becomes -sin here.
  return Matrix.create([
    [ t*x*x + c, t*x*y - s*z, t*x*z + s*y ],
    [ t*x*y + s*z, t*y*y + c, t*y*z - s*x ],
    [ t*x*z - s*y, t*y*z + s*x, t*z*z + c ]
  ]);
};

// Special case rotations
Matrix.RotationX = function(t) {
  var c = Math.cos(t), s = Math.sin(t);
  return Matrix.create([
    [  1,  0,  0 ],
    [  0,  c, -s ],
    [  0,  s,  c ]
  ]);
};
Matrix.RotationY = function(t) {
  var c = Math.cos(t), s = Math.sin(t);
  return Matrix.create([
    [  c,  0,  s ],
    [  0,  1,  0 ],
    [ -s,  0,  c ]
  ]);
};
Matrix.RotationZ = function(t) {
  var c = Math.cos(t), s = Math.sin(t);
  return Matrix.create([
    [  c, -s,  0 ],
    [  s,  c,  0 ],
    [  0,  0,  1 ]
  ]);
};

// Random matrix of n rows, m columns
Matrix.Random = function(n, m) {
  return Matrix.Zero(n, m).map(
    function() { return Math.random(); }
  );
};

// Matrix filled with zeros
Matrix.Zero = function(n, m) {
  var els = [], ni = n, i, nj, j;
  do { i = n - ni;
    els[i] = [];
    nj = m;
    do { j = m - nj;
      els[i][j] = 0;
    } while (--nj);
  } while (--ni);
  return Matrix.create(els);
};



function Line() {}
Line.prototype = {

  // Returns true if the argument occupies the same space as the line
  eql: function(line) {
    return (this.isParallelTo(line) && this.contains(line.anchor));
  },

  // Returns a copy of the line
  dup: function() {
    return Line.create(this.anchor, this.direction);
  },

  // Returns the result of translating the line by the given vector/array
  translate: function(vector) {
    var V = vector.elements || vector;
    return Line.create([
      this.anchor.elements[0] + V[0],
      this.anchor.elements[1] + V[1],
      this.anchor.elements[2] + (V[2] || 0)
    ], this.direction);
  },

  // Returns true if the line is parallel to the argument. Here, 'parallel to'
  // means that the argument's direction is either parallel or antiparallel to
  // the line's own direction. A line is parallel to a plane if the two do not
  // have a unique intersection.
  isParallelTo: function(obj) {
    if (obj.normal) { return obj.isParallelTo(this); }
    var theta = this.direction.angleFrom(obj.direction);
    return (Math.abs(theta) <= Sylvester.precision || Math.abs(theta - Math.PI) <= Sylvester.precision);
  },

  // Returns the line's perpendicular distance from the argument,
  // which can be a point, a line or a plane
  distanceFrom: function(obj) {
    if (obj.normal) { return obj.distanceFrom(this); }
    if (obj.direction) {
      // obj is a line
      if (this.isParallelTo(obj)) { return this.distanceFrom(obj.anchor); }
      var N = this.direction.cross(obj.direction).toUnitVector().elements;
      var A = this.anchor.elements, B = obj.anchor.elements;
      return Math.abs((A[0] - B[0]) * N[0] + (A[1] - B[1]) * N[1] + (A[2] - B[2]) * N[2]);
    } else {
      // obj is a point
      var P = obj.elements || obj;
      var A = this.anchor.elements, D = this.direction.elements;
      var PA1 = P[0] - A[0], PA2 = P[1] - A[1], PA3 = (P[2] || 0) - A[2];
      var modPA = Math.sqrt(PA1*PA1 + PA2*PA2 + PA3*PA3);
      if (modPA === 0) return 0;
      // Assumes direction vector is normalized
      var cosTheta = (PA1 * D[0] + PA2 * D[1] + PA3 * D[2]) / modPA;
      var sin2 = 1 - cosTheta*cosTheta;
      return Math.abs(modPA * Math.sqrt(sin2 < 0 ? 0 : sin2));
    }
  },

  // Returns true iff the argument is a point on the line
  contains: function(point) {
    var dist = this.distanceFrom(point);
    return (dist !== null && dist <= Sylvester.precision);
  },

  // Returns true iff the line lies in the given plane
  liesIn: function(plane) {
    return plane.contains(this);
  },

  // Returns true iff the line has a unique point of intersection with the argument
  intersects: function(obj) {
    if (obj.normal) { return obj.intersects(this); }
    return (!this.isParallelTo(obj) && this.distanceFrom(obj) <= Sylvester.precision);
  },

  // Returns the unique intersection point with the argument, if one exists
  intersectionWith: function(obj) {
    if (obj.normal) { return obj.intersectionWith(this); }
    if (!this.intersects(obj)) { return null; }
    var P = this.anchor.elements, X = this.direction.elements,
        Q = obj.anchor.elements, Y = obj.direction.elements;
    var X1 = X[0], X2 = X[1], X3 = X[2], Y1 = Y[0], Y2 = Y[1], Y3 = Y[2];
    var PsubQ1 = P[0] - Q[0], PsubQ2 = P[1] - Q[1], PsubQ3 = P[2] - Q[2];
    var XdotQsubP = - X1*PsubQ1 - X2*PsubQ2 - X3*PsubQ3;
    var YdotPsubQ = Y1*PsubQ1 + Y2*PsubQ2 + Y3*PsubQ3;
    var XdotX = X1*X1 + X2*X2 + X3*X3;
    var YdotY = Y1*Y1 + Y2*Y2 + Y3*Y3;
    var XdotY = X1*Y1 + X2*Y2 + X3*Y3;
    var k = (XdotQsubP * YdotY / XdotX + XdotY * YdotPsubQ) / (YdotY - XdotY * XdotY);
    return Vector.create([P[0] + k*X1, P[1] + k*X2, P[2] + k*X3]);
  },

  // Returns the point on the line that is closest to the given point or line
  pointClosestTo: function(obj) {
    if (obj.direction) {
      // obj is a line
      if (this.intersects(obj)) { return this.intersectionWith(obj); }
      if (this.isParallelTo(obj)) { return null; }
      var D = this.direction.elements, E = obj.direction.elements;
      var D1 = D[0], D2 = D[1], D3 = D[2], E1 = E[0], E2 = E[1], E3 = E[2];
      // Create plane containing obj and the shared normal and intersect this with it
      // Thank you: http://www.cgafaq.info/wiki/Line-line_distance
      var x = (D3 * E1 - D1 * E3), y = (D1 * E2 - D2 * E1), z = (D2 * E3 - D3 * E2);
      var N = Vector.create([x * E3 - y * E2, y * E1 - z * E3, z * E2 - x * E1]);
      var P = Plane.create(obj.anchor, N);
      return P.intersectionWith(this);
    } else {
      // obj is a point
      var P = obj.elements || obj;
      if (this.contains(P)) { return Vector.create(P); }
      var A = this.anchor.elements, D = this.direction.elements;
      var D1 = D[0], D2 = D[1], D3 = D[2], A1 = A[0], A2 = A[1], A3 = A[2];
      var x = D1 * (P[1]-A2) - D2 * (P[0]-A1), y = D2 * ((P[2] || 0) - A3) - D3 * (P[1]-A2),
          z = D3 * (P[0]-A1) - D1 * ((P[2] || 0) - A3);
      var V = Vector.create([D2 * x - D3 * z, D3 * y - D1 * x, D1 * z - D2 * y]);
      var k = this.distanceFrom(P) / V.modulus();
      return Vector.create([
        P[0] + V.elements[0] * k,
        P[1] + V.elements[1] * k,
        (P[2] || 0) + V.elements[2] * k
      ]);
    }
  },

  // Returns a copy of the line rotated by t radians about the given line. Works by
  // finding the argument's closest point to this line's anchor point (call this C) and
  // rotating the anchor about C. Also rotates the line's direction about the argument's.
  // Be careful with this - the rotation axis' direction affects the outcome!
  rotate: function(t, line) {
    // If we're working in 2D
    if (typeof(line.direction) == 'undefined') { line = Line.create(line.to3D(), Vector.k); }
    var R = Matrix.Rotation(t, line.direction).elements;
    var C = line.pointClosestTo(this.anchor).elements;
    var A = this.anchor.elements, D = this.direction.elements;
    var C1 = C[0], C2 = C[1], C3 = C[2], A1 = A[0], A2 = A[1], A3 = A[2];
    var x = A1 - C1, y = A2 - C2, z = A3 - C3;
    return Line.create([
      C1 + R[0][0] * x + R[0][1] * y + R[0][2] * z,
      C2 + R[1][0] * x + R[1][1] * y + R[1][2] * z,
      C3 + R[2][0] * x + R[2][1] * y + R[2][2] * z
    ], [
      R[0][0] * D[0] + R[0][1] * D[1] + R[0][2] * D[2],
      R[1][0] * D[0] + R[1][1] * D[1] + R[1][2] * D[2],
      R[2][0] * D[0] + R[2][1] * D[1] + R[2][2] * D[2]
    ]);
  },

  // Returns the line's reflection in the given point or line
  reflectionIn: function(obj) {
    if (obj.normal) {
      // obj is a plane
      var A = this.anchor.elements, D = this.direction.elements;
      var A1 = A[0], A2 = A[1], A3 = A[2], D1 = D[0], D2 = D[1], D3 = D[2];
      var newA = this.anchor.reflectionIn(obj).elements;
      // Add the line's direction vector to its anchor, then mirror that in the plane
      var AD1 = A1 + D1, AD2 = A2 + D2, AD3 = A3 + D3;
      var Q = obj.pointClosestTo([AD1, AD2, AD3]).elements;
      var newD = [Q[0] + (Q[0] - AD1) - newA[0], Q[1] + (Q[1] - AD2) - newA[1], Q[2] + (Q[2] - AD3) - newA[2]];
      return Line.create(newA, newD);
    } else if (obj.direction) {
      // obj is a line - reflection obtained by rotating PI radians about obj
      return this.rotate(Math.PI, obj);
    } else {
      // obj is a point - just reflect the line's anchor in it
      var P = obj.elements || obj;
      return Line.create(this.anchor.reflectionIn([P[0], P[1], (P[2] || 0)]), this.direction);
    }
  },

  // Set the line's anchor point and direction.
  setVectors: function(anchor, direction) {
    // Need to do this so that line's properties are not
    // references to the arguments passed in
    anchor = Vector.create(anchor);
    direction = Vector.create(direction);
    if (anchor.elements.length == 2) {anchor.elements.push(0); }
    if (direction.elements.length == 2) { direction.elements.push(0); }
    if (anchor.elements.length > 3 || direction.elements.length > 3) { return null; }
    var mod = direction.modulus();
    if (mod === 0) { return null; }
    this.anchor = anchor;
    this.direction = Vector.create([
      direction.elements[0] / mod,
      direction.elements[1] / mod,
      direction.elements[2] / mod
    ]);
    return this;
  }
};

  
// Constructor function
Line.create = function(anchor, direction) {
  var L = new Line();
  return L.setVectors(anchor, direction);
};

// Axes
Line.X = Line.create(Vector.Zero(3), Vector.i);
Line.Y = Line.create(Vector.Zero(3), Vector.j);
Line.Z = Line.create(Vector.Zero(3), Vector.k);



function Plane() {}
Plane.prototype = {

  // Returns true iff the plane occupies the same space as the argument
  eql: function(plane) {
    return (this.contains(plane.anchor) && this.isParallelTo(plane));
  },

  // Returns a copy of the plane
  dup: function() {
    return Plane.create(this.anchor, this.normal);
  },

  // Returns the result of translating the plane by the given vector
  translate: function(vector) {
    var V = vector.elements || vector;
    return Plane.create([
      this.anchor.elements[0] + V[0],
      this.anchor.elements[1] + V[1],
      this.anchor.elements[2] + (V[2] || 0)
    ], this.normal);
  },

  // Returns true iff the plane is parallel to the argument. Will return true
  // if the planes are equal, or if you give a line and it lies in the plane.
  isParallelTo: function(obj) {
    var theta;
    if (obj.normal) {
      // obj is a plane
      theta = this.normal.angleFrom(obj.normal);
      return (Math.abs(theta) <= Sylvester.precision || Math.abs(Math.PI - theta) <= Sylvester.precision);
    } else if (obj.direction) {
      // obj is a line
      return this.normal.isPerpendicularTo(obj.direction);
    }
    return null;
  },
  
  // Returns true iff the receiver is perpendicular to the argument
  isPerpendicularTo: function(plane) {
    var theta = this.normal.angleFrom(plane.normal);
    return (Math.abs(Math.PI/2 - theta) <= Sylvester.precision);
  },

  // Returns the plane's distance from the given object (point, line or plane)
  distanceFrom: function(obj) {
    if (this.intersects(obj) || this.contains(obj)) { return 0; }
    if (obj.anchor) {
      // obj is a plane or line
      var A = this.anchor.elements, B = obj.anchor.elements, N = this.normal.elements;
      return Math.abs((A[0] - B[0]) * N[0] + (A[1] - B[1]) * N[1] + (A[2] - B[2]) * N[2]);
    } else {
      // obj is a point
      var P = obj.elements || obj;
      var A = this.anchor.elements, N = this.normal.elements;
      return Math.abs((A[0] - P[0]) * N[0] + (A[1] - P[1]) * N[1] + (A[2] - (P[2] || 0)) * N[2]);
    }
  },

  // Returns true iff the plane contains the given point or line
  contains: function(obj) {
    if (obj.normal) { return null; }
    if (obj.direction) {
      return (this.contains(obj.anchor) && this.contains(obj.anchor.add(obj.direction)));
    } else {
      var P = obj.elements || obj;
      var A = this.anchor.elements, N = this.normal.elements;
      var diff = Math.abs(N[0]*(A[0] - P[0]) + N[1]*(A[1] - P[1]) + N[2]*(A[2] - (P[2] || 0)));
      return (diff <= Sylvester.precision);
    }
  },

  // Returns true iff the plane has a unique point/line of intersection with the argument
  intersects: function(obj) {
    if (typeof(obj.direction) == 'undefined' && typeof(obj.normal) == 'undefined') { return null; }
    return !this.isParallelTo(obj);
  },

  // Returns the unique intersection with the argument, if one exists. The result
  // will be a vector if a line is supplied, and a line if a plane is supplied.
  intersectionWith: function(obj) {
    if (!this.intersects(obj)) { return null; }
    if (obj.direction) {
      // obj is a line
      var A = obj.anchor.elements, D = obj.direction.elements,
          P = this.anchor.elements, N = this.normal.elements;
      var multiplier = (N[0]*(P[0]-A[0]) + N[1]*(P[1]-A[1]) + N[2]*(P[2]-A[2])) / (N[0]*D[0] + N[1]*D[1] + N[2]*D[2]);
      return Vector.create([A[0] + D[0]*multiplier, A[1] + D[1]*multiplier, A[2] + D[2]*multiplier]);
    } else if (obj.normal) {
      // obj is a plane
      var direction = this.normal.cross(obj.normal).toUnitVector();
      // To find an anchor point, we find one co-ordinate that has a value
      // of zero somewhere on the intersection, and remember which one we picked
      var N = this.normal.elements, A = this.anchor.elements,
          O = obj.normal.elements, B = obj.anchor.elements;
      var solver = Matrix.Zero(2,2), i = 0;
      while (solver.isSingular()) {
        i++;
        solver = Matrix.create([
          [ N[i%3], N[(i+1)%3] ],
          [ O[i%3], O[(i+1)%3]  ]
        ]);
      }
      // Then we solve the simultaneous equations in the remaining dimensions
      var inverse = solver.inverse().elements;
      var x = N[0]*A[0] + N[1]*A[1] + N[2]*A[2];
      var y = O[0]*B[0] + O[1]*B[1] + O[2]*B[2];
      var intersection = [
        inverse[0][0] * x + inverse[0][1] * y,
        inverse[1][0] * x + inverse[1][1] * y
      ];
      var anchor = [];
      for (var j = 1; j <= 3; j++) {
        // This formula picks the right element from intersection by
        // cycling depending on which element we set to zero above
        anchor.push((i == j) ? 0 : intersection[(j + (5 - i)%3)%3]);
      }
      return Line.create(anchor, direction);
    }
  },

  // Returns the point in the plane closest to the given point
  pointClosestTo: function(point) {
    var P = point.elements || point;
    var A = this.anchor.elements, N = this.normal.elements;
    var dot = (A[0] - P[0]) * N[0] + (A[1] - P[1]) * N[1] + (A[2] - (P[2] || 0)) * N[2];
    return Vector.create([P[0] + N[0] * dot, P[1] + N[1] * dot, (P[2] || 0) + N[2] * dot]);
  },

  // Returns a copy of the plane, rotated by t radians about the given line
  // See notes on Line#rotate.
  rotate: function(t, line) {
    var R = Matrix.Rotation(t, line.direction).elements;
    var C = line.pointClosestTo(this.anchor).elements;
    var A = this.anchor.elements, N = this.normal.elements;
    var C1 = C[0], C2 = C[1], C3 = C[2], A1 = A[0], A2 = A[1], A3 = A[2];
    var x = A1 - C1, y = A2 - C2, z = A3 - C3;
    return Plane.create([
      C1 + R[0][0] * x + R[0][1] * y + R[0][2] * z,
      C2 + R[1][0] * x + R[1][1] * y + R[1][2] * z,
      C3 + R[2][0] * x + R[2][1] * y + R[2][2] * z
    ], [
      R[0][0] * N[0] + R[0][1] * N[1] + R[0][2] * N[2],
      R[1][0] * N[0] + R[1][1] * N[1] + R[1][2] * N[2],
      R[2][0] * N[0] + R[2][1] * N[1] + R[2][2] * N[2]
    ]);
  },

  // Returns the reflection of the plane in the given point, line or plane.
  reflectionIn: function(obj) {
    if (obj.normal) {
      // obj is a plane
      var A = this.anchor.elements, N = this.normal.elements;
      var A1 = A[0], A2 = A[1], A3 = A[2], N1 = N[0], N2 = N[1], N3 = N[2];
      var newA = this.anchor.reflectionIn(obj).elements;
      // Add the plane's normal to its anchor, then mirror that in the other plane
      var AN1 = A1 + N1, AN2 = A2 + N2, AN3 = A3 + N3;
      var Q = obj.pointClosestTo([AN1, AN2, AN3]).elements;
      var newN = [Q[0] + (Q[0] - AN1) - newA[0], Q[1] + (Q[1] - AN2) - newA[1], Q[2] + (Q[2] - AN3) - newA[2]];
      return Plane.create(newA, newN);
    } else if (obj.direction) {
      // obj is a line
      return this.rotate(Math.PI, obj);
    } else {
      // obj is a point
      var P = obj.elements || obj;
      return Plane.create(this.anchor.reflectionIn([P[0], P[1], (P[2] || 0)]), this.normal);
    }
  },

  // Sets the anchor point and normal to the plane. If three arguments are specified,
  // the normal is calculated by assuming the three points should lie in the same plane.
  // If only two are sepcified, the second is taken to be the normal. Normal vector is
  // normalised before storage.
  setVectors: function(anchor, v1, v2) {
    anchor = Vector.create(anchor);
    anchor = anchor.to3D(); if (anchor === null) { return null; }
    v1 = Vector.create(v1);
    v1 = v1.to3D(); if (v1 === null) { return null; }
    if (typeof(v2) == 'undefined') {
      v2 = null;
    } else {
      v2 = Vector.create(v2);
      v2 = v2.to3D(); if (v2 === null) { return null; }
    }
    var A1 = anchor.elements[0], A2 = anchor.elements[1], A3 = anchor.elements[2];
    var v11 = v1.elements[0], v12 = v1.elements[1], v13 = v1.elements[2];
    var normal, mod;
    if (v2 !== null) {
      var v21 = v2.elements[0], v22 = v2.elements[1], v23 = v2.elements[2];
      normal = Vector.create([
        (v12 - A2) * (v23 - A3) - (v13 - A3) * (v22 - A2),
        (v13 - A3) * (v21 - A1) - (v11 - A1) * (v23 - A3),
        (v11 - A1) * (v22 - A2) - (v12 - A2) * (v21 - A1)
      ]);
      mod = normal.modulus();
      if (mod === 0) { return null; }
      normal = Vector.create([normal.elements[0] / mod, normal.elements[1] / mod, normal.elements[2] / mod]);
    } else {
      mod = Math.sqrt(v11*v11 + v12*v12 + v13*v13);
      if (mod === 0) { return null; }
      normal = Vector.create([v1.elements[0] / mod, v1.elements[1] / mod, v1.elements[2] / mod]);
    }
    this.anchor = anchor;
    this.normal = normal;
    return this;
  }
};

// Constructor function
Plane.create = function(anchor, v1, v2) {
  var P = new Plane();
  return P.setVectors(anchor, v1, v2);
};

// X-Y-Z planes
Plane.XY = Plane.create(Vector.Zero(3), Vector.k);
Plane.YZ = Plane.create(Vector.Zero(3), Vector.i);
Plane.ZX = Plane.create(Vector.Zero(3), Vector.j);
Plane.YX = Plane.XY; Plane.ZY = Plane.YZ; Plane.XZ = Plane.ZX;

// Utility functions
var $V = Vector.create;
var $M = Matrix.create;
var $L = Line.create;
var $P = Plane.create;
</script>
<script>
var N3D = {
  Models:{},
  GetPageSize:function(){
    var d = document, e = d.documentElement, g = d.getElementsByTagName('body')[0];  
    return {
      width:window.innerWidth || e.clientWidth || g.clientWidth,    
      height:window.innerHeight|| e.clientHeight|| g.clientHeight
    };
  }
};
N3D.Error = function(name,message) {
    this.name = name;
    this.level = "Show Stopper";
    this.message =      message; 
    this.htmlMessage =  message;
};  
N3D.Error.prototype.toString =  function(){return this.name + ": " + this.message};

function extend(child,parent){
  var F = function(){};
  F.prototype = parent.prototype;
  child.prototype = new F(); 
  child.prototype.constructor = child; 
  return child.prototype;                                   
};


(function(){
  var head = document.getElementsByTagName("head")[0];
  var master_script = document.getElementsByTagName('script');
  master_script = master_script[master_script.length-1];
  var abs_path = master_script.src.match(/.*\//);
  abs_path = abs_path ? abs_path[0] : '/';

  /* >>>> Detect support render >>>> */           
  var supp = N3D.Support = {
    Canvas:false,
    WebGL:false,
    SVG:false,
    VML:false,
    toString:function(){
      return 'Context 2D: '+this.Canvas+'\n' + 
             'WebGL: '+this.WebGL+'\n' + 
             'SVG: '+this.SVG+'\n' +
             'VML: '+this.VML;
    } 
  };
  
  var canvas = document.createElement('canvas');
  
  /* Support Canvas */
  try{
    canvas.getContext('2d');    
    supp.Canvas = true; 
  }catch(e){} 
  
  
  /* Support WebGL */                            
  if(typeof WebGLRenderingContext !== 'undefined'){
    supp.WebGL = true;
  }else{
    var types = ['webgl','experimental-webgl'];
    for(var i=0;i<length;i++){
      try{
        var ctx = canvas.getContext(types[i]);
      
        supp.WebGL = true;
        break;
      }catch(e){}  
    }
  }
  
  /* Support SVG */
  supp.SVG = document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#Shape", "1.1")
  
  /* Support VML */
  var a = document.createElement('div');
  a.innerHTML = '<v:shape adj="1" />';
  var b = a.firstChild;
  b.style.behavior = "url(#default#VML)";
  supp.VML = b ? typeof b.adj == "object": true;
  /* <<<< Detect support render <<<< */  
  
  
function load(urls,callbacks){
  if(urls.length <= 0){
    if(callbacks.unloaded.length == 0){
      callbacks.success();
    }else{
      callbacks.error();
    }
    callbacks.complete();
    return;
  }
  var url = urls[0];
  urls.shift();
 
  if(document.getElementById(url) != null){ loader(urls,callbacks); return false;}

  var script = document.createElement('script');
  script.type = 'text/javascript';
  script.id = url;
  script.src = abs_path+url+'.js';
  head.appendChild(script);

  script.onreadystatechange = function(){
    if(script.readyState == 'loaded' || script.readyState == 'complete'){
      this.onreadystatechange = null; 
        
      load(urls,callbacks);        
    }
  };
  
  script.onerror = function(){
    callbacks.unloaded.push(this.id+' missing library file,'+this.src+' not a file'); 
    load(urls,callbacks);
    head.removeChild(this);
    return false;
  };
    
  script.onload = function(){
    load(urls,callbacks);
  };
};


N3D.require = function(){
  var urls = Array.prototype.slice.call(arguments);
  var callbacks = {
    complete: function(f){ this.complete = f || this.complete; },
    success: function(f){ this.success = f || this.success; },
    error: function(f){ this.error = f || this.error; },
    unloaded:[]
  };

  load(urls,callbacks);
  return callbacks;
};



function getAttr(el, attr) {
  var result;
  if(result = el[attr]){ return result; }
  if(el.getAttribute && (result = el.getAttribute(attr))){ return result;}
  var attrs = el.attributes;
  var length = attrs.length;

  for(var i = 0; i < length; i++){
    if(attrs[i].nodeName === attr){
      return attrs[i].nodeValue;
    }
  }
  return null;
};
  
  var require = getAttr(master_script,'require');
  
  if(require !== null){
    
    var req_load = N3D.require.apply(null,require.split(','));
    req_load.success(function(){
      var script = document.createElement('script');
      script.type = 'text/javascript';
     
      script.text = master_script.innerHTML;
      head.appendChild(script);
      
      master_script.parentNode.removeChild(master_script);
      
    });
    req_load.error(function(){
      console.log('error');
    })
  
  }
  
  N3D.SaveModel = function(name){
    var model = N3D.Models[name];
    var text = '{"vp":[1,2,3,4],"f":[0,1,2,0,2,3]}';
     
    if(model instanceof N3D.Geometry.Shapes){
      var a = document.createElement("a");
          a.download = name+'.json';
          a.href = 'data:text/javascript;charset=utf-8,'+text;
          a.style.display = "none";
          a.onclick = function(event){
            var event = event || window.event;
            var target = event.target || event.srcElement;
            document.body.removeChild(event.target);
          };
        
          document.body.appendChild(a);
          a.click();
      throw new N3D.Error('Model Exporter','export was successful');  
    }else{
      throw new N3D.Error('Model Exporter','Model "'+name+'" not found');
    }
  };

})();
</script>
<script>
/* >>>> Math.Main >>>> */
N3D.Math = (function(){
  var obj = {};
  var PI = Math.PI, floor = Math.floor, random = Math.random;
  var PI180 = PI/180, PI180_rev = 180/PI, sqrt5 = Math.sqrt(5);
  
  obj.Log10E = Math.LOG10E || 0.4342945;
  obj.Log2E = Math.LOG2E || 1.442695;
  obj.PiOver2 = PI*0.5;
  obj.PiOver4 = PI*0.25;
  obj.TwoPi = PI*2;
  obj.PiOver360 = PI/360;
  obj.PiOver180 = PI180;
  obj.Pi = PI;
  obj.AbsFloat = Math.abs;
  obj.Floor = floor;
  obj.Max = Math.max;
  obj.Min = Math.min;
  obj.Sqrt = Math.sqrt;
  obj.Pow = Math.pow;
  obj.Ceil = Math.ceil;
  obj.Round = Math.round;
  obj.Pow2 = function(n){ return n*n; };
  obj.Pow3 = function(n){ return n*n*n; };
  obj.Ceil2 = function(n){ return (~~n)+1; };
  obj.Floor2 = function(n){ return ~~n; };
  obj.RandomInt = function(min, max) {
    return min + floor(random() * (max - min + 1));
  };
  obj.RandomFloat = function(min, max) {
    return min + (random() * (max - min));
  };
  obj.AbsInt = function(n){
    var b = n >> 31; 
    return (n ^ b) - b;
  };
  
  obj.ToDegrees = function(d){
    return d * PI180_rev;
  };
  obj.ToRadians = function(d){
    return d * PI180;
  };
  
  obj.FromFibonacci = function(T){
    var phi = (1 + root5) / 2;

    var idx  = floor( Math.log(T*sqrt5) / Math.log(phi) + 0.5 );
    var u = floor( Math.pow(phi, idx)/sqrt5 + 0.5);

    return (u == T) ? idx : false;
  };
  
  obj.ToFibonacci = function(d){
    for(var a=0,b=1,c=0,f=1;f<d;f++){
      a = c + b;
      c = b;
      b = a;  
    }
    return a;
  };
  
  obj.Barycentric = function(v1,v2,v3,a1,a2){
    return v1 + (v2-v1) * a1 + (v3-v1) * a2;
  };
  
  obj.CatmullRom = function(v1, v2, v3, v4, a){
    var aS = a * a, aC = aS * a;
    return (0 * (2 * ve2 + (v3 - v1) * a + (2 * v1 - 5 * v2 + 4 * v3 - v4) * aS + (3 * v2 - v1 - 3 * v3 + v4) * aC));
  };
  
  obj.Clamp = function(v,min,max){
    return v > max ? max : (v < min ? min : v);
  };
  obj.Lerp = function(v1,v2,a){
    return v1 + (v2-v1) * a;
  };
  
  return obj;
})();
/* <<<< Math.Main <<<< */


/* >>>> Math.Matrix3 >>>> */
N3D.Math.Matrix3 = function(n0,n1,n2,n3,n4,n5,n6,n7,n8){
  this.m = [n0,n1,n2,n3,n4,n5,n6,n7,n8];

  return this;
};
N3D.Math.Matrix3.prototype = {
  constructor:N3D.Math.Matrix3,
  identity:function(){
    this.m = [
      1,0,0,
      0,1,0,
      0,0,1
    ]; 
    return this; 
  },
  determinant:function(){
  },
  inverse:function(){
    var m = this.m,
        m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3],
        m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7],
        m8 = m[8],
        a0 = (m8*m4-m7*m5),
        a1 = (m8*m1-m7*m2),
        a2 = (m5*m1-m4*m2);
    
    var det = 1/(m0*a0-m3*a1+m6*a2);
    
    m[0] =  a0*det;
    m[1] = -a1*det;
    m[2] =  a2*det;
    
    m[3] = -(m8*m3-m6*m5)*det;
    m[4] =  (m8*m0-m6*m2)*det;
    m[5] = -(m5*m0-m3*m2)*det;
    
    m[6] =  (m7*m3-m6*m4)*det;
    m[7] = -(m7*m0-m6*m1)*det;
    m[8] =  (m4*m0-m3*m1)*det; 

    return this;
  },
  multiply:function(n){
    var m = this.m,
        nm = n.m, 
        m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3],
        m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7],
        m8 = m[8],

        n0 = nm[0], n1 = nm[1], n2 = nm[2], n3 = nm[3],
        n4 = nm[4], n5 = nm[5], n6 = nm[6], n7 = nm[7],
        n8 = nm[8];
        
        
    m[0] = m0*n0 + m1*n3 + m2*n6;
    m[1] = m0*n1 + m1*n4 + m2*n7;
    m[2] = m0*n2 + m1*n5 + m2*n8;
      
    m[3] = m3*n0 + m4*n3 + m5*n6;
    m[4] = m3*n1 + m4*n4 + m5*n7;
    m[5] = m3*n2 + m4*n5 + m5*n8;  
    
    m[6] = m6*n0 + m7*n3 + m8*n6;
    m[7] = m6*n1 + m7*n4 + m8*n7;
    m[8] = m6*n2 + m7*n5 + m8*n8; 
      
   return this;
  },
  multiplyVector3:function(v){
    var m = this.m;
    var x = v.x, y = v.y, z = v.z;

    return new $V3(
      m[0] * x + m[3] * y + m[6] * z,
      m[1] * x + m[4] * y + m[7] * z,
      m[2] * x + m[5] * y + m[8] * z
    );
  },
  transpose:function(){
    var m = this.m;
    var a1 = m[1], a2 = m[2], a5 = m[3];
                
    m[1] = m[3];
    m[2] = m[6];
    m[5] = m[7];
    
    m[3] = a1;
    m[6] = a2;
    m[7] = a5;
    
    return this;    
  },
  scale:function(x,y,z){
    var m = this.m;
    m[0] *= x; m[1] *= y; m[2] *= z;
        m[3] *= x; m[4] *= y; m[5] *= z;
        m[6] *= x; m[7] *= y; m[8] *= z;
    
    return this;
  },
  rotateX: function(angle){
    var m = this.m;
    
    var c = Math.cos(angle);
    var s = Math.sin(angle);
    
    var m1 = m[1], m4 = m[4], m7 = m[7],
        m2 = m[2], m5 = m[5], m8= m[8];

    m[1] = m1 * c + m2 *s;
    m[4] = m4 * c + m5 *s;
    m[7] = m7 * c + m8*s;

    m[2] = m1 * -s + m2 * c;
    m[6] = m4 * -s + m5 * c;
    m[10]= m7 * -s + m8* c;

    return this;
  },
  rotateY: function(angle){
    var m = this.m;
    
    var c = Math.cos(angle);
    var s = Math.sin(angle);
    var m0 = m[0], m3 = m[3], m6 = m[6],
        m2 = m[2], m5 = m[5], m8= m[8];
    
    m[0] = m0 * c + m2 * -s;
    m[3] = m3 * c + m5 * -s;
    m[6] = m6 * c + m8* -s;

    m[2] = m0 *s + m2 * c;
    m[5] = m3 *s + m5 * c;
    m[8] = m6 *s + m8* c;

    return this;
  },
  rotateZ:function(angle){
    var m = this.m;
    
    var c = Math.cos(angle);
    var s = Math.sin(angle);
    var m0 = m[0], m3 = m[3], m6 = m[6],
        m1 = m[1], m4 = m[4], m7 = m[7];

    m[0] = m0 * c + m1 *s;
    m[3] = m3 * c + m4 *s;
    m[6] = m6 * c + m7 *s;

    m[1] = m0 * -s + m1 * c;
    m[4] = m3 * -s + m4 * c;
    m[7] = m6 * -s + m7 * c; 

    return this;
  },
  toString:function(){
    var m = this.m;
    return m[0].toFixed(4)+", "+m[1].toFixed(4)+", "+m[2].toFixed(4) + "\n" +
           m[3].toFixed(4)+", "+m[4].toFixed(4)+", "+m[5].toFixed(4) + "\n" + 
           m[6].toFixed(4)+", "+m[7].toFixed(4)+", "+m[8].toFixed(4) + "\n"; 
  }
};
N3D.Math.Matrix3.Identity = function(){
  return new this(1,0,0,0,1,0,0,0,1);
};

N3D.Math.Matrix3.FromMatrix4 = function(m){
  var m = m.m;
  
  return new this(
    m[0], m[1], m[2],
    m[4], m[5], m[6],
    m[8], m[9], m[10]
  );
};

N3D.Math.Matrix3.Inverse = function(m){
  var m = this.m,
        m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3],
        m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7],
        m8 = m[8],
        a0 = (m8*m4-m7*m5),
        a1 = (m8*m1-m7*m2),
        a2 = (m5*m1-m4*m2);
    
    var det = 1/(m0*a0-m3*a1+m6*a2);
    
    return new this(
        a0*det,           -a1*det,              a2*det,
      -(m8*m3-m6*m5)*det,  (m8*m0-m6*m2)*det, -(m5*m0-m3*m2)*det,
       (m7*m3-m6*m4)*det, -(m7*m0-m6*m1)*det,  (m4*m0-m3*m1)*det 
    );

    return this;
};
/* <<<< Math.Matrix3 <<<< */


/* >>>> Math.Matrix4 >>>> */
N3D.Math.Matrix4 = function(a00,a04,a08,a12,
                            a01,a05,a09,a13,
                            a02,a06,a10,a14,
                            a03,a07,a11,a15){
  this.elements =  [
    a00,a01,a02,a03,
    a04,a05,a06,a07,
    a08,a09,a10,a11,
    a12,a13,a14,a15
  ];
  return this;

};
N3D.Math.Matrix4.prototype = {
  constructor:N3D.Math.Matrix4,
  getTranslate:function(){
    var m = this.elements;
    return new $V4(m[12],m[13],m[14],m[15]);
  },
  clone:function(){  
    var m = this.elements;
    return new this.constructor(
      m[0],m[4],m[8],m[12],
      m[1],m[5],m[9],m[13],
      m[2],m[6],m[10],m[14],
      m[3],m[7],m[11],m[15]
    );
  },
  inverse:function(){ //zkontrolovat
    var m = this.elements, 
        m00 = m[0],  m04 = m[4],  m08 = m[8],  m12 = m[12],
        m01 = m[1],  m05 = m[5],  m09 = m[9],  m13 = m[13],
        m02 = m[2],  m06 = m[6],  m10 = m[10], m14 = m[14],
        m03 = m[3],  m07 = m[7],  m11 = m[11], m15 = m[15];
        
    
    var n0 =  m05 * (m10*m15 - m11*m14) - m06 * (m09*m15 - m11*m13) + m07 * (m09*m14 - m10*m13),
        n1 =  m04 * (m10*m15 - m11*m14) - m06 * (m08*m15 - m11*m12) + m07 * (m08*m14 - m10*m12),
        n2 =  m04 * (m09*m15 - m11*m13) - m05 * (m08*m15 - m11*m12) + m07 * (m08*m13 - m09*m12),
        n3 =  m04 * (m09*m14 - m10*m13) - m05 * (m08*m14 - m10*m12) + m06 * (m08*m13 - m09*m12),  
              
        invDet = 1/(m00*n0 - m01*n1 + m02*n2 - m03*n3);
    
    m[0]  =  n0*invDet;
    m[1]  = -n1*invDet;
    m[2]  =  n2*invDet;
    m[3]  = -n3*invDet;     
    
    m[4]  = -(m01 * (m10*m15 - m11*m14) - m02 * (m09*m15 - m11*m13) + m03 * (m09*m14 - m10*m13))*invDet;  
    m[5]  =  (m00 * (m10*m15 - m11*m14) - m02 * (m08*m15 - m11*m12) + m03 * (m08*m14 - m10*m12))*invDet;
    m[6]  = -(m00 * (m09*m15 - m11*m13) - m01 * (m08*m15 - m11*m12) + m03 * (m08*m13 - m09*m12))*invDet;
    m[7]  =  (m00 * (m09*m14 - m10*m13) - m01 * (m08*m14 - m10*m12) + m02 * (m08*m13 - m09*m12))*invDet;
    
    m[8]  =  (m01 * (m06*m15 - m07*m14) - m02 * (m05*m15 - m07*m13) + m03 * (m05*m14 - m06*m13))*invDet;
    m[9]  = -(m00 * (m06*m15 - m07*m14) - m02 * (m04*m15 - m07*m12) + m03 * (m04*m14 - m06*m12))*invDet;
    m[10] =  (m00 * (m05*m15 - m07*m13) - m01 * (m04*m15 - m07*m12) + m03 * (m04*m13 - m05*m12))*invDet;
    m[11] = -(m00 * (m05*m14 - m06*m13) - m01 * (m04*m14 - m06*m12) + m02 * (m04*m13 - m05*m12))*invDet;
    
    m[12] = -(m01 * (m06*m11 - m07*m10) - m02 * (m05*m11 - m07*m09) + m03 * (m05*m10 - m06*m09))*invDet;
    m[13] =  (m00 * (m06*m11 - m07*m10) - m02 * (m04*m11 - m07*m08) + m03 * (m04*m10 - m06*m08))*invDet;
    m[14] = -(m00 * (m05*m11 - m07*m09) - m01 * (m04*m11 - m07*m08) + m03 * (m04*m09 - m05*m08))*invDet;
    m[15] =  (m00 * (m05*m10 - m06*m09) - m01 * (m04*m10 - m06*m08) + m02 * (m04*m09 - m05*m08))*invDet; 

    return this;
  },
  inverseFast:function(){
    var m = this.elements, 
        m00 = m[0],  m04 = m[4],  m08 = m[8],  m12 = m[12],
        m01 = m[1],  m05 = m[5],  m09 = m[9],  m13 = m[13],
        m02 = m[2],  m06 = m[6],  m10 = m[10], m14 = m[14],
        m03 = m[3],  m07 = m[7],  m11 = m[11], m15 = m[15];
    
    
    var a0813 = m08 * m13, a0814 = m08 * m14, a0815 = m08 * m15,
        a0912 = m09 * m12, a0914 = m09 * m14, a0915 = m09 * m15,
        a1012 = m10 * m12, a1013 = m10 * m13, a1015 = m10 * m15,
        a1112 = m11 * m12, a1113 = m11 * m13, a1114 = m11 * m14;
        
    var n0 =  m05 * (a1015 - a1114) - m06 * (a0915 - a1113) + m07 * (a0914 - a1013),
        n1 =  m04 * (a1015 - a1114) - m06 * (a0815 - a1112) + m07 * (a0814 - a1012),
        n2 =  m04 * (a0915 - a1113) - m05 * (a0815 - a1112) + m07 * (a0813 - a0912),
        n3 =  m04 * (a0914 - a1013) - m05 * (a0814 - a1012) + m06 * (a0813 - a0912),  
              
        invDet = 1/(m00*n0 - m01*n1 + m02*n2 - m03*n3);
    
    m[0]  =  n0*invDet;
    m[1]  = -n1*invDet;
    m[2]  =  n2*invDet;
    m[3]  = -n3*invDet;     
    
    m[4]  = -(m01 * (a1015 - a1114) - m02 * (a0915 - a1113) + m03 * (a0914 - a1013))*invDet;  
    m[5]  =  (m00 * (a1015 - a1114) - m02 * (a0815 - a1112) + m03 * (a0814 - a1012))*invDet;
    m[6]  = -(m00 * (a0915 - a1113) - m01 * (a0815 - a1112) + m03 * (a0813 - a0912))*invDet;
    m[7]  =  (m00 * (a0914 - a1013) - m01 * (a0814 - a1012) + m02 * (a0813 - a0912))*invDet;
    
    m[8]  =  (m01 * (m06*m15 - m07*m14) - m02 * (m05*m15 - m07*m13) + m03 * (m05*m14 - m06*m13))*invDet;
    m[9]  = -(m00 * (m06*m15 - m07*m14) - m02 * (m04*m15 - m07*m12) + m03 * (m04*m14 - m06*m12))*invDet;
    m[10] =  (m00 * (m05*m15 - m07*m13) - m01 * (m04*m15 - m07*m12) + m03 * (m04*m13 - m05*m12))*invDet;
    m[11] = -(m00 * (m05*m14 - m06*m13) - m01 * (m04*m14 - m06*m12) + m02 * (m04*m13 - m05*m12))*invDet;
    
    m[12] = -(m01 * (m06*m11 - m07*m10) - m02 * (m05*m11 - m07*m09) + m03 * (m05*m10 - m06*m09))*invDet;
    m[13] =  (m00 * (m06*m11 - m07*m10) - m02 * (m04*m11 - m07*m08) + m03 * (m04*m10 - m06*m08))*invDet;
    m[14] = -(m00 * (m05*m11 - m07*m09) - m01 * (m04*m11 - m07*m08) + m03 * (m04*m09 - m05*m08))*invDet;
    m[15] =  (m00 * (m05*m10 - m06*m09) - m01 * (m04*m10 - m06*m08) + m02 * (m04*m09 - m05*m08))*invDet; 

    return this;
  },
  multiply:function(m2){
    var m1 = this.elements,
        m2 = m2.elements, 
      
        m1_00 = m1[0],  m1_04 = m1[4],  m1_08 = m1[8],  m1_12 = m1[12],
        m1_01 = m1[1],  m1_05 = m1[5],  m1_09 = m1[9],  m1_13 = m1[13],
        m1_02 = m1[2],  m1_06 = m1[6],  m1_10 = m1[10], m1_14 = m1[14],
        m1_03 = m1[3],  m1_07 = m1[7],  m1_11 = m1[11], m1_15 = m1[15], 
                                                   
        m2_00 = m2[0],  m2_04 = m2[4],  m2_08 = m2[8],  m2_12 = m2[12],
        m2_01 = m2[1],  m2_05 = m2[5],  m2_09 = m2[9],  m2_13 = m2[13],
        m2_02 = m2[2],  m2_06 = m2[6],  m2_10 = m2[10], m2_14 = m2[14],
        m2_03 = m2[3],  m2_07 = m2[7],  m2_11 = m2[11], m2_15 = m2[15];
      
    m1[0] = m1_00*m2_00 + m1_01*m2_04 + m1_02*m2_08 + m1_03*m2_12;
    m1[4] = m1_04*m2_00 + m1_05*m2_04 + m1_06*m2_08 + m1_07*m2_12;
    m1[8] = m1_08*m2_00 + m1_09*m2_04 + m1_10*m2_08 + m1_11*m2_12;
    m1[12] = m1_12*m2_00 + m1_13*m2_04 + m1_14*m2_08 + m1_15*m2_12;
    
    m1[1] = m1_00*m2_01 + m1_01*m2_05 + m1_02*m2_09 + m1_03*m2_13;
    m1[5] = m1_04*m2_01 + m1_05*m2_05 + m1_06*m2_09 + m1_07*m2_13;
    m1[9] = m1_08*m2_01 + m1_09*m2_05 + m1_10*m2_09 + m1_11*m2_13;
    m1[13] = m1_12*m2_01 + m1_13*m2_05 + m1_14*m2_09 + m1_15*m2_13;
    
    m1[2] = m1_00*m2_02 + m1_01*m2_06 + m1_02*m2_10 + m1_03*m2_14;
    m1[6] = m1_04*m2_02 + m1_05*m2_06 + m1_06*m2_10 + m1_07*m2_14;
    m1[10] = m1_08*m2_02 + m1_09*m2_06 + m1_10*m2_10 + m1_11*m2_14;
    m1[14] = m1_12*m2_02 + m1_13*m2_06 + m1_14*m2_10 + m1_15*m2_14;
    
    m1[3] = m1_00*m2_03 + m1_01*m2_07 + m1_02*m2_11 + m1_03*m2_15;
    m1[7] = m1_04*m2_03 + m1_05*m2_07 + m1_06*m2_11 + m1_07*m2_15;
    m1[11] = m1_08*m2_03 + m1_09*m2_07 + m1_10*m2_11 + m1_11*m2_15;
    m1[15] = m1_12*m2_03 + m1_13*m2_07 + m1_14*m2_11 + m1_15*m2_15;
    
    return this;
  },
  multiplyTranspose:function(m2){
    var m1 = this.elements,
        m2 = m2.elements, 
        m1_00 = m1[0],  m1_04 = m1[4],  m1_08 = m1[8],  m1_12 = m1[12],
        m1_01 = m1[1],  m1_05 = m1[5],  m1_09 = m1[9],  m1_13 = m1[13],
        m1_02 = m1[2],  m1_06 = m1[6],  m1_10 = m1[10], m1_14 = m1[14],
        m1_03 = m1[3],  m1_07 = m1[7],  m1_11 = m1[11], m1_15 = m1[15], 
                                                   
        m2_00 = m2[0],  m2_04 = m2[4],  m2_08 = m2[8],  m2_12 = m2[12],
        m2_01 = m2[1],  m2_05 = m2[5],  m2_09 = m2[9],  m2_13 = m2[13],
        m2_02 = m2[2],  m2_06 = m2[6],  m2_10 = m2[10], m2_14 = m2[14],
        m2_03 = m2[3],  m2_07 = m2[7],  m2_11 = m2[11], m2_15 = m2[15];

    m1[0] =   m1_00*m2_00 + m1_04*m2_01 + m1_08*m2_02 + m1_12*m2_03;
    m1[1] =   m1_01*m2_00 + m1_05*m2_01 + m1_09*m2_02 + m1_13*m2_03;
    m1[2] =   m1_02*m2_00 + m1_06*m2_01 + m1_10*m2_02 + m1_14*m2_03;
    m1[3] =  m1_03*m2_00 + m1_07*m2_01 + m1_11*m2_02 + m1_15*m2_03;
    
    m1[4] =   m1_00*m2_04 + m1_04*m2_05 + m1_08*m2_06 + m1_12*m2_07;
    m1[5] =   m1_01*m2_04 + m1_05*m2_05 + m1_09*m2_06 + m1_13*m2_07;
    m1[6] =   m1_02*m2_04 + m1_06*m2_05 + m1_10*m2_06 + m1_14*m2_07;
    m1[7] =  m1_03*m2_04 + m1_07*m2_05 + m1_11*m2_06 + m1_15*m2_07;    
    
    m1[8] =   m1_00*m2_08 + m1_04*m2_09 + m1_08*m2_10 + m1_12*m2_11;
    m1[9] =   m1_01*m2_08 + m1_05*m2_09 + m1_09*m2_10 + m1_13*m2_11;
    m1[10] =  m1_02*m2_08 + m1_06*m2_09 + m1_10*m2_10 + m1_14*m2_11;
    m1[11] =  m1_03*m2_08 + m1_07*m2_09 + m1_11*m2_10 + m1_15*m2_11;
    
    m1[12] =   m1_00*m2_12 + m1_04*m2_13 + m1_08*m2_14 + m1_12*m2_15;
    m1[13] =   m1_01*m2_12 + m1_05*m2_13 + m1_09*m2_14 + m1_13*m2_15;
    m1[14] =  m1_02*m2_12 + m1_06*m2_13 + m1_10*m2_14 + m1_14*m2_15;
    m1[15] =  m1_03*m2_12 + m1_07*m2_13 + m1_11*m2_14 + m1_15*m2_15;

    return this;
  },
  multiplyVector4:function(v){
    var x = v.x, y = v.y, z = v.z, w = v.w;
    var m = this.elements;

    return new v.constructor(
      m[0]*x + m[4]*y + m[8]*z + m[12]*w,
      m[1]*x + m[5]*y + m[9]*z + m[13]*w,
      m[2]*x + m[6]*y + m[10]*z + m[14]*w,
      m[3]*x + m[7]*y + m[11]*z + m[15]*w
    );
  },
  rotateX: function(radians){
    var m = this.elements;
    
    var c = Math.cos(radians);
    var s = Math.sin(radians);
    var m04 = m[4], m05 = m[5], m06 = m[6],  m07 = m[7],
        m08 = m[8], m09 = m[9], m10 = m[10], m11= m[11];
    
    
    m[4] = m04 * c + m08 * s; m[5] = m05 * c + m09 * s; m[6] = m06 * c + m10 * s; m[7] = m07 * c + m11 * s;
    m[8] = m04 * -s + m08 * c; m[9] = m05 * -s + m09 * c; m[10] = m06 * -s + m10 * c; m[11] = m07 * -s + m11 * c;
    
    return this;
  },
  rotateY: function(radians){
    var m = this.elements;
    
    var c = Math.cos(radians);
    var s = Math.sin(radians);
    var m00 = m[0], m01 = m[1], m02 = m[2], m03 = m[3],
        m08 = m[8], m09 = m[9], m10= m[10], m11= m[11];
    
    m[0] = m00 * c + m02 * -s; m[1] = m01 * c + m09 * -s; m[2] = m02 * c + m10* -s; m[3] = m03 * c + m11* -s;
    
    m[8] = m00 * s + m02 * c; m[9] = m01 * s + m09 * c; m[10]= m02 * s + m10* c; m[11] = m03 * s + m11* c;    

    return this;
  },
  rotateZ: function(radians){
    var m = this.elements;
    
    var c = Math.cos(radians);
    var s = Math.sin(radians);
    var m00 = m[0], m01 = m[1], m02 = m[2],  m03 = m[3],
        m04 = m[4], m05 = m[5], m06 = m[6],  m07 = m[7];
    
    m[0] = m00 * c + m04 * s; m[1] = m01 * c + m05 * s; m[2] = m02 * c + m06* s; m[3] = m03 * c + m07* s;
    m[4] = m00 * -s + m04 * c; m[5] = m01 * -s + m05 * c; m[6] = m02 * -s + m06* c; m[7] = m03 * -s + m07* c;

    return this;
  },  
  rotateAroundAxis:function(r,v){
    var c = Math.cos(r), s = Math.sin(r);
    
    var x = v.x,y = v.y, z = v.z, t = 1-c,
        xyt = x*y*t, xzt = x*z*t, yzt = y*z*t,
        xs = x*s, ys = y*s, zs = z*s;
        
    var m = this.elements, 
        m00 = m[0],  m04 = m[4],  m08 = m[8],  m12 = m[12],
        m01 = m[1],  m05 = m[5],  m09 = m[9],  m13 = m[13],
        m02 = m[2],  m06 = m[6],  m10 = m[10], m14 = m[14],
        m03 = m[3],  m07 = m[7],  m11 = m[11], m15 = m[15];
    
    var a00 = c+x*x*t, a04 = xyt-zs, a08 = xzt+ys,
        a01 = xyt+zs,  a05 = c+y*y*t,a09 = yzt-xs,
        a02 = xzt-ys,  a06 = yzt+xs, a10 = c+z*z*t;

    m[0] = m00*a00 + m01*a04 + m02*a08;
    m[4] = m04*a00 + m05*a04 + m06*a08;
    m[8] = m08*a00 + m09*a04 + m10*a08;
    m[12] = m12*a00 + m13*a04 + m14*a08;   
    
    m[1] = m00*a01 + m01*a05 + m02*a09;
    m[5] = m04*a01 + m05*a05 + m06*a09;
    m[9] = m08*a01 + m09*a05 + m10*a09;
    m[13] = m12*a01 + m13*a05 + m14*a09;
    
    m[2] = m00*a02 + m01*a06 + m02*a10;
    m[6] = m04*a02 + m05*a06 + m06*a10;
    m[10] = m08*a02 + m09*a06 + m10*a10;
    m[14] = m12*a02 + m13*a06 + m14*a10;

    return this;
  },
  scale:function(x,y,z){
    var m = this.elements;
    
    m[0] = m[0]*x;  m[4] = m[4]*y;  m[8] = m[8]*z;         
    m[1] = m[1]*x;  m[5] = m[5]*y;  m[9] = m[9]*z;
    m[2] = m[2]*x;  m[6] = m[6]*y;  m[10]= m[10]*z;
    m[3] = m[3]*x;  m[7] = m[7]*y;  m[11]= m[11]*z;   
    
    return this;
  },
  translate:function(x,y,z){
    var m = this.elements;
    
    m[12] = m[0]*x + m[4]*y + m[8]*z + m[12];
        m[13] = m[1]*x + m[5]*y + m[9]*z + m[13];
        m[14] = m[2]*x + m[6]*y + m[10]*z + m[14];
        m[15] = m[3]*x + m[7]*y + m[11]*z + m[15];
    
    return this;
  },
  transpose:function(){
    var m = this.elements;
    var a01 = m[1], a02 = m[2], a03 = m[3],
        a12 = m[6], a13 = m[7],
        a23 = m[11];
                
    m[1] = m[4]; m[2] = m[8]; m[3] = m[12];
    m[4] = a01;  m[6] = m[9]; m[7] = m[13];
    m[8] = a02;  m[9] = a12;  m[11] = m[14];
    m[12] = a03; m[13] = a13; m[14] = a23;
    
    return this;  
  },
  toQuaternion:function(){
    var m = this.elements, 
        m00 = m[0],  m04 = m[4],  m08 = m[8],
        m01 = m[1],  m05 = m[5],  m09 = m[9],
        m02 = m[2],  m06 = m[6],  m10 = m[10];
    var max = Math.max, sqrt = Math.sqrt;
    
    return new N3D_M_Quaternion(
      sqrt(max(0,1+m00-m05-m10))*0.5, //sqrt( max( 0, 1 + m00 - m11 - m22 ) ) / 2;
      sqrt(max(0,1-m00+m05-m10))*0.5, //sqrt( max( 0, 1 - m00 + m11 - m22 ) ) / 2;
      sqrt(max(0,1-m00-m05+m10))*0.5, //sqrt( max( 0, 1 - m00 - m11 + m22 ) ) / 2;
      sqrt(max(0,1+m00+m05+m10))*0.5  //sqrt( max( 0, 1 + m00 + m11 + m22 ) ) / 2;
    ); 
    
    /*    
    var trace = m[0] + m[5] + m[10];
    var s;
    
    if(trace>0){
      s = 0.5/Math.sqrt(trace+1);

      return new N3D_M_Vector4(
        (m[9] - m[6]) * s,
        (m[2] - m[8]) * s,
        (m[4] - m[1]) * s,
        0.25 / s
      );
    }else if((m00>m05) && (m00>m10)){
      s = 0.5/Math.sqrt(1 + m00 - m05 - m10)

      return new N3D_M_Vector4(
        0.25 / s,
        (m01 + m04) * s,
        (m02 + m08) * s,
        (m09 - m06) * s        
      );
      
    }else if(m05 > m10){
      s = 0.5/Math.sqrt(1 + m05 - m00 - m10);
      
      return new N3D_M_Vector4(
        (m01 + m04) * s,
        0.25 / s,
        (m06 + m09) * s,
        (m02 - m08) * s
      );
       
    }
    
    
    s = 0.5/Math.sqrt(1+m10 - m00 - m05);
    return new N3D_M_Vector4(
      (m02 + m08) * s,
      (m06 + m09) * s,
      0.25 / s,
      (m04 - m01) * s
    );
    */    
  },
  toString:function(){
    var e = this.elements;
    return '01: '+e[0].toFixed(3)+', 04: '+e[4].toFixed(3)+', 08: '+e[8].toFixed(3)+', 12: '+e[12].toFixed(3) + '\n' + 
           '02: '+e[1].toFixed(3)+', 05: '+e[5].toFixed(3)+', 09: '+e[9].toFixed(3)+', 13: '+e[13].toFixed(3) + '\n' + 
           '03: '+e[2].toFixed(3)+', 06: '+e[6].toFixed(3)+', 10: '+e[10].toFixed(3)+', 14: '+e[14].toFixed(3) + '\n' + 
           '04: '+e[3].toFixed(3)+', 07: '+e[7].toFixed(3)+', 11: '+e[11].toFixed(3)+', 15: '+e[15].toFixed(3);
  }
};

N3D.Math.Matrix4.Identity = function(){
  return new N3D_M_Matrix4(
    1,0,0,0,
    0,1,0,0,
    0,0,1,0,
    0,0,0,1
  );
};


N3D.Math.Matrix4.Multiply = function(m1,m2){
  var m1 = m1.elements,
      m2 = m2.elements, 
      
      m1_00 = m1[0],  m1_04 = m1[4],  m1_08 = m1[8],  m1_12 = m1[12],
      m1_01 = m1[1],  m1_05 = m1[5],  m1_09 = m1[9],  m1_13 = m1[13],
      m1_02 = m1[2],  m1_06 = m1[6],  m1_10 = m1[10], m1_14 = m1[14],
      m1_03 = m1[3],  m1_07 = m1[7],  m1_11 = m1[11], m1_15 = m1[15], 
                                                   
      m2_00 = m2[0],  m2_04 = m2[4],  m2_08 = m2[8],  m2_12 = m2[12],
      m2_01 = m2[1],  m2_05 = m2[5],  m2_09 = m2[9],  m2_13 = m2[13],
      m2_02 = m2[2],  m2_06 = m2[6],  m2_10 = m2[10], m2_14 = m2[14],
      m2_03 = m2[3],  m2_07 = m2[7],  m2_11 = m2[11], m2_15 = m2[15];
      
  return new N3D_M_Matrix4(
    m1_00*m2_00 + m1_01*m2_04 + m1_02*m2_08 + m1_03*m2_12,
    m1_04*m2_00 + m1_05*m2_04 + m1_06*m2_08 + m1_07*m2_12,
    m1_08*m2_00 + m1_09*m2_04 + m1_10*m2_08 + m1_11*m2_12,
    m1_12*m2_00 + m1_13*m2_04 + m1_14*m2_08 + m1_15*m2_12,
    
    m1_00*m2_01 + m1_01*m2_05 + m1_02*m2_09 + m1_03*m2_13,
    m1_04*m2_01 + m1_05*m2_05 + m1_06*m2_09 + m1_07*m2_13,
    m1_08*m2_01 + m1_09*m2_05 + m1_10*m2_09 + m1_11*m2_13,
    m1_12*m2_01 + m1_13*m2_05 + m1_14*m2_09 + m1_15*m2_13,
    
    m1_00*m2_02 + m1_01*m2_06 + m1_02*m2_10 + m1_03*m2_14,
    m1_04*m2_02 + m1_05*m2_06 + m1_06*m2_10 + m1_07*m2_14,
    m1_08*m2_02 + m1_09*m2_06 + m1_10*m2_10 + m1_11*m2_14,
    m1_12*m2_02 + m1_13*m2_06 + m1_14*m2_10 + m1_15*m2_14,
    
    m1_00*m2_03 + m1_01*m2_07 + m1_02*m2_11 + m1_03*m2_15,
    m1_04*m2_03 + m1_05*m2_07 + m1_06*m2_11 + m1_07*m2_15,
    m1_08*m2_03 + m1_09*m2_07 + m1_10*m2_11 + m1_11*m2_15,
    m1_12*m2_03 + m1_13*m2_07 + m1_14*m2_11 + m1_15*m2_15
  );   
};



N3D.Math.Matrix4.MultiplyTranspose = function(m1,m2){
  var m1 = m1.elements,
      m2 = m2.elements, 
      
      m1_00 = m1[0],  m1_04 = m1[4],  m1_08 = m1[8],  m1_12 = m1[12],
      m1_01 = m1[1],  m1_05 = m1[5],  m1_09 = m1[9],  m1_13 = m1[13],
      m1_02 = m1[2],  m1_06 = m1[6],  m1_10 = m1[10], m1_14 = m1[14],
      m1_03 = m1[3],  m1_07 = m1[7],  m1_11 = m1[11], m1_15 = m1[15], 
                                                   
      m2_00 = m2[0],  m2_04 = m2[4],  m2_08 = m2[8],  m2_12 = m2[12],
      m2_01 = m2[1],  m2_05 = m2[5],  m2_09 = m2[9],  m2_13 = m2[13],
      m2_02 = m2[2],  m2_06 = m2[6],  m2_10 = m2[10], m2_14 = m2[14],
      m2_03 = m2[3],  m2_07 = m2[7],  m2_11 = m2[11], m2_15 = m2[15];
    
  return new N3D_M_Matrix4(        
    m1_00*m2_00 + m1_04*m2_01 + m1_08*m2_02 + m1_12*m2_03,
    m1_00*m2_04 + m1_04*m2_05 + m1_08*m2_06 + m1_12*m2_07,
    m1_00*m2_08 + m1_04*m2_09 + m1_08*m2_10 + m1_12*m2_11,
    m1_00*m2_12 + m1_04*m2_13 + m1_08*m2_14 + m1_12*m2_15,
    
    m1_01*m2_00 + m1_05*m2_01 + m1_09*m2_02 + m1_13*m2_03,
    m1_01*m2_04 + m1_05*m2_05 + m1_09*m2_06 + m1_13*m2_07,
    m1_01*m2_08 + m1_05*m2_09 + m1_09*m2_10 + m1_13*m2_11,
    m1_01*m2_12 + m1_05*m2_13 + m1_09*m2_14 + m1_13*m2_15,
    
    m1_02*m2_00 + m1_06*m2_01 + m1_10*m2_02 + m1_14*m2_03,
    m1_02*m2_04 + m1_06*m2_05 + m1_10*m2_06 + m1_14*m2_07,
    m1_02*m2_08 + m1_06*m2_09 + m1_10*m2_10 + m1_14*m2_11,
    m1_02*m2_12 + m1_06*m2_13 + m1_10*m2_14 + m1_14*m2_15,
    
    m1_03*m2_00 + m1_07*m2_01 + m1_11*m2_02 + m1_15*m2_03,
    m1_03*m2_04 + m1_07*m2_05 + m1_11*m2_06 + m1_15*m2_07,
    m1_03*m2_08 + m1_07*m2_09 + m1_11*m2_10 + m1_15*m2_11,
    m1_03*m2_12 + m1_07*m2_13 + m1_11*m2_14 + m1_15*m2_15 
  );  
};

N3D.Math.Matrix4.CreateLookAt = function(eye,target,up){
  var f = N3D_M_Vector3.Sub(eye,target).normalize(),
      s = N3D_M_Vector3.Cross(up,f).normalize(),
      u = N3D_M_Vector3.Cross(f,s); 
      
  return new N3D_M_Matrix4(
    s.x,  u.x,  f.x,  -eye.x,
    s.y,  u.y,  f.y,  -eye.y,
    s.z,  u.z,  f.z,  -eye.z,
    0,    0,    0,    1 
  );
};

N3D.Math.Matrix4.CreateRotationX = function(r){
  var c = Math.cos(r), s = Math.sin(r);
  
  return new N3D_M_Matrix4(
    1,0,0,0,
    0,c,-s,0,
    0,s,c,0,
    0,0,0,1
  );
};


N3D.Math.Matrix4.CreateRotationY = function(r){
  var c = Math.cos(r), s = Math.sin(r);
  
  return new N3D_M_Matrix4(
    c,0,s,0,
    0,1,0,0,
    -s,0,c,0,
    0,0,0,1
  );
};
N3D.Math.Matrix4.CreateRotationZ = function(r){
  var c = Math.cos(r), s = Math.sin(r);
  
  return new N3D_M_Matrix4(
    c,-s,0,0,
    s,c,0,0,
    0,0,1,0,
    0,0,0,1
  );
};

N3D.Math.Matrix4.CreateRotationAroundAxis = function(r,v){
  var c = Math.cos(r), s = Math.sin(r);
  var x = v.x,y = v.y, z = v.z,
      t = 1-c,
      xyt = x*y*t, xzt = x*z*t, yzt = y*z*t,
      xs = x*s, ys = y*s, zs = z*s;
  
  return new N3D_M_Matrix4(
    c+x*x*t, xyt-zs,  xzt+ys,  0,
    xyt+zs,  c+y*y*t,  yzt-xs,  0,
    xzt-ys,  yzt+xs,  c+z*z*t,  0,
    0,        0,        0,        1
  );
};

N3D.Math.Matrix4.CreateScale = function(x,y,z){
  return new N3D_M_Matrix4(
    x,0,0,0,
    0,y,0,0,
    0,0,z,0,
    0,0,0,1
  );
};

N3D.Math.Matrix4.CreateTranslation = function(x,y,z){
  return new N3D_M_Matrix4(
    1,0,0,x,
    0,1,0,y,
    0,0,1,z,
    0,0,0,1
  );
};

N3D.Math.Matrix4.CreateFrustum = function(left,right,bottom,top,near,far){
  var rl = right - left,
      tb = top - bottom,
      fn = far - near,
      n2 = 2 * near;
  return new N3D_M_Matrix4(
    n2/rl,            0,                0,                0,
    0,                n2/tb,            0,                0,
    (right+left)/rl,  (top+bottom)/tb,  -(far+near)/fn,   -1,
    0,                0,                -n2*far/fn,         0
  );
};

N3D.Math.Matrix4.CreatePerspective = function(angle,aspectRatio,near,far){
  var scale = Math.tan(angle * N3D_M.PiOver360) * near,
      right = aspectRatio * scale,
      fn = far - near,
      tb = scale + scale,
      rl = right + right,
      n2 = 2 * near;
      
  return new N3D_M_Matrix4(
    n2/rl,  0,      (right-right)/rl,       0,
    0,      n2/tb,  (scale-scale)/tb,       0,
    0,      0,      -(far+near)/fn,         -1,
    0,      0,      -n2*far/fn,             0
  );
};

N3D.Math.Matrix4.CreatePerspective2 = function(angle,aspectRatio,near,far){
  var scale = Math.tan(angle * N3D_M.PiOver360) * near,
      right = aspectRatio * scale;

  return N3D_M_Matrix4.CreateFrustum(-right,right,-scale,scale,near,far);
};

N3D.Math.Matrix4.CreateOrthographic = function(l,r,b,t,n,f){
  var rl = r - l,
        tb = t - b,
        fn = f - n;
  
  return new N3D_M_Matrix4(
    2/rl,       0,          0,          0,
    0,          2/tb,       0,          0,
    0,          0,          -2/fn,      0,
    -(l+r)/rl,  -(t+b)/tb,  -(f+n)/fn,  1
  );
};

N3D.Math.Matrix4.CreateFromQuaternion = function(q){
  q.normalize();
  
  var x = q.x, y = q.y, z = q.z, w = 0;
  
  var xx = x*x, xy = x*y, xz = x*z, xw = x*w, 
      yy = y*y, yz = y*z, yw = y*w,
      zz = z*z, zw = z*w;
  
  return new N3D_M_Matrix4(
    1 - 2*(yy+zz),  2*(xy-zw),    2*(xz+yw),    0,
    2*(xy+zw),      1-2*(xx+zz),  2*(yz-xw),    0,
    2*(xz-yw),      2*(yz+xw),    1-2*(xx+yy),  0,
    0,              0,            0,            1 
     
  );
  /*var xx2 = 2*x*x, yy2 = 2*y*y, zz2 = 2*z*z;
  
  return new N3D_M_Matrix4(
    1-yy2 - zz2, 2*x*y - 2*z*w, 2*x*z + 2*y*w, 0,
    2*x*y + 2*z*w, 1-xx2 - zz2, 2*y*z - 2*x*w, 0,
    2*x*z - 2*y*w, 2*y*z + 2*x*w, 1-xx2 - yy2, 0,
    0,0,0,1 
  
  ); */
};
/* <<<< Math.Matrix4 <<<< */


/* >>>> Math.Vector2 >>>> */
N3D.Math.Vector2 = function(x,y){
  this.x = x;
  this.y = y;

  return this;
};
N3D.Math.Vector2.prototype = {
  constructor:N3D.Math.Vector2,
  xy:function(){
    return [this.x,this.y];
  },
  clone:function(){
    return new N3D_M_Vector2(this.x,this.y);
  },
  add:function(v){
    this.x += v.x;
    this.y += v.y;
    
    return this;
  },
  sub:function(v){
    this.x -= v.x;
    this.y -= v.y;
    
    return this;  
  },
  multiply:function(v){
    this.x *= v.x;
    this.y *= v.y;
    
    return this;  
  },
  scale:function(n){
    this.x *= n;
    this.y *= n;
    
    return this;
  },
  normalize:function(){
    var x = this.x,y = this.y;
    var length = Math.sqrt(x*x + y*y);
    
    this.x /= length;
    this.y /= length;
    
    return this; 
  },
  perpendicular:function(){
   var x = this.x,y = this.y;
   var scale_factor = 1 / Math.sqrt(x*x + y*y);
   
   this.x = -1 * y;
   this.y = x;
   
   return this;
  },
  divide:function(v){
    this.x /= v.x;
    this.y /= v.y;
    
    return this;  
  },
  rotate:function(angle){
    var x = this.x, y = this.y;
    
    var cos = Math.cos(angle);
    var sin = Math.sin(angle);
    
    this.x = x*cos - y*sin;
    this.y = x*sin + y*cos;
    
    return this;
  },
  dot:function(v){
    return (this.x * v.x + this.y * v.y);
  },
  toString:function(){
    return "N3D.Math.Vector2("+this.x+","+this.y+")";
  },
  negative:function(){
    return this.scale(-1);
  },
  equals:function(v){
    return (this.x == v.x && this.y == v.y);
  },
  distance:function(v){
    var x = this.x-v.x;
    var y = this.y-v.y;
    return Math.sqrt(x*x + y*y);
  }  
};
N3D.Math.Vector2.Equals = function(v1,v2){
  return (v1.x == v2.x && v1.y == v2.y);
};
N3D.Math.Vector2.Identity = function(){
  return new N3D_M_Vector2(0,0);
};
N3D.Math.Vector2.Add = function(v1,v2){
  return new N3D_M_Vector2(v2.x+v1.x,v2.y+v1.y);
};

N3D.Math.Vector2.MultiplyScalar = function(v,n){
  return new N3D_M_Vector2(v.x*n,v.y*n);
};
N3D.Math.Vector2.Dot = function(v1, v2){
  return (v1.x*v2.x + v1.y*v2.y);
};
N3D.Math.Vector2.Sub = function(v1,v2){
  return new N3D_M_Vector2(v1.x-v2.x,v1.y-v2.y);
};
N3D.Math.Vector2.Distance = function(v1,v2){
  var x = v1.x-v2.x, y = v1.y-v2.y;
  return Math.sqrt(x*x+y*y);
};
N3D.Math.Vector2.Cross = function(v1,v2){
  return new N3D_M_Vector2(
    v1.x*v2.y - v1.y*v2.x,
    v2.x*v1.y - v2.y*v1.x
  );
};

N3D.Math.Vector2.Lerp = function(v1,v2,a){
  return new N3D_M_Vector2(
    v1.x + (v2.x-v1.x) * a,
    v1.y + (v2.y-v1.y) * a,
    v1.z + (v2.z-v1.z) * a
  );
};

/* <<<< Math.Vector2 <<<< */

/* >>>> Math.Vector3 >>>> */
N3D.Math.Vector3 = function(x,y,z){
  this.x = x;
  this.y = y;
  this.z = z;
  
  return this;
};
N3D.Math.Vector3.prototype = {
  constructor:N3D.Math.Vector3,
  clone:function(){
    return new N3D_M_Vector3(this.x,this.y,this.z);
  },
  xyz:function(){
    return [this.x,this.y,this.z];
  },
  add:function(v){
    this.x += v.x;
    this.y += v.y;
    this.z += v.z;
    
    return this;
  },
  sub:function(v){
    this.x -= v.x;
    this.y -= v.y;
    this.z -= v.z;
    
    return this;
  },
  multiply:function(v){
    this.x *= v.x;
    this.y *= v.y;
    this.z *= v.z;
    
    return this;
  },
  scale:function(n){
    this.x *= n;
    this.y *= n;
    this.z *= n;
    
    return this;
  },
  cross:function(v){
    var x = this.x,y = this.y,z = this.z;
    
    this.x = y*v.z - z*v.y;
    this.y = z*v.x - x*v.z;
    this.z = x*v.y - y*v.x;
    
    return this;
  },
  dot:function(){
    var x = this.x,y = this.y,z = this.z;
    return (x*x + y*y + z*z);
  },
  length:function(){
    var x = this.x,y = this.y,z = this.z;
    return Math.sqrt(x*x + y*y + z*z);
  },
  normalize:function(){
    var x = this.x,y = this.y,z = this.z;
    var length = 1/Math.sqrt(x*x + y*y + z*z);
    
    this.x *= length;
    this.y *= length;
    this.z *= length;
    
    return this; 
  },
  negative:function(){
    this.x *= -1;
    this.y *= -1;
    this.z *= -1;
    return this;
  },
  rotateY:function(angle){
    var x = this.x, z = this.z;
    
    var c = Math.cos(angle),
        s = Math.sin(angle);
    
    this.x = z*s + x*c;
    this.z = z*c - x*s;    
    
    return this;
  },
  rounded:function(){
    this.x = ~~this.x;
    this.y = ~~this.y;
    this.z = ~~this.z;
    
    return this;
  },
  toRotationMatrix:function(r){
    var c = Math.cos(r), s = Math.sin(r);
    
    var x = this.x, y = this.y, z = this.z, t = 1-c,
        xyt = x*y*t, xzt = x*z*t, yzt = y*z*t,
        xs = x*s, ys = y*s, zs = z*s;

    return new N3D_M_Matrix4(
      c+x*x*t, xyt-zs,  xzt+ys,  0,
      xyt+zs,  c+y*y*t, yzt-xs,  0,
      xzt-ys,  yzt+xs,  c+z*z*t, 0,
      0,       0,       0,       1
    );
  },
  toVector4:function(n){
    return new N3D_M_Vector4(this.x,this.y,this.z,n);
  },
  toString:function(){
    return "N3D.Math.Vector3("+this.x+","+this.y+","+this.z+")";
  }
};
N3D.Math.Vector3.Perp = function(a,axis){
  var x = a.x, y = a.y, z = a.z;
  var par = N3D_M_Vector3.Parallel(a,axis);
  return new N3D_M_Vector3(
    x-par.x,
    y-par.y,
    z-par.z  
  );
};
N3D.Math.Vector3.Parallel = function(a,axis){
  var dot = N3D_M_Vector3.Dot(a,axis);
  var p = axis.clone();
  
  return new N3D_M_Vector3(
    axis.x*dot, axis.y*dot, axis.z*dot
  ); 
};
N3D.Math.Vector3.Identity = function(){
  return new N3D_M_Vector3(0,0,0);
};
N3D.Math.Vector3.Up = new N3D.Math.Vector3(0,1,0);
N3D.Math.Vector3.Right = new N3D.Math.Vector3(1,0,0);
N3D.Math.Vector3.Forward = new N3D.Math.Vector3(0,0,-1);

N3D.Math.Vector3.Lerp = function(v1,v2,a){
  var Lerp = N3D_M.Lerp;

  return new N3D_M_Vector3(
    Lerp(v1.x, v2.x, a),
    Lerp(v1.y, v2.y, a),
    Lerp(v1.z, v2.z, a)
  );
};
N3D.Math.Vector3.Max = function(v1,v2){
  return newN3D_M_Vector3(
    N3D_M.Max(v1.x, v2.x),
    N3D_M.Max(v1.y, v2.y),
    N3D_M.Max(v1.z, v2.z)
  );
};
N3D.Math.Vector3.Min = function(v1,v2){
  return new N3D_M_Vector3(
    N3D_M.Min(v1.x, v2.x),
    N3D_M.Min(v1.y, v2.y),
    N3D_M.Min(v1.z, v2.z)
  );
};
N3D.Math.Vector3.Herminte = function(v1,t1,v2,t2,a){
  return new N3D_M_Vector3(
    N3D_M.Hermite(v1.x, t1.x, v2.x, t2.x, a),
    N3D_M.Hermite(v1.y, t1.y, v2.y, t2.y, a),
    N3D_M.Hermite(v1.z, t1.z, v2.z, t2.z, a)
  );   
};
N3D.Math.Vector3.isZero = function(v){
  return (v.x == 0 && v.y == 0 && v.z==0);
};
N3D.Math.Vector3.Equals = function(v){
  return v instanceof N3D_M_Vector3;
};
N3D.Math.Vector3.DistanceSquared = function(v1,v2){
  return (v1.x-v2.x) * (v1.x-v2.x) + (v1.y-v2.y) * (v1.y-v2.y) + (v1.z-v2.z) * (v1.z-v2.z); 
};
N3D.Math.Vector3.Distance = function(v1,v2){
  return Math.sqrt((v1.x-v2.x) * (v1.x-v2.x) + (v1.y-v2.y) * (v1.y-v2.y) + (v1.z-v2.z) * (v1.z-v2.z));
};
N3D.Math.Vector3.Cross = function(v1, v2){
  return new N3D_M_Vector3(
    v1.y * v2.z - v1.z * v2.y,
    v1.z * v2.x - v1.x * v2.z,
    v1.x * v2.y - v1.y * v2.x  
  );
};
N3D.Math.Vector3.BaryCentric = function(v1,v2,v3,a1,a2,r){
  return new N3D_M_Vector3(
    N3D_M.Barycentric(v1.x, v2.x, v3.x, a1, a2),
    N3D_M.Barycentric(v1.y, v2.y, v3.y, a1, a2),
    N3D_M.Barycentric(v1.z, v2.z, v3.z, a1, a2)
  );
};

N3D.Math.Vector3.CatmullRom = function(v1,v2,v3,v4,a,r){
  return new N3D_M_Vector3(
    N3D_M.CatmullRom(v1.x, v2.x, v3.x, v4.x, a),
    N3D_M.CatmullRom(v1.y, v2.y, v3.y, v4.y, a),
    N3D_M.CatmullRom(v1.z, v2.z, v3.z, v4.z, a)
  );
};

N3D.Math.Vector3.Clamp = function(v1, min, max){
  return new N3D_M_Vector3(
    N3D_M.Clamp(v1.x, min.x, max.x),
    N3D_M.Clamp(v1.y, min.y, max.y),
    N3D_M.Clamp(v1.z, min.z, max.z)
  );
};
N3D.Math.Vector3.Dot = function(v1, v2){
  return (v1.x*v2.x + v1.y*v2.y + v1.z * v2.z);
};
N3D.Math.Vector3.Reflect = function(v,n){
  var dT = 2 * N3D_M_Vector3.Dot(v,n);
  return new N3D_M_Vector3(
    v.x - dT * n.x,
    v.y - dT * n.y,
    v.z - dT * n.z
  );
};
N3D.Math.Vector3.Add = function(v0,v1){
  return new N3D_M_Vector3(
    v0.x+v1.x,
    v0.y+v1.y,
    v0.z+v1.z  
  );
};

N3D.Math.Vector3.Sub = function(v0,v1){
  return new N3D_M_Vector3(
    v0.x-v1.x,
    v0.y-v1.y,
    v0.z-v1.z  
  );
};
N3D.Math.Vector3.MultiplyScalar = function(v0,n){
  return new N3D_M_Vector3(
    v0.x*n,
    v0.y*n,
    v0.z*n  
  );
};

N3D.Math.Vector3.SmoothStep = function(v1,v2,a){
  return new N3D_M_Vector3(
    N3D_M.SmoothStep(v1.x, v2.x, a),
    N3D_M.SmoothStep(v1.y, v2.y, a),
    N3D_M.SmoothStep(v1.z, v2.z, a)
  );
};

N3D_M_Vector3 = N3D.Math.Vector3;
/* <<<< Math.Vector3 <<<< */

/* >>>> Math.Vector4 >>>> */
N3D.isLoaded = true;

N3D.Math.Vector4 = function(x,y,z,w){
  this.x = x;
  this.y = y;
  this.z = z;
  this.w = w;
  
  return this;
};
N3D.Math.Vector4.prototype = {
  constructor:N3D.Math.Vector4,
  clone:function(){
    return new N3D.Math.Vector4(this.x,this.y,this.z,this.w);
  },
  xyz:function(){
    return [this.x,this.y,this.z];
  },
  xyzw:function(){
    return [this.x,this.y,this.z,this.w];
  },
  add:function(v){
    this.x += v.x;
    this.y += v.y;
    this.z += v.z;
    this.w += v.w;
    
    return this;
  },
  sub:function(v){
    this.x -= v.x;
    this.y -= v.y;
    this.z -= v.z;
    this.w -= v.w;
    
    return this;
  },
  multiply:function(v){
    this.x *= v.x;
    this.y *= v.y;
    this.z *= v.z;
    this.w *= v.w;
    
    return this;
  },
  scale:function(n){
    this.x *= n;
    this.y *= n;
    this.z *= n;
    this.w *= n;
    
    return this;
  },
  divide:function(v){
    this.x /= v.x;
    this.y /= v.y;
    this.z /= v.z;
    this.w /= v.w;
    
    return this;
  },
  divideScalar:function(n){
    return this.multiplyScalar(1/n);
  },
  dot:function(v){
    return (this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w);
  },
  normalize:function(){
    var x = this.x, y = this.y, z = this.z, w = this.w;
    var f = 1/Math.sqrt(x*x+y*y+z*z+w*w);
    this.x *= f;
    this.y *= f;
    this.z *= f;
    this.w *= f;
    
    return this;
  },
  length:function(){
    var x = this.x, y = this.y, z = this.z, w = this.w;
    return Math.sqrt(x*x+y*y+z*z+w*w);
  },
  multiplyMatrix4:function(m){
    var m = m.elements;
    var x = this.x, y = this.y, z = this.z,w = this.w;
    
    this.x = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
    this.y = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
    this.z = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
    this.w = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
   
    return this; 
  },
  copyFromVector4:function(o){
    this.x = o.x;
    this.y = o.y;
    this.z = o.z;
    this.w = o.w;
    
    return this;
  },
  toHomogenous: function(width,height){
    var invW = 1/this.w;
    
    var x = this.x*invW,
        y = this.y*invW,
        z = this.z*invW;

    if(-1 < x && x < 1 && -1 < y && y < 1 && -1 < z && z < 1){
      this.x = ~~((x+1)*(width*0.5)); 
      this.y = ~~((y+1)*(height*0.5));
      this.z = z; 
      this.draw = true;
      return this;  
    }
  
    this.draw = false;
    
    return false;
  },
  toString:function(){
    return "Vector4("+this.x+","+this.y+","+this.z+","+this.w+")";
  }
};
N3D.Math.Vector4.Identity = function(){
  return new this(0,0,0,1);
};
N3D.Math.Vector4.CreateFromVector3 = function(v,n){
  return new this(v.x,v.y,v.z,n);
};

N3D.Math.Vector4.Lerp = function(v1,v2,a){
  var Lerp = N3D_M.Lerp;

  return new $V4(
    Lerp(v1.x, v2.x, a),
    Lerp(v1.y, v2.y, a),
    Lerp(v1.z, v2.z, a),
    Lerp(v1.w, v2.w, a)
  );
};

N3D.Math.Vector4.Multiply = function(v1,v2){
  return new this(
    v1.x*v2.x,
    v1.y*v2.y,
    v1.z*v2.z,
    v1.w*v2.w
  );
};

N3D.Math.Vector4.Equals = function(v){
  return v instanceof this;
};
N3D.Math.Vector4.Add = function(v1,v2){
  return new this(
    v1.x+v2.x,
    v1.y+v2.y,
    v1.z+v2.z,
    v1.w+v2.w
  );
};
N3D.Math.Vector4.Sub = function(v1,v2){
  return new this(
    v1.x-v2.x,
    v1.y-v2.y,
    v1.z-v2.z,
    v1.w-v2.w  
  );
};

N3D.Math.Vector4.Projection = function(p,viewport){
  var viewport = viewport || $Game.viewport;
  p.divideNumber(p.w);
  var w = 1;
  
  if(-w <= p.x <= w && -w <= p.y <= w && -w <= p.z <= w){
    var x = (p.x+1)*(viewport.width*0.5); 
    var y = (p.y+1)*(viewport.height*0.5);
    var v = new $V2(~~x,~~y);
    v.z = p.z;
    return v;  
  }
  
  return false;
}; 
/* <<<< Math.Vector4 <<<< */

/* >>>> Math.Quaternion >>>> */
N3D.Math.Quaternion = function(x,y,z,w){
  this.x = x;
  this.y = y;
  this.z = z;
  this.w = w;
};
N3D.Math.Quaternion.prototype = {
  conjugate:function(){
    this.x *= -1;
    this.y *= -1;
    this.z *= -1;
    
    return this;
  },
  scale:function(n){
    this.x *= n;
    this.y *= n;
    this.z *= n;
    this.w *= n;
  },
  multiply:function(q){
    var q1x = this.x, q1y = this.y, q1z = this.z, q1w = this.w;
    var q2x = q.x, q2y = q.y, q2z = q.z, q2w = q.w;
    
    this.x =  q1x * q2w + q1y * q2z - q1z * q2y + q1w * q2x;
    this.y = -q1x * q2z + q1y * q2w + q1z * q2x + q1w * q2y;
    this.z =  q1x * q2y - q1y * q2x + q1z * q2w + q1w * q2z;
    this.w = -q1x * q2x - q1y * q2y - q1z * q2z + q1w * q2w;
    
    return this;
  },
  add:function(q){
    this.x += q.x;
    this.y += q.y;
    this.z += q.z;
    this.w += q.w;
    
    return this;
  },
  toMatrix4:function(){
    var x = this.x, y = this.y, z = this.z, w = this.w;
    
    var xx = x*x, xy = x*y, xz = x*z, xw = x*w;
    var yy = y*y, yz = y*z, yw = y*w;
    var zz = z*z, zw = z*w;

    
    return new N3D_M_Matrix4(
      1 - 2*yy - 2*zz,  2*xy - 2*zw,      2*xz + 2*yw,      0,
      2*xy + 2*zw,      1 - 2*xx - 2*zz,  2*yz - 2*xw,      0,
      2*xz - 2*yw,      2*yz + 2*xw,      1 - 2*xx - 2*yy,  0,
      0,                0,                0,                1
    );
  },
  identity:function(){
    this.x = 0;
    this.y = 0;
    this.z = 0;
    this.w = 1;
    
    return this;
  },
  toTransposedMatrix4:function(){
    var x = this.x, y = this.y, z = this.z, w = this.w;
    
    var xx = x*x, xy = x*y, xz = x*z, xw = x*w;
    var yy = y*y, yz = y*z, yw = y*w;
    var zz = z*z, zw = z*w;
    
    return new N3D_M_Matrix4(
      1 - 2*yy - 2*zz,  2*xy + 2*zw,      2*xz - 2*yw,        0,
      2*xy - 2*zw,      1 - 2*xx - 2*zz,  2*yz + 2*xw,        0,
      2*xz + 2*yw,      2*yz - 2*xw,      1 - 2*xx - 2*yy,    0,
      0,                0,                0,                  1 
    );
  },
  toAngleAxis:function(){
    var x = this.x, y = this.y, z = this.z, w = this.w;
    var scale = Math.sqrt(x*x + y*y + z*z);

    if (scale == 0 || w > 1 || w < -1){
      return {
        angle:0,
        axis:new N3D_M_Vector3(
          0,1,0
        )
      };
    }
    
    var invscale = 1/scale;

    return {
      angle:2 * Math.acos(w),
      axis:new N3D_M_Vector3(
        x * invscale,
        y * invscale,
        z * invscale
      )
    };
  },
  toAngles:function(){
    var x = this.x, y = this.y, z = this.z;
    
    return new N3D_M_Vector3(
      Math.atan(2*(x*y + z*w)/(1-2*(y*y+z*z))),
      Math.asin(2*(x*z - w*y)),
      Math.atan(2*(x*w +y*z)/(1-2*(z*z + w*w)))
    );
  },
  toString:function(){
    return "Quaternion("+this.x+","+this.y+","+this.z+","+this.w+")";
  }
};

N3D.Math.Quaternion.prototype.dot = N3D.Math.Vector4.prototype.dot;
N3D.Math.Quaternion.Equals = N3D.Math.Vector4.Equals;
N3D.Math.Quaternion.prototype.inverse = N3D.Math.Quaternion.prototype.conjugate;
N3D.Math.Quaternion.prototype.normalize = N3D.Math.Vector4.prototype.normalize;
N3D.Math.Quaternion.CreateFromAngles = function(x,y,z){
  x *= 0.5, y *= 0.5, z *= 0.5;
  var cos_x_2 = Math.cos(x), sin_x_2 = Math.sin(x),
      cos_y_2 = Math.cos(y), sin_y_2 = Math.sin(y),
      cos_z_2 = Math.cos(z), sin_z_2 = Math.sin(z);
  
  return new N3D_M_Quaternion(
    cos_z_2*cos_y_2*sin_x_2 - sin_z_2*sin_y_2*cos_x_2,
    cos_z_2*sin_y_2*cos_x_2 + sin_z_2*cos_y_2*sin_x_2,
    sin_z_2*cos_y_2*cos_x_2 - cos_z_2*sin_y_2*sin_x_2,
    cos_z_2*cos_y_2*cos_x_2 + sin_z_2*sin_y_2*sin_x_2
  );
};
N3D.Math.Quaternion.Lerp = function(q1,q2,time){
  var scale = 1 - time;

  return new N3D_M_Quaternion(
    q1.x*scale + q2.x*time,
    q1.y*scale + q2.y*time,
    q1.z*scale + q2.z*time,
    q1.w*scale + q2.w*time
  );
};
N3D.Math.Quaternion.Dot = function(q1,q2){
  var x1 = q1.x, y1 = q1.y, z1 = q1.z, w1 = q1.w;
  var x2 = q2.x, y2 = q2.y, z2 = q2.z, w2 = q2.w;
  
  return x1*x2 + y1*y2 + z1*z2 + w1*w2; 
};
N3D.Math.Quaternion.Slerp = function(q1,q2,time,threshold){
  var angle = q1.dot(q2);

  // make sure we use the short rotation
  if (angle < 0){
    q1.scale(-1);
    angle *= -1;
  }
  
  if (angle <= (1-threshold)){ // spherical interpolation
      var theta = Math.acos(angle);
      var invsintheta = 1/Math.sin(theta);
      var scale = Math.sin(theta * (1-time)) * invsintheta;
      var invscale = Math.sin(theta * time) * invsintheta;
      
      
      return new N3D_M_Quaternion(
        q1.x*scale + q2.x*invscale,
        q1.y*scale + q2.y*invscale,
        q1.z*scale + q2.z*invscale,
        q1.w*scale + q2.w*invscale
      );
  }
  // linear interploation
  return N3D_M_Quaternion.Lerp(q1,q2,time);
};

N3D.Math.Quaternion.CreateFromAngles2 = function(x,y,z){
  x *= 0.5, y *= 0.5, z *= 0.5;
  
  var sx = Math.sin(x), cx = Math.cos(x),
      sy = Math.sin(y), cy = Math.cos(y),
      sz = Math.sin(z), cz = Math.cos(z),
      
      cycz = cy * cz, sycz = sy * cz,
      cysz = cy * sz, sysz= sy * sz;
  
  return new N3D_M_Quaternion(
    sx * cycz - cx * sysz,
    cx * sycz + sx * cysz,
    cx * cysz - sx * sycz,
    cx * cycz + sx * sysz
  );
};

N3D.Math.Quaternion.CreateFromAngles3 = function(x,y,z){
  x *= 0.5, y *= 0.5, z *= 0.5;
  
  var c1 = Math.cos(y), s1 = Math.sin(y),
      c2 = Math.cos(z), s2 = Math.sin(z),
      c3 = Math.cos(x), s3 = Math.sin(x),
      c1c2 = c1*c2,     s1s2 = s1*s2;
  
  return new N3D_M_Quaternion(
    c1c2*s3 + s1s2*c3,
      s1*c2*c3 + c1*s2*s3,
    c1*s2*c3 - s1*c2*s3,
    c1c2*c3 - s1s2*s3
  );
};

N3D.Math.Quaternion.CreateFromAngles4 = function(x,y,z){
  x *= 0.5, y *= 0.5, z *= 0.5, w = 0;
  
  var cx = Math.cos(x), sx = Math.sin(x),
      cy = Math.cos(y), sy = Math.sin(y),
      cz = Math.cos(z), sz = Math.sin(z);
      
      
  

  return new N3D_M_Quaternion(
    cz*cx*cy-sz*sx*sy,
    sz*cx*cy+cz*sx*sy,
    cz*sx*cy-sz*cx*sy,
    cz*cx*sy+sz*sx*cy 
  );
};


N3D_M = N3D.Math;
$M4 = N3D_M_Matrix4 = N3D.Math.Matrix4; 
$M3 = N3D_M_Matrix3 = N3D.Math.Matrix3;
$V2 = N3D_M_Vector2 = N3D.Math.Vector2;
$V3 = N3D_M_Vector3 = N3D.Math.Vector3; 
$V4 = N3D_M_Vector4 = N3D.Math.Vector4;
N3D_M_Quaternion = N3D.Math.Quaternion;
</script>
<script>
goog.require('goog.math.Vec3');
goog.require('goog.math.Matrix');
//N3D.require("Math.Vector3");
</script>
<script>

"use strict";
class CVec{
    constructor(x,y,z){ 
        this.x = x; 
        this.y = y; 
        this.z = z; 
    }

    add(v2){
      this.x+=v2.x;
      this.y+=v2.y;
      this.z+=v2.z;
    }

    normalize(){
      let xx = this.x*this.x; 
      let yy = this.y*this.y;
      let zz = this.z*this.z;
      let invnorm = 1.0/Math.sqrt(xx+yy+zz);
      this.x*=invnorm;
      this.y*=invnorm;
      this.z*=invnorm;
    }
    cross(v2){
      let ax = this.x, ay = this.y, az = this.z;
      let bx = v2.x, by = v2.y, bz = v2.z;
      this.x = ay * bz - az * by;
      this.y = az * bx - ax * bz;
      this.z = ax * by - ay * bx;
    }

}
</script>

Script Preparation code:

var mArrData = [0, 0, 0, 0, 0, 0, 0, 0, 0];
var m1ArrData = [0, 0, 0, 0, 0, 0, 0, 0, 0];
var mData = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
var m1Data = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];

for(var i = 0; i < 9; i++) {
    mArrData[i] = Math.random();
    m1ArrData[i] = Math.random();
}

for(var i = 0; i < 3; i++) {
    for(var j = 0; j < 3; j++) {
        mData[i][j] = mArrData[i + j];
        m1Data[i][j] = m1ArrData[i + j];
    }
}

Tests:

Vanilla
let v1 = [1, 2, 3]; let v2 = [4, 5, 6]; // add v1[0] += v2[0]; v1[1] += v2[1]; v1[2] += v2[2]; // normalize let invLength = 1 / Math.sqrt(v1[0] * v1[0] + v1[1] * v1[1] + v1[2] * v1[2]); v1[0] *= invLength; v1[1] *= invLength; v1[2] *= invLength; // cross let ax = v1[0], ay = v1[1], az = v1[2]; let bx = v2[0], by = v2[1], bz = v2[2]; v1[0] = ay * bz - az * by; v1[1] = az * bx - ax * bz; v1[2] = ax * by - ay * bx; floatArray[index] = floatArray[index] + v1[0] - v1[0] + v1[0]; index = (index + 1) % defaultCount;
glmatrix
var v1 = vec3.fromValues(1,2,3); var v2 = vec3.fromValues(4,5,6); vec3.add(v1, v2, v1); vec3.normalize(v1, v1); vec3.cross(v1, v2, v1); floatArray[index] = floatArray[index] + v1[0] - v1[0] + v1[0]; index = (index + 1) % defaultCount;
ES6 class
var v1 = new CVec(1,2,3); var v2 = new CVec(4,5,6); v1.add(v2); v1.normalize(); v1.cross(v2); floatArray[index] = floatArray[index] + v1.x - v1.y + v1.z; index = (index + 1) % defaultCount;
No Array
let v1x = 1, v1y = 2, v1z = 3; let v2x = 4, v2y = 5, v2z = 6; // add v1x += v2x; v1y += v2y; v1z += v2z; // normalize let invLength = 1 / Math.sqrt(v1x * v1x + v1y * v1y + v1z * v1z); v1x *= invLength; v1y *= invLength; v1z *= invLength; // cross let ax = v1x, ay = v1y, az = v1z; let bx = v2x, by = v2y, bz = v2z; v1x = ay * bz - az * by; v1y = az * bx - ax * bz; v1z = ax * by - ay * bx; floatArray[index] = floatArray[index] + v1x - v1y + v1z; index = (index + 1) % defaultCount;
N3D
var v1 = new $V3(1,2,3); var v2 = new $V3(4,5,6); v1.add(v2); v1.normalize(); v1.cross(v2); floatArray[index] = floatArray[index] + v1.x - v1.y + v1.z; index = (index + 1) % defaultCount;
Closure
var v1 = new goog.math.Vec3(1,2,3); var v2 = new goog.math.Vec3(4,5,6); v1.add(v2); v1.normalize(); v1 = goog.math.Vec3.cross(v2, v1); floatArray[index] = floatArray[index] + v1.x - v1.y + v1.z; index = (index + 1) % defaultCount;

Run results for: WebGL math library comparison

Vanilla

glmatrix

ES6 class

No Array

N3D

Closure