jax 1.1.1 → 2.0.0

data/lib/assets/javascripts/jax/core/base.js

@@ -0,0 +1,69 @@
+/**
+ * Jax
+ * Root namespace containing all Jax data
+ **/
+var Jax = {
+  PRODUCTION: 1,
+  
+  VERSION: "<%=JAX_VERSION%>",
+  
+  webgl_not_supported_path: null,
+  
+  /**
+   * Global
+   * Objects and functions defined here are available in the global scope.
+   **/
+  getGlobal: function() {
+    var g;
+    if (typeof(global) != 'undefined') g = global;
+    else g = window;
+
+    Jax.getGlobal = function() { return g; };
+    return Jax.getGlobal();
+  },
+  
+  /**
+   * Jax.reraise(old_error, new_error) -> error
+   * - old_error (Error): the original exception that was raised
+   * - new_error (Error): the error to be raised in its place
+   *
+   * Copies the backtrace from the old error into the new error, if available.
+   * Since some browsers do not support assignment to the +stack+ attribute
+   * of an error, this is stored in the +_stack+ attribute instead.
+   *
+   * After the copy has been performed, the new error is thrown
+   **/
+  reraise: function(original_error, new_error) {
+    if (original_error._stack) new_error._stack = original_error._stack;
+    else if (original_error.stack) new_error._stack = original_error.stack;
+    throw new_error;
+  },
+  
+  /**
+   * Jax.click_speed = 0.2
+   *
+   * Think of an input button. The 'mouse_clicked' event fires after the button has been
+   * depressed, regardless of how long the button has been held down. However, in
+   * terms of UI events, a "mouse clicked" event generally corresponds to a mouse
+   * button press followed by a mouse button release within a relatively short
+   * timeframe.
+   *
+   * In order to prevent 'mouse_clicked' events from interfering with other button-related
+   * events, such as 'mouse_dragged', Jax imposes a UI-like click speed. If the
+   * 'mouse_clicked' event is not received within this number of seconds from the
+   * previous 'mouse_pressed' event, it will be ignored.
+   *
+   * To revert to HTML-style, button-like clicking, simply set this number to +null+.
+   *
+   **/
+  click_speed: 0.2,
+};
+
+// note: the default_shader is used immediately after Jax.Material has been defined. So, most
+// likely the end user won't be able to customize it with the expected result. Materials created
+// *after* the default shader has been changed are fine, but materials already existing
+// (such as "default") will continue to use the previous default. If default material init can be deferred
+// until first use (e.g. upon first call to model#render), then we can expose this variable.
+// Since materials are generally meant to maintain their own shaders, it may not be desirable to
+// expose it in any case.
+Jax.default_shader = "basic";

data/lib/assets/javascripts/jax/core/glMatrix_ext/mat3.js

