jax 1.1.1 → 2.0.0

data/lib/assets/javascripts/jax/noise.js

@@ -0,0 +1,251 @@
+/**
+ * class Jax.Noise
+ * Constructs several textures to be used in vertex shaders involving Perlin noise.
+ * As of v1.1.0, Jax defines a global variable called **Jax.noise** that you can use
+ * instead of maintaining your own instance of +Jax.Noise+. This is both more memory
+ * efficient and easier to use.
+ *
+ * Example:
+ *
+ *     setUniforms: function($super, context, mesh, options, uniforms) {
+ *       $super(context, mesh, options, uniforms);
+ *       
+ *       Jax.noise.bind(context, uniforms);
+ *       
+ *       // . . .
+ *     }
+ *
+ **/
+Jax.Noise = (function() {
+  var perm/*[256]*/ = [151,160,137,91,90,15,
+    131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
+    190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
+    88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
+    77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
+    102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
+    135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
+    5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
+    223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
+    129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
+    251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
+    49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
+    138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180];
+
+  /* These are Ken Perlin's proposed gradients for 3D noise. I kept them for
+     better consistency with the reference implementation, but there is really
+     no need to pad this to 16 gradients for this particular implementation.
+     If only the "proper" first 12 gradients are used, they can be extracted
+     from the grad4[][] array: grad3[i][j] == grad4[i*2][j], 0<=i<=11, j=0,1,2
+  */
+  var grad3/*[16][3]*/ = [0,1,1,    0,1,-1,   0,-1,1,   0,-1,-1,
+                          1,0,1,    1,0,-1,  -1,0,1,   -1,0,-1,
+                          1,1,0,    1,-1,0,  -1,1,0,   -1,-1,0, // 12 cube edges
+                          1,0,-1,  -1,0,-1,   0,-1,1,   0,1,1]; // 4 more to make 16
+
+  /* These are my own proposed gradients for 4D noise. They are the coordinates
+     of the midpoints of each of the 32 edges of a tesseract, just like the 3D
+     noise gradients are the midpoints of the 12 edges of a cube.
+  */
+  var grad4/*[32][4]*/ = [0,1,1,1,   0,1,1,-1,   0,1,-1,1,   0,1,-1,-1, // 32 tesseract edges
+                          0,-1,1,1,  0,-1,1,-1,  0,-1,-1,1,  0,-1,-1,-1,
+                          1,0,1,1,   1,0,1,-1,   1,0,-1,1,   1,0,-1,-1,
+                         -1,0,1,1,  -1,0,1,-1,  -1,0,-1,1,  -1,0,-1,-1,
+                          1,1,0,1,   1,1,0,-1,   1,-1,0,1,   1,-1,0,-1,
+                         -1,1,0,1,  -1,1,0,-1,  -1,-1,0,1,  -1,-1,0,-1,
+                          1,1,1,0,   1,1,-1,0,   1,-1,1,0,   1,-1,-1,0,
+                         -1,1,1,0,  -1,1,-1,0,  -1,-1,1,0,  -1,-1,-1,0];
+
+  /* This is a look-up table to speed up the decision on which simplex we
+     are in inside a cube or hypercube "cell" for 3D and 4D simplex noise.
+     It is used to avoid complicated nested conditionals in the GLSL code.
+     The table is indexed in GLSL with the results of six pair-wise
+     comparisons beween the components of the P=(x,y,z,w) coordinates
+     within a hypercube cell.
+     c1 = x>=y ? 32 : 0;
+     c2 = x>=z ? 16 : 0;
+     c3 = y>=z ? 8 : 0;
+     c4 = x>=w ? 4 : 0;
+     c5 = y>=w ? 2 : 0;
+     c6 = z>=w ? 1 : 0;
+     offsets = simplex[c1+c2+c3+c4+c5+c6];
+     o1 = step(160,offsets);
+     o2 = step(96,offsets);
+     o3 = step(32,offsets);
+     (For the 3D case, c4, c5, c6 and o3 are not needed.)
+  */
+    var simplex4/*[][4]*/ = [0,64,128,192,   0,64,192,128,   0,0,0,0,        0,128,192,64,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        64,128,192,0,
+                             0,128,64,192,   0,0,0,0,        0,192,64,128,   0,192,128,64,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        64,192,128,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             64,128,0,192,   0,0,0,0,        64,192,0,128,   0,0,0,0,
+                             0,0,0,0,        0,0,0,0,        128,192,0,64,   128,192,64,0,
+                             64,0,128,192,   64,0,192,128,   0,0,0,0,        0,0,0,0,
+                             0,0,0,0,        128,0,192,64,   0,0,0,0,        128,64,192,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             0,0,0,0,        0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             128,0,64,192,   0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             192,0,64,128,   192,0,128,64,   0,0,0,0,        192,64,128,0,
+                             128,64,0,192,   0,0,0,0,        0,0,0,0,        0,0,0,0,
+                             192,64,0,128,   0,0,0,0,        192,128,0,64,   192,128,64,0];
+                             
+  var simplex_buf = null, perm_buf = null, grad_buf = null;
+  
+  /*
+   * initPermTexture() - create and load a 2D texture for
+   * a combined index permutation and gradient lookup table.
+   * This texture is used for 2D and 3D noise, both classic and simplex.
+   */
+  function initPermTexture(context)
+  {
+    var tex = new Jax.Texture({min_filter: GL_NEAREST, mag_filter: GL_NEAREST, width:256, height:256});
+    
+    if (!perm_buf) {
+      var pixels = new Array(256*256*4);
+      var i,j;
+      for(i = 0; i<256; i++)
+        for(j = 0; j<256; j++) {
+          var offset = (i*256+j)*4;
+          var value = perm[(j+perm[i]) & 0xFF];
+          var g = (value & 0x0F) * 3;
+          pixels[offset]   = grad3[g+0] * 64 + 64; // Gradient x
+          pixels[offset+1] = grad3[g+1] * 64 + 64; // Gradient y
+          pixels[offset+2] = grad3[g+2] * 64 + 64; // Gradient z
+          pixels[offset+3] = value;                // Permuted index
+        }
+      perm_buf = new Uint8Array(pixels);
+    }
+
+    return tex;
+  }
+  
+  /*
+   * initSimplexTexture() - create and load a 1D texture for a
+   * simplex traversal order lookup table. This is used for simplex noise only,
+   * and only for 3D and 4D noise where there are more than 2 simplices.
+   * (3D simplex noise has 6 cases to sort out, 4D simplex noise has 24 cases.)
+   */
+  function initSimplexTexture(context)
+  {
+    // webgl doesn't support 1D so we'll simulate it with a 64x1 texture
+
+    if (!simplex_buf) simplex_buf = new Uint8Array(simplex4);
+    var tex = new Jax.Texture({min_filter:GL_NEAREST,mag_filter:GL_NEAREST, width:64, height:1});
+    return tex;
+  }
+  
+  /*
+   * initGradTexture(context) - create and load a 2D texture
+   * for a 4D gradient lookup table. This is used for 4D noise only.
+   */
+  function initGradTexture(context)
+  {
+    var tex = new Jax.Texture({min_filter: GL_NEAREST, mag_filter: GL_NEAREST, width:256, height:256});
+
+    if (!grad_buf) {
+      var pixels = new Array(256*256*4);
+      var i,j;
+
+      for(i = 0; i<256; i++)
+        for(j = 0; j<256; j++) {
+          var offset = (i*256+j)*4;
+          var value = perm[(j+perm[i]) & 0xFF];
+          var g = (value & 0x1F) * 4;
+          pixels[offset]   = grad4[g+0] * 64 + 64; // Gradient x
+          pixels[offset+1] = grad4[g+1] * 64 + 64; // Gradient y
+          pixels[offset+2] = grad4[g+2] * 64 + 64; // Gradient z
+          pixels[offset+3] = grad4[g+3] * 64 + 64; // Gradient z
+        }
+      
+      grad_buf = new Uint8Array(pixels);
+    }
+
+    return tex;
+  }
+  
+  function prepareAll(self, context) {
+    if (!perm_buf || !simplex_buf || !grad_buf)
+      throw new Error("Unknown error: one of the noise buffers is null!");
+      
+    self.perm.bind(context, function() {
+      context.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, perm_buf);
+    });
+    self.simplex.bind(context, function() {
+      context.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 64, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, simplex_buf);
+    });
+    self.grad.bind(context, function() {
+      context.glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, grad_buf);
+    });
+  }
+
+  return Jax.Class.create({
+    initialize: function(context) {
+      /** 
+       * Jax.Noise#perm -> Jax.Texture
+       * A 2D texture for a combined index permutation and gradient lookup table.
+       * This texture is used for both 2D and 3D noise, both classic and simplex.
+       **/
+      this.perm = initPermTexture(context);
+      
+      /** 
+       * Jax.Noise#simplex -> Jax.Texture
+       * A 1D texture for a simplex transversal order lookup table. This is used
+       * for simplex noise only, and only for 3D and 4D noise where there are more
+       * than 2 simplices. (3D simplex noise has 6 cases to sort out, 4D simplex
+       * noise has 24 cases.)
+       *
+       * Note that WebGL does not support 1D textures, so this is technically a
+       * 2D texture with a height of 1 pixel.
+       **/
+      this.simplex = initSimplexTexture(context);
+      
+      /** 
+       * Jax.Noise#grad -> Jax.Texture
+       * A 2D texture for a 4D gradient lookup table. This is used for 4D noise
+       * only.
+       **/
+      this.grad = initGradTexture(context);
+      
+      if (context) prepareAll(this, context);
+    },
+    
+    /**
+     * Jax.Noise#bind(context, uniforms) -> Jax.Shader.Delegator
+     * - context (Jax.Context): the context to bind the noise textures to
+     * - uniforms (Jax.Shader.Delegator): the shader variables to bind this noise to.
+     * 
+     * Binds the three noise textures to the given set of shader uniforms. This is
+     * intended to be used from within a shader's +material.js+ file like so:
+     *
+     *     setUniforms: function($super, context, mesh, options, uniforms) {
+     *       $super(context, mesh, options, uniforms);
+     *       
+     *       Jax.noise.bind(context, uniforms);
+     *       
+     *       // . . .
+     *     }
+     *
+     * Returns the same uniforms delegator that was specified to begin with.
+     *
+     **/
+    bind: function(context, uniforms) {
+      if (!this.isPrepared(context)) prepareAll(this, context);
+      uniforms.texture('permTexture',    this.perm,    context);
+      uniforms.texture('simplexTexture', this.simplex, context);
+      uniforms.texture('gradTexture',    this.grad,    context);
+    },
+    
+    /**
+     * Jax.Noise#isPrepared(context) -> Boolean
+     * 
+     * Returns true if this Jax.Noise has had its textures prepared for the
+     * specified context.
+     **/
+    isPrepared: function(context) {
+      return this.perm.isValid(context);
+    }
+  });
+})();
+
+Jax.noise = new Jax.Noise();

