jax 1.1.1 → 2.0.0

data/lib/assets/javascripts/jax/webgl/material.js

@@ -0,0 +1,381 @@
+//= require "jax/webgl/shader"
+
+/**
+ * class Jax.Material
+ * 
+ * Represents a single material, which has its own color, lighting and texture properties.
+ * 
+ * Example:
+ * 
+ *     var material = new Jax.Material({ shininess: 1,
+ *                                       diffuse:  [0.8, 0.8, 0.8, 1.0],
+ *                                       ambient:  [0.8, 0.8, 0.8, 1.0],
+ *                                       specular: [1.0, 1.0, 1.0, 1.0],
+ *                                       emissive: [0.0, 0.0, 0.0, 1.0]
+ *                                     });
+ *                                     
+ * IMPORTANT: Note that shaders are no longer directly tied to a given Material. Instead, the shader
+ * should be specified as a property (or render option) of the mesh to be rendered. In most cases,
+ * however, the appropriate shader will be determined automatically by Jax.
+ **/
+Jax.Material = (function() {
+  function updatePrevious(self) {
+    self.previous = self.previous || {subshaders:[]};
+    for (var i = 0; i < self.layers.length; i++)
+      self.previous.subshaders[i] = self.layers[i].getName();
+  }
+  
+  function instantiate_layer(options) {
+    if (options.isKindOf && options.isKindOf(Jax.Material))
+      return options;
+    else {
+      if (options.type) {
+        var klass = Jax.Material[options.type];
+        if (!klass) throw new Error("Could not find material layer type: "+options.type);
+        delete options.type;
+        return new klass(options);
+      }
+      else
+        throw new Error("Could not create layer: property 'type' was missing!");
+    }
+  }
+  
+  return Jax.Class.create({
+    initialize: function(options) {
+      options = Jax.Util.normalizeOptions(options, {
+        ambient: [1,1,1,1],
+        diffuse: [1,1,1,1],
+        specular:[1,1,1,1],
+        emissive: [0, 0, 0, 1.0],
+        shininess: 10,
+        default_shader: Jax.default_shader
+      });
+      options.ambient = Jax.Util.colorize(options.ambient);
+      options.diffuse = Jax.Util.colorize(options.diffuse);
+      options.specular = Jax.Util.colorize(options.specular);
+      options.emissive = Jax.Util.colorize(options.emissive);
+
+      for (var i in options) { this[i] = options[i]; }
+      this.option_properties = Jax.Util.properties(options);
+      this.protected_properties = ['name', 'shader', 'default_shader', 'shaders', 'layers'];
+      
+      this.name = options.name || options.shader || options.default_shader;
+      this.shaders = {};
+      this.layers = [];
+
+      if (!options.shader && !options.default_shader)
+        throw new Error("No shader specified for Jax.Material "+this.name);
+      
+      var tex;
+      if (options.texture) {
+        tex = new Jax.Texture(options.texture);
+        this.addTextureLayer(tex);
+        delete options.texture;
+      } else if (options.textures) {
+        for (i = 0; i < options.textures.length; i++) {
+          tex = new Jax.Texture(options.textures[i]);
+          this.addTextureLayer(tex);
+        }
+        delete options.textures;
+      }
+      
+      if (options.layers) {
+        for (i = 0; i < options.layers.length; i++) {
+          this.addLayer(instantiate_layer(options.layers[i]));
+        }
+      }
+    },
+    
+    /**
+     * Jax.Material#supportsLighting() -> Boolean
+     *
+     * Returns true if this material supports lighting effects.
+     **/
+    supportsLighting: function() {
+      if (this.getName() == "lighting")
+        return true;
+      for (var i = 0; i < this.layers.length; i++)
+        if (this.layers[i].getName() == "lighting")
+          return true;
+      return false;
+    },
+    
+    getName: function() { return this.name; },
+    
+    addTextureLayer: function(tex) {
+      var mat;
+      switch(tex.options.type) {
+        case Jax.NORMAL_MAP:
+          mat = new Jax.Material.NormalMap(tex);
+          break;
+        default:
+          mat = new Jax.Material.Texture(tex);
+      }
+      this.addLayer(mat);
+    },
+    
+    addLayer: function(layer) {
+      if (!layer.option_properties) layer = instantiate_layer(layer);
+      this.layers.push(layer);
+
+      for (var i = 0; i < layer.option_properties.length; i++) {
+        var name = layer.option_properties[i];
+        if (this.protected_properties.indexOf(name) == -1 && this[name] == undefined) {
+          this[name] = layer[name];
+        }
+      }
+    },
+
+    /**
+     * Jax.Material#buildShader(name) -> Jax.Shader
+     * 
+     * Forces a rebuild of the specified shader. If the shader doesn't exist, one will be instantiated.
+     * Note that this doesn't result in an immediate recompile (as that would require a Jax.Context).
+     * Instead, it schedules the rebuild for the next render pass, when the Jax.Context is readily
+     * available.
+     **/
+    buildShader: function() {
+      if (this.shaderChain)
+        this.shaderChain.removeAllShaders();
+      else
+        this.shaderChain = new Jax.ShaderChain(this.getName());
+      
+      this.addShadersToChain(this.shaderChain);
+
+      return this.shaderChain;
+    },
+    
+    addShadersToChain: function(chain) {
+      this.shader_variable_prefix = chain.addShader(this.getBaseShader());
+      for (var i = 0; i < this.layers.length; i++)
+        this.layers[i].addShadersToChain(chain);
+    },
+    
+    getBaseShader: function() {
+      return (this.shader || this.default_shader);
+    },
+    
+    /**
+     * Jax.Material#updateModifiedShaders() -> self
+     * 
+     * If this Material has been modified, all shaders attached to it will be rebuilt.
+     **/
+    updateModifiedShaders: function() {
+      if (this.isChanged()) {
+        this.buildShader();
+        updatePrevious(this);
+      }
+      return this;
+    },
+
+    /**
+     * Jax.Material#prepareShader(name) -> Jax.Shader
+     * 
+     * Prepares the specified shader for rendering. If this Material has been modified,
+     * then all related shaders are updated. The specified shader is either built or returned,
+     * depending on whether it has already been built.
+     **/
+    prepareShader: function() {
+      var shader;
+      
+      if (this.shaderChain) shader = this.shaderChain;
+      else shader = this.buildShader();
+      
+      this.updateModifiedShaders();
+      return shader;
+    },
+    
+    setShaderVariables: function(context, mesh, options, manifest) {
+      manifest.variable_prefix = this.shader_variable_prefix;
+
+      manifest.set({
+        mMatrix: context.getModelMatrix(),
+        vnMatrix: mat3.transpose(mat4.toMat3(context.getViewMatrix())),
+        ivMatrix:  context.getInverseViewMatrix(),
+        vMatrix:   context.getViewMatrix(),
+        mvMatrix:  context.getModelViewMatrix(),
+        pMatrix:   context.getProjectionMatrix(),
+        nMatrix:   context.getNormalMatrix(),
+        
+        PASS_TYPE: context.current_pass,
+        
+        materialAmbient: this.ambient,
+        materialDiffuse: this.diffuse,
+        materialSpecular: this.specular,
+        materialShininess: this.shininess
+      });
+      manifest.set('VERTEX_POSITION',  mesh.getVertexBuffer() || null);
+      manifest.set('VERTEX_COLOR',     mesh.getColorBuffer() || null);
+      manifest.set('VERTEX_NORMAL',    mesh.getNormalBuffer() || null);
+      manifest.set('VERTEX_TEXCOORDS', mesh.getTextureCoordsBuffer() || null);
+
+      if (this.setVariables)  this.setVariables(context, mesh, options, manifest);
+      if (this.setUniforms)   this.setUniforms(context, mesh, options, manifest);
+      if (this.setAttributes) this.setAttributes(context, mesh, options, manifest);
+
+      for (var i = 0; i < this.layers.length; i++) {
+        manifest.variable_prefix = this.layers[i].shader_variable_prefix;
+        if (this.layers[i].setVariables)  this.layers[i].setVariables(context, mesh, options, manifest);
+        if (this.layers[i].setUniforms)   this.layers[i].setUniforms(context, mesh, options, manifest);
+        if (this.layers[i].setAttributes) this.layers[i].setAttributes(context, mesh, options, manifest);
+      }
+    },
+    
+    /**
+     * Jax.Material#render(context, mesh) -> undefined
+     * Renders the specified object to the specified context, using this material.
+     *
+     * This action will build and compile the shader for the given context if necessary.
+     **/
+    render: function(context, mesh, options) {
+      this.lights = context.world.lighting._lights;
+      this.light_count = context.world.lighting._lights.length;
+      
+      try {
+        var shader = this.prepareShader(context);
+        
+        shader.render(context, mesh, this, options);
+      } catch(error) {
+        if (error instanceof RangeError) {
+          // we've hit hardware limits. Back off a layer. If we are down to no layers, raise a coherent error.
+          if (this.layers.length > 0) {
+            this.adaptShaderToHardwareLimits(shader, error);
+            this.render(context, mesh, options);
+          }
+          else throw error;
+        }
+        else throw error;
+      }
+    },
+    
+    adaptShaderToHardwareLimits: function(shader, error) {
+      function log(msg) {
+        if (Jax.getGlobal().ENV && Jax.getGlobal().ENV['SILENCED']) return;
+        
+        if (Jax.getGlobal().console)
+          console.log(msg);
+        else
+          setTimeout(function() { throw new Error(msg); }, 1);
+      }
+            
+      log("WARNING: Hardware limits reached for material '"+this.getName()+"'! (original message: "+error+")");
+      
+      /*
+        choose which shader(s) to remove. We know off the bat that we can remove any shaders which would
+        push us over the threshold on their own (e.g. not combined with any except 'basic'), so let's remove
+        those first.
+      */
+      
+      var map = shader.getPerShaderInputMap(this);
+      
+      var uniformsRemaining = Jax.Shader.max_uniforms - map[this.getBaseShader()].uniforms.length;
+      var varyingsRemaining = Jax.Shader.max_varyings - map[this.getBaseShader()].varyings.length;
+      var attributesRemaining = Jax.Shader.max_attributes - map[this.getBaseShader()].attributes.length;
+      
+      // we'll use these to determine if we *still* need to pop at the end.
+      var totalUniformsInUse = 0, totalVaryingsInUse = 0, totalAttributesInUse = 0;
+      
+      for (var i = 0; i < this.layers.length; i++) {
+        var entry = map[this.layers[i].getBaseShader()];
+
+        if (entry.uniforms.length > uniformsRemaining || entry.varyings.length > varyingsRemaining ||
+                entry.attributes.length > attributesRemaining)
+        {
+          log("WARNING: Removing shader '"+this.layers[i].getName()+"' due to hardware limitations!");
+          this.layers.splice(i, 1);
+          i = 0;
+        } else {
+          totalUniformsInUse += entry.uniforms.length;
+          totalVaryingsInUse += entry.varyings.length;
+          totalAttributesInUse += entry.attributes.length;
+        }
+      }
+      
+      if (totalUniformsInUse > uniformsRemaining || totalVaryingsInUse > varyingsRemaining ||
+              totalAttributesInUse > attributesRemaining)
+      {
+        log("WARNING: Removing shader '"+this.layers[this.layers.length-1].getName()+"' due to hardware limitations!");
+        this.layers.pop();
+      }
+    },
+    
+    /**
+     * Jax.Material#isChanged() -> Boolean
+     * Returns true if this material's properties have been changed since
+     * the last time its internal shader was compiled.
+     **/
+    isChanged: function() {
+      if (!this.previous) return true;
+
+      if (this.previous.subshaders.length != this.layers.length) return true;
+      
+      for (var i = 0; i < this.layers.length; i++)
+        if (this.previous.subshaders[i] != this.layers[i].getName())
+          return true;
+
+      return false;
+    }
+  });
+})();
+
+Jax.Material.instances = {};
+
+/**
+ * Jax.Material.find(name) -> Jax.Material
+ * - name (String): the unique name of the material you're looking for
+ * 
+ * Returns the instance of Jax.Material matching the specified name, or throws
+ * an error if the material can't be found.
+ **/
+Jax.Material.find = function(name) {
+  var result;
+  if (result = Jax.Material.instances[name])
+    return result;
+  throw new Error("Material {material:'"+name+"'} could not be found.");
+};
+
+/**
+ * Jax.Material.create(name, options) -> Jax.Material
+ * - name (String): the unique name of this material
+ * - options (Object): a set of options to be passed to the material constructor
+ * 
+ * Creates a material and adds it to the material registry. This way,
+ * the material can be later retrieved using:
+ * 
+ *     var matr = Jax.Material.find(name);
+ *     
+ * Note that unlike instances of Jax.Model, specifying a name for a material that
+ * already exists will not raise an error. Instead, the previous material will be
+ * replaced with a new material constructed using the new options. This allows you
+ * to override Jax defaults like so:
+ * 
+ *     Jax.Material.create("default", {...});
+ *     
+ **/
+Jax.Material.create = function(name, options) {
+  options = Jax.Util.normalizeOptions(options, { name: name });
+  
+  var klass = Jax.Material;
+  if (options.type) klass = klass[options.type];
+  
+  if (!klass) throw new Error("Material type '"+options.type+"' not found!");
+  return Jax.Material.instances[name] = new klass(options);
+};
+
+/**
+ * Jax.Material.all() -> Array
+ * 
+ * Returns an array containing the names of all Materials currently registered
+ * with Jax. Note that this does not include one-off materials created directly,
+ * for example, using "new Jax.Material()".
+ **/
+Jax.Material.all = function() {
+  return Jax.Util.properties(Jax.Material.instances);
+};
+
+Jax.Material.addResources = function(resources) {
+  for (var i in resources) {
+    if (Jax.Material.instances[i]) throw new Error("Duplicate material resource ID: "+i);
+    Jax.Material.create(i, resources[i]);
+  }
+};

