jax 2.0.4 → 2.0.5

data/CHANGELOG

@@ -1,3 +1,21 @@
+* 2.0.5 *
+
+* Setting `shadowcaster` to `false` for a light source now has the expected result: it
+  disables all shadow mapping for that light, resulting in a significant performance boost.
+  
+* Updated gl-matrix to the latest version (v1.1), and updated Jax to take advantage of
+  it, resulting in a moderate performance boost.
+  
+* Light sources no longer generate shadow maps for, nor cast shadows upon, objects that
+  are beyond their range. This is based on the light's intensity (its ambient,
+  specular and diffuse color components), and its attenuation coefficients.
+  
+* Fixed `Jax.Camera#unproject` -- it had some stupid errors that kept it from working
+  at all. This method had also somehow crept into Jax without any tests; it is now
+  appropriately tested, of course.
+
+
+
 * 2.0.4 *
 
 * Jax was not differentiating between development mode and production mode, resulting

data/Rakefile

@@ -164,9 +164,9 @@ namespace :doc do
     @hide_links_to_api_docs = true
     header = ERB.new(File.read(File.expand_path("guides/partials/_top_nav.html.erb", File.dirname(__FILE__)))).result(binding)
     PDoc.run({
-      :source_files => (['lib/assets/javascripts/jax.js', 'vendor/assets/javascripts/glMatrix.js'] +
+      :source_files => (['lib/assets/javascripts/jax.js', 'vendor/assets/javascripts/gl-matrix-pdoc.js'] +
 #                        Dir['vendor/ejs/src/**/*.js'] +
-                        Dir['lib/assets/javascripts/jax/**/*.js']),
+                        Dir['lib/assets/javascripts/jax/**/*.{js,js.erb}']),
       :destination  => "doc",
 #      :index_page   => 'src/README.markdown',
       :syntax_highlighter => 'coderay',

data/lib/assets/javascripts/jax/{application.js.erb → application.js}

@@ -8,10 +8,6 @@
 //= require_everything_matching "shaders"
 //= require_everything_matching "resources"
 
-<% if Rails.env == "production" %>
-  Jax.environment = Jax.PRODUCTION;
-<% end %>
-
 for (var shaderName in Jax._shader_data) {
   if (!(Jax.shaders[shaderName] instanceof Jax.Shader)) {
     var descriptor = Jax._shader_data[shaderName];

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

@@ -1,5 +1,5 @@
 //= require "jax/vendor/ejs"
-//= require "jax/vendor/glMatrix"
+//= require "jax/vendor/gl-matrix"
 //= require "jax/prototype/class"
 //= require "jax/core/helper"
 //= require "jax/core/math"

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

@@ -59,6 +59,10 @@ var Jax = {
   click_speed: 0.2,
 };
 
+<% if Rails.env == "production" %>
+  Jax.environment = Jax.PRODUCTION;
+<% end %>
+
 // 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

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

@@ -35,6 +35,28 @@ vec3.toQuatRotation = function(first, second, dest) {
   }
 };
 
+
+/**
+ * vec3.distance(first, second) -> Number
+ * - first (vec3): a vector
+ * - second (vec3): a vector
+ *
+ * Returns the scalar distance between the two vectors. This
+ * is equivalent to:
+ *
+ *     vec3.length(vec3.subtract(first, second, tmp));
+ *
+ **/
+vec3.distance = function(a, b) {
+  var x = a[0] - b[0];
+  var y = a[1] - b[1];
+  var z = a[2] - b[2];
+  
+  var sum = x*x + y*y + z*z;
+  if (sum > 0) return Math.sqrt(sum);
+  return 0;
+};
+
 /**
  * vec3.multiply(a, b[, dest]) -> vec3
  * - a (vec3): left operand

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

@@ -1,4 +1,4 @@
-//= require "../vendor/glMatrix"
+//= require "../vendor/gl-matrix"
 //= require "../prototype/class"
 
 /**

data/lib/assets/javascripts/jax/mvc/model.js

@@ -109,6 +109,24 @@
        **/
       isShadowCaster: function() { return this.shadow_caster; },
 
+      /** alias of: Jax.Model#isShadowCaster
+       * Jax.Model#isShadowcaster() -> Boolean
+       *
+       * Returns true if this model casts shadows upon other models in the scene. Note that
+       * even if true, shadows will only be cast upon models which utilize +Jax.Material+s that support
+       * both the +Lighting+ and +ShadowMap+ effects.
+       *
+       **/
+      isShadowcaster: function() { return this.shadow_caster; },
+      
+      /**
+       * Jax.Model#disableShadows() -> Boolean
+       *
+       * Disables shadows cast by this model. Returns whether or not shadows were previously enabled
+       * prior to this method call.
+       **/
+      disableShadows: function() { var was = this.shadow_caster; this.shadow_caster = false; return was; },
+
       /**
        * Jax.Model#render(context) -> undefined
        * 

data/lib/assets/javascripts/jax/vendor/{glMatrix.js → gl-matrix.js}

@@ -1,4 +1,4 @@
-//= require "glMatrix"
+//= require "gl-matrix"
 //= require "jax/core/glMatrix_ext/mat3.js"
 //= require "jax/core/glMatrix_ext/mat4.js"
 //= require "jax/core/glMatrix_ext/quat4.js"

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

@@ -4,7 +4,7 @@ a new global called GL_METHODS. This will later be used for method delegation
 within Jax.Context.
  */
 
-//= require "jax/vendor/glMatrix"
+//= require "jax/vendor/gl-matrix"
 //= require_self
 /*
   all files in the webgl/ subdirectory will have access to a temporary GL context,

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

@@ -47,7 +47,7 @@ Jax.Camera = (function() {
   }
   
   function tmpRotQuat(self) {
-    return self._rotquat = self._rotquat || quat4.create();
+    return self._rotquat || (self._rotquat = quat4.create());
   }
   
   function storeVecBuf(self, buftype) {
@@ -94,10 +94,7 @@ Jax.Camera = (function() {
     self.stale = false;
 
     var pos = storeVecBuf(self, POSITION);
-    quat4.toMat4(self.rotation, self.matrices.mv);
-    mat4.translate(self.matrices.mv, vec3.negate(pos), self.matrices.mv);
-    mat4.inverse(self.matrices.mv);
-    
+    mat4.fromRotationTranslation(self.rotation, pos, self.matrices.mv);
     mat4.toInverseMat3(self.matrices.mv, self.matrices.n);
     mat3.transpose(self.matrices.n);
     
@@ -316,16 +313,6 @@ Jax.Camera = (function() {
       }
       
       return this.rotateWorld(amount, quat4.multiplyVec3(this.rotation, vec, this._tmp[0]));
-      
-      // var axis = storeVecBuf(this, RIGHT);
-      // this.rotateWorld(amount, axis);
-      // 
-      // var rotquat = quat4.fromAngleAxis(amount, vec, tmpRotQuat(this));
-      // quat4.normalize(rotquat);
-      // quat4.multiply(rotquat, this.rotation, this.rotation);
-      // 
-      // this.fireEvent('updated');
-      // return this;
     },
 
     /**
@@ -513,9 +500,9 @@ Jax.Camera = (function() {
       options = options || {};
       if (!options.width) throw new Error("Expected a screen width in Jax.Camera#perspective");
       if (!options.height)throw new Error("Expected a screen height in Jax.Camera#perspective");
-      options.fov  = options.fov  || 45;
-      options.near = options.near || 0.01;
-      options.far  = options.far  || 200;
+      options.fov  || (options.fov  = 45);
+      options.near || (options.near = 0.01);
+      options.far  || (options.far  = 200);
       
       var aspect_ratio = options.width / options.height;
       mat4.perspective(options.fov, aspect_ratio, options.near, options.far, this.matrices.p);
@@ -587,35 +574,33 @@ Jax.Camera = (function() {
       // winz is either 0 (near plane), 1 (far plane) or somewhere in between.
       // if it's not given a value we'll produce coords for both.
       if (typeof(winz) == "number") {
-        winx = parseFloat(winx);
-        winy = parseFloat(winy);
-        winz = parseFloat(winz);
-      
-        var inf = [];
+        var inf = vec4.create();
         var mm = this.getTransformationMatrix(), pm = this.matrices.p;
-        var viewport = [0, 0, pm.width, pm.height];
+        var viewport = [0, 0, this.projection.width, this.projection.height];
     
         //Calculation for inverting a matrix, compute projection x modelview; then compute the inverse
-        var m = mat4.set(mm, mat4.create());
-        
-        mat4.inverse(m, m); // WHY do I have to do this? --see Jax.Context#reloadMatrices
+        var m;
+        mat4.inverse(mm, m = mat4.create()); // WHY do I have to invert first?
         mat4.multiply(pm, m, m);
-        mat4.inverse(m, m);
-    
+        if (!mat4.inverse(m, m)) return null;
+        
         // Transformation of normalized coordinates between -1 and 1
-        inf[0]=(winx-viewport[0])/viewport[2]*2.0-1.0;
-        inf[1]=(winy-viewport[1])/viewport[3]*2.0-1.0;
-        inf[2]=2.0*winz-1.0;
-        inf[3]=1.0;
-    
+        inf[0] = (winx-viewport[0])/viewport[2]*2.0-1.0;
+        inf[1] = (winy-viewport[1])/viewport[3]*2.0-1.0;
+        inf[2] = 2.0*winz-1.0;
+        inf[3] = 1.0;
+        
         //Objects coordinates
-        var out = vec3.create();
+        var out = vec4.create();
         mat4.multiplyVec4(m, inf, out);
-        if(out[3]==0.0)
-           return null;
+        if (out[3] == 0.0) return null;
     
-        out[3]=1.0/out[3];
-        return [out[0]*out[3], out[1]*out[3], out[2]*out[3]];
+        var result = vec3.create();
+        out[3] = 1.0/out[3];
+        result[0] = out[0] * out[3];
+        result[1] = out[1] * out[3];
+        result[2] = out[2] * out[3];
+        return result;
       }
       else
         return [this.unproject(winx, winy, 0), this.unproject(winx, winy, 1)];

data/lib/assets/javascripts/jax/webgl/scene/light_source.js

@@ -43,6 +43,10 @@ Jax.Scene.LightSource = (function() {
         spot_exponent: 0,
         shadowcaster: true
       });
+      // Jax.Model uses `shadow_caster`, but previous versions of LightSource used `shadowcaster`.
+      // TODO deprecate both `shadow_caster` and `shadowcaster` in favor of something like boolean `shadows`.
+      data.shadow_caster = data.shadowcaster;
+      delete data.shadowcaster;
       
       if (typeof(data.type) == "string") data.type = Jax[data.type] || data.type;
       data.color.ambient = Jax.Util.colorize(data.color.ambient);
@@ -56,12 +60,12 @@ Jax.Scene.LightSource = (function() {
       this.spotExponent = this.spot_exponent;
       delete this.spot_exponent;
 
-      this.shadowMatrix = mat4.create();
-      
-      this.framebuffers = [new Jax.Framebuffer({width:1024,height:1024,depth:true,color:GL_RGBA}),
-                           new Jax.Framebuffer({width:1024,height:1024,depth:true,color:GL_RGBA})];
-
-      setupProjection(this);
+      if (this.isShadowCaster()) {
+        this.shadowMatrix = mat4.create();
+        this.framebuffers = [new Jax.Framebuffer({width:1024,height:1024,depth:true,color:GL_RGBA}),
+                             new Jax.Framebuffer({width:1024,height:1024,depth:true,color:GL_RGBA})];
+        setupProjection(this);
+      }
     },
     
     format: function() {
@@ -136,8 +140,6 @@ Jax.Scene.LightSource = (function() {
       /* FIXME remove the shadowmap event listener from object's camera matrix */
     },
     
-    isShadowcaster: function() { return this.shadowcaster; },
-    
     getDPShadowNear: function() { setupProjection(this); return this.camera.projection.near; },
     
     getDPShadowFar: function() { setupProjection(this); return this.camera.projection.far; },
@@ -146,35 +148,68 @@ Jax.Scene.LightSource = (function() {
     
     render: function(context, objects, options) {
       if (!this.valid) {
+        // calculate maximum distance, holding attenuation at 0.001, so we can
+        // skip shadowmapping of objects too far away
+        // Dmax = R(sqrt(Li/Ic) - 1)
+        //    where R is light radius (always 1 in Jax)
+        //    and Li is light intensity
+        //    and Ic is lowest acceptable attenuation
+        this.max_distance = Math.sqrt(this.getIntensity() / 0.001) - 1;
+
         var real_pass = context.current_pass;
         /* shadowgen pass */
         context.current_pass = Jax.Scene.SHADOWMAP_PASS;
         // Look for errors while rendering the shadow map; if any occur, log them, but then
         // disable shadowmap generation so Jax can continue without shadow support.
-        try {
-          if (this.shadowcaster)
+        if (this.isShadowCaster())
+          try {
             this.updateShadowMap(context, this.boundingRadius, objects, options);
-          this.valid = true;
-        } catch(e) {
-          if (Jax.getGlobal().console && Jax.getGlobal().console.log)
-            Jax.getGlobal().console.log(e.toString());
-          this.shadowcaster = false;
-        }
+          } catch(e) {
+            if (Jax.getGlobal().console && Jax.getGlobal().console.log)
+              Jax.getGlobal().console.log(e.toString());
+            this.disableShadows();
+          }
+        this.valid = true;
         context.current_pass = real_pass;
       }
       
+      this.renderWithinRange(context, objects, options);
+    },
+    
+    // Renders all objects within range of this light source, based on its color intensity
+    // and attenuation coefficients.
+    //
+    // Pass force=true in options to render all objects even if #isLit returns false. Even
+    // if force=true, the object will be skipped if it is outside of the light's range.
+    //
+    renderWithinRange: function(context, objects, options) {
       for (var j = 0; j < objects.length; j++) {
         options.model_index = j;
         
-        /* TODO optimization: see if objects[j] is even affected by this light (based on attenuation) */
-        if (objects[j].isLit()) // it could be unlit but still in array if it casts a shadow
-          objects[j].render(context, options);
+        if (options.force || objects[j].isLit()) {
+          var dist = vec3.distance(this.camera.getPosition(), objects[j].camera.getPosition())
+                   - objects[j].getBoundingSphereRadius();
+
+          if (dist < this.max_distance)
+            // it could be unlit but still in array if it casts a shadow
+            objects[j].render(context, options);
+        }
       }
     },
     
+    // returns a single float value representing the sum of the average intensities of each color channel
+    // of ambient, diffuse and specular components.
+    getIntensity: function() {
+      var c = this.color;
+      return (c.ambient[0] * c.ambient[3] + c.ambient[1] * c.ambient[3] + c.ambient[2] * c.ambient[3] +
+              c.diffuse[0] * c.diffuse[3] + c.diffuse[1] * c.diffuse[3] + c.diffuse[2] * c.diffuse[3] +
+              c.specular[0]* c.specular[3]+ c.specular[1]* c.specular[3]+ c.specular[2]* c.specular[3]) / 3.0;
+    },
+    
     updateShadowMap: function(context, sceneBoundingRadius, objects, render_options) {
       // we can't afford to taint the original options
-      render_options = Jax.Util.normalizeOptions(render_options, {});
+      render_options = Jax.Util.normalizeOptions(render_options, {force: true});
+      if (this.max_distance < sceneBoundingRadius) this.max_distance = sceneBoundingRadius;
       
       setupProjection(this);
       
@@ -217,9 +252,7 @@ Jax.Scene.LightSource = (function() {
             context.loadViewMatrix(self.camera.getTransformationMatrix());
             mat4.set(context.getInverseViewMatrix(), sm);
             
-            for (var i = 0; i < objects.length; i++) {
-              objects[i].render(context, render_options);
-            }
+            self.renderWithinRange(context, objects, render_options);
           });
 
           render_options.direction = -1;
@@ -229,9 +262,7 @@ Jax.Scene.LightSource = (function() {
             self.framebuffers[1].viewport(context);
             context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
             context.loadViewMatrix(self.camera.getTransformationMatrix());
-            for (var i = 0; i < objects.length; i++) {
-              objects[i].render(context, render_options);
-            }
+            self.renderWithinRange(context, objects, render_options);
           });
   
           context.glDisable(GL_POLYGON_OFFSET_FILL);
@@ -264,9 +295,7 @@ Jax.Scene.LightSource = (function() {
           context.glDisable(GL_BLEND);
           context.glEnable(GL_POLYGON_OFFSET_FILL);
           context.glPolygonOffset(2.0, 2.0);
-          for (var i = 0; i < objects.length; i++) {
-            objects[i].render(context, render_options);
-          }
+          self.renderWithinRange(context, objects, render_options);
           context.glDisable(GL_POLYGON_OFFSET_FILL);
           context.glEnable(GL_BLEND);
           context.glCullFace(GL_BACK);

data/lib/jax/version.rb

@@ -2,7 +2,7 @@ module Jax
   module Version
     MAJOR = 2
     MINOR = 0
-    PATCH = 4
+    PATCH = 5
     BUILD = nil
     STRING = BUILD ? [MAJOR, MINOR, PATCH, BUILD].join(".") : [MAJOR, MINOR, PATCH].join(".")
   end

data/spec/javascripts/jax/core/utils_spec.js

@@ -177,6 +177,15 @@ describe("Jax.Util", function() {
   
   describe("normalizeOptions", function() {
     var normalized;
+    
+    describe("with a false value that defaults to true", function() {
+      beforeEach(function() { normalized = Jax.Util.normalizeOptions({enabled:false}, {enabled:true}); });
+      
+      it("should not have a truthy value", function() {
+        expect(normalized.enabled).toBeFalsy();
+      });
+    });
+    
     describe("with a missing default array", function() {
       var arr = [1,2,3];
       beforeEach(function() { normalized = Jax.Util.normalizeOptions(null, {def:arr}); });

data/spec/javascripts/jax/webgl/camera_spec.js

@@ -3,6 +3,31 @@ describe("Camera", function() {
   
   beforeEach(function() { camera = new Jax.Camera(); });
   
+  it("should unproject properly", function() {
+    camera.perspective({width:800,height:500,near:0.1,far:200});
+    
+    camera.setPosition([38.375, 75, 44.25]);
+    // camera.setUpVector([0, 0.196116, -0.980580]);
+    // camera.setRightVector([1,0,0]);
+    camera.setViewVector([0, -0.980580, -0.196116]);
+    
+    // sanity checks
+    expect(camera.getPosition()).toEqualVector([38.375, 75, 44.25]);
+    expect(camera.getUpVector()).toEqualVector([0, 0.196116, -0.980580]);
+    expect(camera.getRightVector()).toEqualVector([1,0,0]);
+    expect(camera.getViewVector()).toEqualVector([0, -0.980580, -0.196116]);
+    
+    
+    var nearest = [ 38.308727, 74.893821, 44.271007 ];
+    var farthest = [-94.170333, -137.355712, 86.261283];
+    
+    // all that for this:
+    expect(camera.unproject(0, 0, 0)).toEqualVector(nearest);
+    expect(camera.unproject(0, 0, 1)).toEqualVector(farthest);
+    expect(camera.unproject(0, 0)[0]).toEqualVector(nearest);
+    expect(camera.unproject(0, 0)[1]).toEqualVector(farthest);
+  });
+  
   it("movement with rotations", function() {
     camera.move(10);
     camera.yaw(Math.PI/2);