@@ -0,0 +1,20 @@
+/**
+ * mat3.multiplyVec3(matrix, vec[, dest]) -> vec3
+ * - matrix (mat3): the 3x3 matrix to multiply against
+ * - vec (vec3): the vector to multiply
+ * - dest (vec3): an optional receiving vector. If not given, vec is used.
+ *
+ * Transforms the vec3 according to this rotation matrix. Returns +dest+.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+mat3.multiplyVec3 = function(matrix, vec, dest) {
+  if (!dest) dest = vec;
+  
+  dest[0] = vec[0] * matrix[0] + vec[1] * matrix[3] + vec[2] * matrix[6];
+  dest[1] = vec[0] * matrix[1] + vec[1] * matrix[4] + vec[2] * matrix[7];
+  dest[2] = vec[0] * matrix[2] + vec[1] * matrix[5] + vec[2] * matrix[8];
+  
+  return dest;
+};

data/lib/assets/javascripts/jax/core/glMatrix_ext/mat4.js

@@ -0,0 +1,10 @@
+/**
+ * mat4.IDENTITY -> mat4
+ *
+ * Represents a 4x4 Identity matrix.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+mat4.IDENTITY = mat4.identity(mat4.create());
+

data/lib/assets/javascripts/jax/core/glMatrix_ext/quat4.js

@@ -0,0 +1,148 @@
+/**
+ * quat4.fromAxes(view, right, up[, dest]) -> quat4
+ * - view (vec3): the view vector
+ * - right (vec3): the right vector
+ * - up (vec3): the up vector
+ * - dest (quat): an optional receiving quat4. If omitted, a new one is created.
+ *
+ * Creates a quaternion from the 3 given vectors. They must be perpendicular
+ * to one another.
+ **/
+quat4.fromAxes = function(view, right, up, dest) {
+  var mat = quat4.fromAxes.mat = quat4.fromAxes.mat || mat3.create();
+  
+  mat[0] = right[0];
+  mat[3] = right[1];
+  mat[6] = right[2];
+
+  mat[1] = up[0];
+  mat[4] = up[1];
+  mat[7] = up[2];
+
+  mat[2] = view[0];
+  mat[5] = view[1];
+  mat[8] = view[2];
+
+  quat4.fromRotationMatrix(mat, dest);
+};
+
+/**
+ * quat4.fromRotationMatrix(mat[, dest]) -> quat4
+ * - mat (mat3): a 3x3 rotation matrix
+ * - dest (quat4): an optional receiving quat4. If omitted, a new one is created.
+ *
+ * Creates a quaternion from the given rotation matrix.
+ **/
+quat4.fromRotationMatrix = function(mat, dest) {
+  if (!dest) dest = quat4.create();
+  
+  // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
+  // article "Quaternion Calculus and Fast Animation".
+
+  var fTrace = mat[0] + mat[4] + mat[8];
+  var fRoot;
+
+  if ( fTrace > 0.0 )
+  {
+    // |w| > 1/2, may as well choose w > 1/2
+    fRoot = Math.sqrt(fTrace + 1.0);  // 2w
+    dest[3] = 0.5 * fRoot;
+    fRoot = 0.5/fRoot;  // 1/(4w)
+    dest[0] = (mat[7]-mat[5])*fRoot;
+    dest[1] = (mat[2]-mat[6])*fRoot;
+    dest[2] = (mat[3]-mat[1])*fRoot;
+  }
+  else
+  {
+    // |w| <= 1/2
+    var s_iNext = quat4.fromRotationMatrix.s_iNext = quat4.fromRotationMatrix.s_iNext || [1,2,0];
+    var i = 0;
+    if ( mat[4] > mat[0] )
+      i = 1;
+    if ( mat[8] > mat[i*3+i] )
+      i = 2;
+    var j = s_iNext[i];
+    var k = s_iNext[j];
+    
+    fRoot = Math.sqrt(mat[i*3+i]-mat[j*3+j]-mat[k*3+k] + 1.0);
+    dest[i] = 0.5 * fRoot;
+    fRoot = 0.5 / fRoot;
+    dest[3] = (mat[k*3+j] - mat[j*3+k]) * fRoot;
+    dest[j] = (mat[j*3+i] + mat[i*3+j]) * fRoot;
+    dest[k] = (mat[k*3+i] + mat[i*3+k]) * fRoot;
+  }
+    
+  return dest;
+};
+
+/**
+ * quat4.toAngleAxis(src[, dest]) -> vec4
+ * - src (quat4): the quaternion to convert into an axis with angle
+ * - dest (vec4): the optional destination vec4 to store the axis and angle in
+ *
+ * If dest is not given, src will be modified in place and returned.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+quat4.toAngleAxis = function(src, dest) {
+  if (!dest) dest = src;
+  // The quaternion representing the rotation is
+  //   q = cos(A/2)+sin(A/2)*(x*i+y*j+z*k)
+
+  var sqrlen = src[0]*src[0]+src[1]*src[1]+src[2]*src[2];
+  if (sqrlen > 0)
+  {
+    dest[3] = 2 * Math.acos(src[3]);
+    var invlen = Math.invsrt(sqrlen);
+    dest[0] = src[0]*invlen;
+    dest[1] = src[1]*invlen;
+    dest[2] = src[2]*invlen;
+  } else {
+    // angle is 0 (mod 2*pi), so any axis will do
+    dest[3] = 0;
+    dest[0] = 1;
+    dest[1] = 0;
+    dest[2] = 0;
+  }
+  
+  return dest;
+};
+
+/**
+ * quat4.fromAngleAxis(angle, axis[, dest]) -> quat4
+ * - angle (Number): the angle in radians
+ * - axis (vec3): the axis around which to rotate
+ * - dest (quat4): the optional quat4 to store the result in
+ *
+ * Creates a quat4 from the given angle and rotation axis,
+ * then returns it. If dest is not given, a new quat4 is created.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+quat4.fromAngleAxis = function(angle, axis, dest) {
+  // The quaternion representing the rotation is
+  //   q = cos(A/2)+sin(A/2)*(x*i+y*j+z*k)
+  if (!dest) dest = quat4.create();
+  
+  var half = angle * 0.5;
+  var s = Math.sin(half);
+  dest[3] = Math.cos(half);
+  dest[0] = s * axis[0];
+  dest[1] = s * axis[1];
+  dest[2] = s * axis[2];
+  
+  return dest;
+};
+
+/**
+ * quat4.IDENTITY -> quat4
+ *
+ * Represents the Identity quaternion.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+quat4.IDENTITY = quat4.create([0, 0, 0, 1]);
+

data/lib/assets/javascripts/jax/core/glMatrix_ext/vec2.js

@@ -0,0 +1,25 @@
+/**
+ * class vec2
+ * 
+ * A 2D vector.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+if (typeof(vec2) == 'undefined') var vec2 = {};
+
+/**
+ * vec2.create([vec]) -> vec2
+ * - vec (vec2): optional vec2 to initialize from
+ * 
+ * Creates a 2D vector and returns it.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+vec2.create = function(src) {
+  var vec = new glMatrixArrayType(2);
+  if (src) { vec[0] = src[0]; vec[1] = src[1]; }
+  return vec;
+};
+

data/lib/assets/javascripts/jax/core/glMatrix_ext/vec3.js

@@ -0,0 +1,86 @@
+/**
+ * vec3.toQuatRotation(first, second[, dest]) -> quat4
+ * - first (vec3): the initial direction vector
+ * - second (vec3): the direction to rotate to
+ * - dest (quat4): optional quat4 containing result
+ *
+ * Returns the shortest arc rotation between the two vectors
+ * in the form of a quaternion. If dest is not given, it is
+ * created.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+vec3.toQuatRotation = function(first, second, dest) {
+  var dot = vec3.dot(first, second);
+  // if dot == 1, vectors are the same
+  if (dot >= 1.0) return quat4.IDENTITY;
+  if (dot < (0.000001 - 1.0)) { // 180 degrees
+    // generate an axis
+    var axis = vec3.cross(vec3.UNIT_X, first, vec3.create());
+    if (vec3.length(axis) < Math.EPSILON) // pick another if colinear
+      axis = vec3.cross(vec3.UNIT_Y, first, axis);
+    vec3.normalize(axis);
+    return quat4.fromAngleAxis(Math.PI, axis, dest);
+  } else {
+    var s = Math.sqrt((1+dot)*2);
+    var invs = 1 / s;
+    var c = vec3.cross(first, second, vec3.create());
+    if (!dest) dest = quat4.create();
+    dest[0] = c[0] * invs;
+    dest[1] = c[1] * invs;
+    dest[2] = c[2] * invs;
+    dest[3] = s * 0.5;
+    return quat4.normalize(dest);
+  }
+};
+
+/**
+ * vec3.multiply(a, b[, dest]) -> vec3
+ * - a (vec3): left operand
+ * - b (vec3): right operand, a 3D vector
+ * - dest (vec3): optional destination vector; if omitted, +a+ is used
+ *
+ * Multiplies the vector +a+ by the vector +b+ and stores the
+ * result in either +dest+ or +a+ if +dest+ is omitted. Returns the result.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+vec3.multiply = function(a, b, dest) {
+  if (!dest) dest = a;
+  dest[0] = a[0] * b[0];
+  dest[1] = a[1] * b[1];
+  dest[2] = a[2] * b[2];
+  return dest;
+}
+
+/**
+ * vec3.UNIT_X -> vec3
+ *
+ * Represents a unit vector along the positive X axis
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+vec3.UNIT_X = vec3.create([1,0,0]);
+
+/**
+ * vec3.UNIT_Y -> vec3
+ *
+ * Represents a unit vector along the positive Y axis
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+vec3.UNIT_Y = vec3.create([0,1,0]);
+
+/**
+ * vec3.UNIT_Z -> vec3
+ *
+ * Represents a unit vector along the positive Z axis
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+vec3.UNIT_Z = vec3.create([0,0,1]);

data/lib/assets/javascripts/jax/core/glMatrix_ext/vec4.js

@@ -0,0 +1,28 @@
+/**
+ * class vec4
+ * 
+ * A 4D vector.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+if (typeof(vec4) == 'undefined') var vec4 = {};
+
+/**
+ * vec4.create([src]) -> vec4
+ * - src (vec4 | Array): an optional source array to initialize this vec4 from
+ * 
+ * Creates and returns a new vec4, optionally initialized with values from +src+.
+ *
+ * (Note: this is a Jax-specific extension. It does not appear by default
+ * in the glMatrix library.)
+ **/
+vec4.create = function(src) {
+  var dest = new glMatrixArrayType(4);
+  if (src) {
+    dest[0] = src[0];
+    dest[1] = src[1];
+    dest[2] = src[2];
+  }
+  return dest;
+};