data/lib/assets/javascripts/jax/webgl/mesh/normals.js

@@ -0,0 +1,37 @@
+// (re)calculates vertex normals based on Jax.Mesh vertex data
+
+Jax.Mesh.prototype.calculateNormals = function() {
+  var mesh = this;
+  var triangles = mesh.getTriangles();
+  var normals = {}, i;
+  
+  // it's much slower to nest an iteration within an iteration; instead
+  // we'll create properties in +normals+ and then enumerate the properties
+  // later.
+  for (i = 0; i < triangles.length; i++) {
+    var tri = triangles[i];
+    normals[tri.a] = normals[tri.a] || [];
+    normals[tri.b] = normals[tri.b] || [];
+    normals[tri.c] = normals[tri.c] || [];
+    normals[tri.a].push(tri.getNormal());
+    normals[tri.b].push(tri.getNormal());
+    normals[tri.c].push(tri.getNormal());
+  }
+  
+  var normal = vec3.create();
+  mesh.dataRegion.remap(mesh.normalData, triangles.length * 9);
+  for (i = 0; i < mesh.vertices.length; i++) {
+    var v = mesh.vertices[i].array;
+    if (normals[v]) {
+      normal[0] = normal[1] = normal[2] = 0;
+      for (var j = 0; j < normals[v].length; j++)
+        vec3.add(normal, normals[v][j], normal);
+      vec3.scale(normal, 1/normals[v].length);
+      
+      vec3.set(normal, mesh.normals[i].array);
+    }
+  }
+  
+  // finally, update or create the WebGL buffer
+  mesh.buffers.normal_buffer.refresh();
+}