data/lib/assets/javascripts/jax/prototype/class.js

@@ -0,0 +1,81 @@
+//= require "jax/prototype/core"
+
+/**
+ * Jax.Class
+ **/
+Jax.Class = (function() {
+  var emptyFunction = function() { };
+
+  var IS_DONTENUM_BUGGY = (function(){
+    for (var p in { toString: 1 }) {
+      if (p === 'toString') return false;
+    }
+    return true;
+  })();
+
+  function subclass() {};
+  function create() {
+    var parent = null, properties = Jax.$A(arguments);
+    if (Object.isFunction(properties[0]))
+      parent = properties.shift();
+
+    function klass() {
+      this.initialize.apply(this, arguments);
+    }
+
+    Object.extend(klass, Jax.Class.Methods);
+    klass.superclass = parent;
+    klass.subclasses = [];
+
+    if (parent) {
+      subclass.prototype = parent.prototype;
+      klass.prototype = new subclass;
+      parent.subclasses.push(klass);
+    }
+
+    for (var i = 0, length = properties.length; i < length; i++)
+      klass.addMethods(properties[i]);
+
+    if (!klass.prototype.initialize)
+      klass.prototype.initialize = emptyFunction;
+
+    klass.prototype.constructor = klass;
+    return klass;
+  }
+
+  function addMethods(source) {
+    var ancestor   = this.superclass && this.superclass.prototype,
+        properties = Object.keys(source);
+
+    if (IS_DONTENUM_BUGGY) {
+      if (source.toString != Object.prototype.toString)
+        properties.push("toString");
+      if (source.valueOf != Object.prototype.valueOf)
+        properties.push("valueOf");
+    }
+
+    for (var i = 0, length = properties.length; i < length; i++) {
+      var property = properties[i], value = source[property];
+      if (ancestor && Object.isFunction(value) &&
+          value.argumentNames()[0] == "$super") {
+        var method = value;
+        value = (function(m) {
+          return function() { return ancestor[m].apply(this, arguments); };
+        })(property).wrap(method);
+
+        value.valueOf = method.valueOf.bind(method);
+        value.toString = method.toString.bind(method);
+      }
+      this.prototype[property] = value;
+    }
+
+    return this;
+  }
+
+  return {
+    create: create,
+    Methods: {
+      addMethods: addMethods
+    }
+  };
+})();

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