data/lib/assets/javascripts/jax/core/helper.js

@@ -0,0 +1,44 @@
+/**
+ * class Jax.Helper
+ *
+ * Jax Helpers are glorified mixins. They contain a set of methods which can then be
+ * included into any Jax class.
+ *
+ * Defining a helper is easy, and looks a bit like this:
+ *
+ *     var HelloHelper = Jax.Helper.create({
+ *       sayHi: function(name) { alert("Hello, "+name+"!"); }
+ *     });
+ *
+ * Once defined, using helpers is particularly simple. In any Jax class, simply define
+ * a +helpers+ function that returns an array of helpers:
+ *
+ *     var Liaison = Jax.Class.create({
+ *       helpers: function() { return [HelloHelper]; }
+ *     });
+ *
+ * Now the +Liaison+ class will include the +sayHi+ method which can be called just like
+ * any other method:
+ *
+ *     var l = new Liaison();
+ *     l.sayHi("World");
+ *     //=> Hello, World!
+ *
+ *
+ * As of Jax v1.1.0, you may also set the array of helpers directly on the +helpers+ property
+ * of a class, instead of defining a function. The following example is functionally
+ * equivalent to the above:
+ *
+ *     var Liaison = Jax.Class.create({
+ *       helpers: [HelloHelper]
+ *     });
+ *
+ **/
+Jax.Helper = {
+  instances: [],
+
+  create: function(methods) {
+    Jax.Helper.instances.push(methods);
+    return methods;
+  }
+};