data/lib/assets/javascripts/jax/webgl/mesh/support.js

@@ -0,0 +1,104 @@
+// Support functions used by Jax.Mesh
+
+Jax.Mesh.prototype.eachTriangle = function(callback) {
+  var mesh = this;
+  var vertcount, a;
+  
+  var indices = mesh.getIndexBuffer(), vertices = mesh.vertices;
+  if (vertices.length == 0) return;
+  
+  if (indices) {
+    if (indices.length == 0) return;
+    indices = indices.getTypedArray();
+    vertcount = indices.length;
+  } else
+    vertcount = vertices.length;
+    
+  function call(i1, i2, i3) {
+    var v1, v2, v3, i = false;
+    
+    if (indices) {
+      i = true;
+      v1 = vertices[indices[i1]];
+      v2 = vertices[indices[i2]];
+      v3 = vertices[indices[i3]];
+    } else {
+      i = false;
+      v1 = vertices[i1];
+      v2 = vertices[i2];
+      v3 = vertices[i3];
+    }
+      
+    if (!v1 || !v2 || !v3) return;
+    callback(v1.array, v2.array, v3.array);
+  }
+  
+  switch(mesh.draw_mode) {
+    case GL_TRIANGLE_STRIP:
+      for (a = 2; a < vertcount; a += 2) {
+        call(a-2, a-1, a);
+        call(a, a-1, a+1);
+      }
+      break;
+    case GL_TRIANGLES:
+      for (a = 0; a < vertcount; a += 3)
+        call(a, a+1, a+2);
+      break;
+    case GL_TRIANGLE_FAN:
+      for (a = 2; a < vertcount; a++)
+        call(0, a-1, a);
+      break;
+    default:
+      return;
+  }
+};
+
+Jax.Mesh.prototype.buildTriangles = function() {
+  var mesh = this;
+  mesh.triangles.clear();
+  
+  mesh.eachTriangle(function(v1, v2, v3) {
+    var tri = new Jax.Geometry.Triangle();
+    tri.assign(v1, v2, v3);
+    mesh.triangles.push(tri);
+  });
+};
+
+Jax.Mesh.prototype.calculateBounds = function(vertices) {
+  var self = this;
+  if (vertices.length == 0) {
+    self.bounds.left = self.bounds.right = 0;
+    self.bounds.top = self.bounds.bottom = 0;
+    self.bounds.front = self.bounds.back = 0;
+    self.bounds.width = self.bounds.height = self.bounds.depth = 0;
+  } else {
+    self.bounds.left = self.bounds.right = null;
+    self.bounds.top = self.bounds.bottom = null;
+    self.bounds.front = self.bounds.back = null;
+    self.bounds.width = self.bounds.height = self.bounds.depth = null;
+  }
+
+  var i, v;
+  
+  for (i = 0; i < vertices.length; i++)
+  {
+    // x, i % 3 == 0
+    v = vertices[i];
+    if (self.bounds.left  == null || v < self.bounds.left)   self.bounds.left   = v;
+    if (self.bounds.right == null || v > self.bounds.right)  self.bounds.right  = v;
+    
+    // y, i % 3 == 1
+    v = vertices[++i];
+    if (self.bounds.bottom== null || v < self.bounds.bottom) self.bounds.bottom = v;
+    if (self.bounds.top   == null || v > self.bounds.top)    self.bounds.top    = v;
+    
+    // z, i % 3 == 2
+    v = vertices[++i];
+    if (self.bounds.front == null || v > self.bounds.front)  self.bounds.front  = v;
+    if (self.bounds.back  == null || v < self.bounds.back)   self.bounds.back   = v;
+  }
+  
+  self.bounds.width = self.bounds.right - self.bounds.left;
+  self.bounds.height= self.bounds.top   - self.bounds.bottom;
+  self.bounds.depth = self.bounds.front - self.bounds.back;
+};