@@ -0,0 +1,112 @@
+/*
+  Core functions borrowed from Prototype. I don't think these are stepping on anyone's (e.g. jQuery's) toes,
+  but if I find out otherwise I'll have to tweak it. The goal here is to be totally compatible with other libraries
+  wherever possible.
+*/
+
+Jax.$A = function(iterable) {
+  if (!iterable) return [];
+  if ('toArray' in Object(iterable)) return iterable.toArray();
+  var length = iterable.length || 0, results = new Array(length);
+  while (length--) results[length] = iterable[length];
+  return results;
+};
+
+/* TODO find a way to avoid polluting Object. */
+Object.isFunction = function(arg) { return Object.prototype.toString.call(arg) === '[object Function]'; };
+Object.isUndefined = function(object) { return typeof object === "undefined"; };
+Object.isArray = function(object) { return Object.prototype.toString.call(object) === '[object Array]'; };
+Object.extend = function(destination, source) {
+  for (var property in source)
+    destination[property] = source[property];
+  return destination;
+};
+
+Object.extend(Function.prototype, (function() {
+  var slice = Array.prototype.slice;
+
+  function update(array, args) {
+    var arrayLength = array.length, length = args.length;
+    while (length--) array[arrayLength + length] = args[length];
+    return array;
+  }
+
+  function merge(array, args) {
+    array = slice.call(array, 0);
+    return update(array, args);
+  }
+
+  function argumentNames() {
+    var names = this.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
+      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
+      .replace(/\s+/g, '').split(',');
+    return names.length == 1 && !names[0] ? [] : names;
+  }
+
+  function bind(context) {
+    if (arguments.length < 2 && Object.isUndefined(arguments[0])) return this;
+    var __method = this, args = slice.call(arguments, 1);
+    return function() {
+      var a = merge(args, arguments);
+      return __method.apply(context, a);
+    }
+  }
+
+  function bindAsEventListener(context) {
+    var __method = this, args = slice.call(arguments, 1);
+    return function(event) {
+      var a = update([event || window.event], args);
+      return __method.apply(context, a);
+    }
+  }
+
+  function curry() {
+    if (!arguments.length) return this;
+    var __method = this, args = slice.call(arguments, 0);
+    return function() {
+      var a = merge(args, arguments);
+      return __method.apply(this, a);
+    }
+  }
+
+  function delay(timeout) {
+    var __method = this, args = slice.call(arguments, 1);
+    timeout = timeout * 1000;
+    return window.setTimeout(function() {
+      return __method.apply(__method, args);
+    }, timeout);
+  }
+
+  function defer() {
+    var args = update([0.01], arguments);
+    return this.delay.apply(this, args);
+  }
+
+  function wrap(wrapper) {
+    var __method = this;
+    return function() {
+      var a = update([__method.bind(this)], arguments);
+      return wrapper.apply(this, a);
+    }
+  }
+
+  function methodize() {
+    if (this._methodized) return this._methodized;
+    var __method = this;
+    return this._methodized = function() {
+      var a = update([this], arguments);
+      return __method.apply(null, a);
+    };
+  }
+
+  return {
+    argumentNames:       argumentNames,
+    bind:                bind,
+    bindAsEventListener: bindAsEventListener,
+    curry:               curry,
+    delay:               delay,
+    defer:               defer,
+    wrap:                wrap,
+    methodize:           methodize
+  };
+})());