data/lib/assets/javascripts/jax/core/math.js

@@ -0,0 +1,61 @@
+/**
+ * Math.EPSILON = 0.00001
+ * This is a very small number, used for testing fuzzy equality with floats due to
+ * floating point imprecision.
+ **/
+Math.EPSILON = Math.EPSILON || 0.00001;
+
+/**
+ * Math
+ * Defines math-related helper functions.
+ **/
+
+/**
+ * Math.radToDeg(rad) -> Number
+ * Helper to convert radians to degrees.
+ **/
+Math.radToDeg = Math.radToDeg || function(rad) {
+  return rad * 180.0 / Math.PI;
+};
+
+/** alias of: Math.radToDeg
+ * Math.rad2deg(rad) -> Number
+ * Helper to convert radians to degrees.
+ **/
+Math.rad2deg = Math.rad2deg || Math.radToDeg;
+
+/**
+ * Math.degToRad(deg) -> Number
+ * Helper to convert degrees to radians.
+ **/
+Math.degToRad = Math.degToRad || function(deg) {
+  return deg * Math.PI / 180.0;
+};
+
+/** alias of: Math.degToRad
+ * Math.deg2rad(deg) -> Number
+ * Helper to convert degrees to radians.
+ **/
+Math.deg2rad = Math.deg2rad || Math.degToRad;
+
+/**
+ * Math.equalish(a, b) -> Boolean
+ * Arguments can be either scalar or vector, but must be of the same type.
+ * Returns true if the arguments are "equal enough" after accounting for floating-point
+ * precision loss. Returns false otherwise.
+ *
+ * Also returns false if any element of either vector is undefined.
+ **/
+Math.equalish = Math.equalish || function(a, b) {
+  if (!a.length && !b.length)
+    return Math.abs(a - b) <= Math.EPSILON;
+
+  if (a.length != b.length) return false;
+  for (var i = 0; i < a.length; i++)
+    if (a[i] == undefined || b[i] == undefined ||
+        isNaN(a[i]) != isNaN(b[i]) ||
+        isFinite(a[i]) != isFinite(b[i]) ||
+        Math.abs(a[i] - b[i]) > Math.EPSILON)
+      return false;
+  return true;
+};