data/lib/assets/javascripts/jax/webgl/mesh/tangent_space.js

@@ -0,0 +1,111 @@
+// used by Jax.Mesh to build tangent-space buffer
+// function makeTangentBuffer(self) {
+Jax.Mesh.prototype.makeTangentBuffer = function() {
+  var self = this;
+  
+  var normals = self.getNormalBuffer();
+  var vertices = self.getVertexBuffer();
+  var texcoords = self.getTextureCoordsBuffer();
+  var indices = self.getIndexBuffer();
+  if (!normals || !vertices || !texcoords) return null;
+
+  var tangentBuffer = self.buffers.tangent_buffer;
+  normals = normals.js;
+  vertices = vertices.js;
+  texcoords = texcoords.js;
+  if (indices && indices.length > 0) indices = indices.js;
+  else indices = null;
+  
+  var tangents = tangentBuffer ? tangentBuffer.js : [];
+  var tan1 = [], tan2 = [], a;
+  var v1 = vec3.create(), v2 = vec3.create(), v3 = vec3.create();
+  var w1 = [], w2 = [], w3 = [];
+  var vertcount;
+  var x1, x2, y1, y2, z1, z2, s1, s2, t1, t2, r;
+  var dif = [];
+  var sdir = vec3.create(), tdir = vec3.create();
+  
+  function setv(v, a) { v[0] = vertices[a*3];  v[1] = vertices[a*3+1];  v[2] = vertices[a*3+2]; }
+  function setw(w, a) { w[0] = texcoords[a*2]; w[1] = texcoords[a*2+1]; }
+  function sett1(a) { tan1[a] = tan1[a] || vec3.create(); vec3.add(tan1[a], sdir, tan1[a]); }
+  function sett2(a) { tan2[a] = tan2[a] || vec3.create(); vec3.add(tan2[a], tdir, tan2[a]); }
+  function findTangentVector(a1, a2, a3) {
+    if (indices) { a1 = indices[a1]; a2 = indices[a2]; a3 = indices[a3]; }
+    
+    setv(v1, a1); setv(v2, a2); setv(v3, a3);
+    setw(w1, a1); setw(w2, a2); setw(w3, a3);
+    x1 = v2[0] - v1[0]; x2 = v3[0] - v1[0];
+    y1 = v2[1] - v1[1]; y2 = v3[1] - v1[1];
+    z1 = v2[2] - v1[2]; z2 = v3[2] - v1[2];
+    s1 = w2[0] - w1[0]; s2 = w3[0] - w1[0];
+    t1 = w2[1] - w1[1]; t2 = w3[1] - w1[1];
+    r = 1.0 / (s1 * t2 - s2 * t1);
+    
+    sdir[0] = (t2 * x1 - t1 * x2) * r; sdir[1] = (t2 * y1 - t1 * y2) * r; sdir[2] = (t2 * z1 - t1 * z2) * r;
+    tdir[0] = (s1 * x2 - s2 * x1) * r; tdir[1] = (s1 * y2 - s2 * y1) * r; tdir[2] = (s1 * z2 - s2 * z1) * r;
+    
+    if (isNaN(sdir[0]) || isNaN(sdir[1]) || isNaN(sdir[2]) ||
+        isNaN(tdir[0]) || isNaN(tdir[1]) || isNaN(tdir[2]) )
+    {
+      // this only seems to happen when dealing with degenerate triangles
+      // ...which seems to be fairly common. So, let's see what happens if
+      // we just set the offending vectors to zero.
+      sdir[0] = sdir[1] = sdir[2] = tdir[0] = tdir[1] = tdir[2] = 0;
+    }
+    sett1(a1); sett1(a2); sett1(a3);
+    sett2(a1); sett2(a2); sett2(a3);
+  }
+  
+  vertcount = indices && indices.length > 0 ? indices.length : normals.length / 3;
+
+  /* we need to pass the vertices into findTangentVector differently depending on draw mode */
+  /* TODO refactor: merge this with mesh support */
+  switch(self.draw_mode) {
+    case GL_TRIANGLE_STRIP:
+      for (a = 2; a < vertcount; a += 2) {
+        findTangentVector(a-2, a-1, a);
+        findTangentVector(a, a-1, a+1);
+      }
+      break;
+    case GL_TRIANGLES:
+      for (a = 0; a < vertcount; a += 3)
+        findTangentVector(a, a+1, a+2);
+      break;
+    case GL_TRIANGLE_FAN:
+      for (a = 2; a < vertcount; a++)
+        findTangentVector(0, a-1, a);
+      break;
+    default:
+      throw new Error("Cannot calculate tangent space for draw mode: "+Jax.Util.enumName(self.draw_mode));
+  }
+
+  var normal = vec3.create();
+
+  // remove any tangents left over from earlier builds (this should be pretty rare)
+  while (tangents.length > vertcount) tangents.pop();
+
+  var b;
+  for (b = 0; b < vertcount; b++) {
+    
+    if (indices) a = indices[b];
+    else a = b;
+    
+    // Gram-Schmidt orthogonalize: (t - n * dot(n, t)).normalize()
+    normal[0] = normals[a*3]; normal[1] = normals[a*3+1]; normal[2] = normals[a*3+2];
+    vec3.scale(normal, vec3.dot(normal, tan1[a]), dif);
+    vec3.subtract(tan1[a], dif, dif);
+    vec3.normalize(dif);
+        
+    tangents[a*4] = dif[0];
+    tangents[a*4+1] = dif[1];
+    tangents[a*4+2] = dif[2];
+    // calc handedness
+    tangents[a*4+3] = (vec3.dot(vec3.cross(normal, tan1[a]), tan2[a])) < 0.0 ? -1.0 : 1.0;
+  }
+  
+  if (tangentBuffer)
+    self.buffers.tangent_buffer.refresh();
+  else
+    self.buffers.tangent_buffer = new Jax.NormalBuffer(tangents);
+  return self.buffers.tangent_buffer;
+}