data/lib/assets/javascripts/jax/prototype/extensions.js

@@ -0,0 +1,142 @@
+//= require "jax/prototype/class"
+
+(function() {
+  /*
+    Delegator is instantiated by the class method #delegate with _this_ and _arguments_ as arguments.
+    It is effectively responsible for copying a set of methods into the destination object.
+    
+    @see Jax.Class.Methods#delegate
+   */
+  var Delegator = Jax.Class.create({
+    initialize: function(target, methods) {
+      this.methods = methods;
+      this.target = target;
+    },
+    
+    into: function(destination, dest_klass) {
+      /*
+        yes, we're using eval in here. But as this method is only called during setup, it's probably OK for the most
+        part. Note the caveat that if dest_klass is omitted and the dev is using regular expressions to match method
+        names, we have no choice but to put an eval into the alias chain for this.target#initialize. Not ideal but I
+        couldn't think of a better way to make it work.
+       */
+      var methods = {};
+      var method_name;
+      var alias_chain_regexps = [];
+      
+      for (var i = 0; i < this.methods.length; i++) {
+        if (typeof(this.methods[i]) == "string") {
+          /* it's not a regexp so this case is pretty straightforward */
+          method_name = this.methods[i];
+          methods[method_name] =
+            eval("(function() { return this."+destination+"."+method_name+".apply(this."+destination+", arguments); })");
+        } else if (this.methods[i].test) {
+          var method_regexp = this.methods[i];
+          /*
+            regexp -- this is harder because we don't know what klass _destination_ points to.
+            we have two choices: require an explicit klass argument, or assume the dev is prepared
+            to pay the overhead price of testing regexps and calling #eval within #initialize.
+            
+            let's do both: if explicit klass was given, use it. Else, set up an alias chain for #initialize.
+           */
+          
+          if (dest_klass) {
+            for (method_name in dest_klass.prototype) {
+              if (method_regexp.test(method_name)) {
+                methods[method_name] =
+                        eval("(function() { return this."+destination+"."+method_name+".apply(this."+destination+", arguments); })");
+              }
+            }
+          } else {
+            alias_chain_regexps.push(method_regexp);
+          }
+        }
+      }
+
+      /* add known methods */
+      this.target.addMethods(methods);
+      
+      if (alias_chain_regexps.length > 0) {
+        if (!this.target.alias_chain_regexps)
+        {
+          /* alias chain doesn't yet exist -- create it */
+          this.target.alias_chain_regexps = {};
+          var original_initialize_method = this.target.prototype.initialize;
+          var fn = "(function(){" +
+                     "if (original_initialize_method) original_initialize_method.apply(this, arguments);" +
+                     "var i, j, method_name, destination, method_regexp, self = this;" +
+                  
+                     "destination = this."+destination+";" +
+                     "for (i = 0; i < this.klass.alias_chain_regexps['"+destination+"'].length; i++) {" +
+                       "method_regexp = this.klass.alias_chain_regexps['"+destination+"'][i];" +
+                       "for (j in destination) {" +
+                         "method_name = j;" +
+                         "if (method_regexp.test(method_name)) " +
+                           "this[method_name] = eval('(function(){return self."+destination+".'+method_name+" +
+                                                    "'.apply(self."+destination+", arguments);})');" +
+                       "}" +
+                     "}" +
+                  "})";
+          
+          this.target.prototype.initialize = eval(fn);
+        }
+        /* else, alias chain exists; we only have to add method regexps */
+        
+        this.target.alias_chain_regexps[destination] = this.target.alias_chain_regexps[destination] || [];
+        for (i = 0; i < alias_chain_regexps.length; i++) {
+          this.target.alias_chain_regexps[destination].push(alias_chain_regexps[i]);
+        }
+      }
+    }
+  });
+    
+  /*
+    Prototype doesn't seem to have a way to add instance methods to all classes (a generic base object would have
+    been nice) so we have to hack it in by aliasing ::create and then replacing it.
+  */
+  Jax.Class.InstanceMethods = {
+    isKindOf: function(klass) {
+      return(this instanceof klass);
+    }
+  };
+
+  var original_create = Jax.Class.create;
+  Jax.Class.create = function() {
+    var klass = original_create.apply(Jax.Class, arguments);
+    klass.prototype.klass = klass;
+    klass.addMethods(Jax.Class.InstanceMethods);
+    Jax.Util.addRequestedHelpers(klass);
+
+    return klass;
+  };
+  
+  /**
+   * Jax.Class.delegate() -> undefined
+   *
+   * This is a class method of all Jax classes.
+   *
+   * Delegates one or more methods into properties of the class. For instance,
+   * the following:
+   * 
+   *     MyClass.delegate("sayHello").into("person");
+   *
+   * will create a +sayHello+ method in the +MyClass+ class that internally calls
+   * 
+   *     this.person.sayHello(...)
+   *
+   * and returns the results.
+   *
+   * There are several other variants:
+   *
+   *     klass.delegate(/regular expression/).into("property_name");
+   *       // delegates any method name in +property_name+ that matches the expression
+   * 
+   *     klass.delegate("one", "two").into("property_name");
+   *       // delegates both 'one' and 'two' methods into +property_name+
+   *
+   *
+   **/
+  Jax.Class.Methods.delegate = function() {
+    return new Delegator(this, arguments);
+  };
+})();

data/lib/assets/javascripts/jax/vendor/ejs.js

@@ -0,0 +1 @@
+//= require "ejs"

data/lib/assets/javascripts/jax/vendor/glMatrix.js

@@ -0,0 +1,7 @@
+//= require "glMatrix"
+//= require "jax/core/glMatrix_ext/mat3.js"
+//= require "jax/core/glMatrix_ext/mat4.js"
+//= require "jax/core/glMatrix_ext/quat4.js"
+//= require "jax/core/glMatrix_ext/vec2.js"
+//= require "jax/core/glMatrix_ext/vec3.js"
+//= require "jax/core/glMatrix_ext/vec4.js"