jax 0.0.0.8 → 0.0.0.9

data/lib/jax/generators/app/templates/public/javascripts/jax.js

@@ -2256,18 +2256,25 @@ Jax.Util = {
 
   vectorize: function(data) {
     if (data) {
-      var res = vec3.create();
+      var res = [];//vec3.create();
       if (typeof(data) == "string") {
         var components = data.split(/[,\s]+/);
-        if (components.length >= 3) {
-          for (var i = 0; i < 3; i++)
+        if (components.length >= 2) {
+          for (var i = 0; i < components.length; i++)
             res[i] = parseFloat(components[i]);
         }
         return res;
       }
       if (data.length && data.length >= 3) return vec3.set(data, res);
-      if ((res[0] = data.x) != undefined && (res[1] = data.y) != undefined && (res[2] = data.z) != undefined) return res;
-      if ((res[0] = data[0]) != undefined && (res[1] = data[1]) != undefined && (res[2] = data[2]) != undefined) return res;
+      else if (data.length == 2) return [data[0], data[1]];
+      if ((res[0] = data.x) != undefined && (res[1] = data.y) != undefined) {
+        if (data.z != undefined) res[2] = data.z;
+        return res;
+      }
+      if ((res[0] = data[0]) != undefined && (res[1] = data[1]) != undefined) {
+        if (data[2] != undefined) res[2] = data[2];
+        return res;
+      }
     }
     throw new Error("Input argument for Jax.Util.vectorize not recognized: "+JSON.stringify(data));
   },
@@ -2783,6 +2790,7 @@ Jax.Helper = {
       },
 
       getBoundingCube: function() {
+        if (!this.mesh) return {left:0,right:0,bottom:0,top:0,front:0,back:0,width:0,height:0,depth:0};
         if (!this.mesh.built) this.mesh.rebuild();
         return this.mesh.bounds;
       },
@@ -5334,6 +5342,9 @@ Jax.Scene.LightSource = (function() {
       data.color.specular= Jax.Util.colorize(data.color.specular);
       $super(data);
 
+      var self = this;
+      this.camera.addEventListener('matrixUpdated', function() { self.invalidate(); });
+
       this.spotExponent = this.spot_exponent;
       delete this.spot_exponent;
 
@@ -5406,13 +5417,47 @@ Jax.Scene.LightSource = (function() {
       return this.shadowMatrix;
     },
 
+    registerCaster: function(object) {
+      var self = this;
+      function updated() { self.invalidate(); }
+      object.camera.addEventListener('matrixUpdated', updated);
+      this.invalidate();
+    },
+
+    unregisterCaster: function(object) {
+      /* 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; },
 
-    updateShadowMap: function(context, sceneBoundingRadius, objects) {
+    invalidate: function() { this.valid = false; },
+
+    render: function(context, objects, options) {
+      if (!this.valid) {
+        var real_pass = context.current_pass;
+        /* shadowgen pass */
+        context.current_pass = Jax.Scene.SHADOWMAP_PASS;
+        this.updateShadowMap(context, this.boundingRadius, objects, options);
+        this.valid = true;
+        context.current_pass = real_pass;
+      }
+
+      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);
+      }
+    },
+
+    updateShadowMap: function(context, sceneBoundingRadius, objects, render_options) {
+      render_options = Jax.Util.normalizeOptions(render_options, {});
+
       setupProjection(this);
 
       var self = this;
@@ -5442,6 +5487,9 @@ Jax.Scene.LightSource = (function() {
         context.glPolygonOffset(2.0, 2.0);
 
         context.pushMatrix(function() {
+          render_options.direction = 1;
+          render_options.material = paraboloid_depthmap;
+
           self.framebuffers[0].bind(context, function() {
             self.framebuffers[0].viewport(context);
             context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -5449,16 +5497,18 @@ Jax.Scene.LightSource = (function() {
             mat4.set(context.getInverseViewMatrix(), sm);
 
             for (var i = 0; i < objects.length; i++) {
-              objects[i].render(context, {material:paraboloid_depthmap, direction:1});
+              objects[i].render(context, render_options);
             }
           });
 
+          render_options.direction = -1;
+
           self.framebuffers[1].bind(context, 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, {material:paraboloid_depthmap,direction:-1});
+              objects[i].render(context, render_options);
             }
           });
 
@@ -5473,6 +5523,8 @@ Jax.Scene.LightSource = (function() {
         return;
       }
 
+      render_options.material = "depthmap";
+
       this.framebuffers[0].bind(context, function() {
         self.framebuffers[0].viewport(context);
         context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -5490,7 +5542,7 @@ Jax.Scene.LightSource = (function() {
           context.glEnable(GL_POLYGON_OFFSET_FILL);
           context.glPolygonOffset(2.0, 2.0);
           for (var i = 0; i < objects.length; i++) {
-            objects[i].render(context, {material:'depthmap'});
+            objects[i].render(context, render_options);
           }
           context.glDisable(GL_POLYGON_OFFSET_FILL);
           context.glEnable(GL_BLEND);
@@ -5528,12 +5580,64 @@ Jax.Scene.LightManager = (function() {
     initialize: function(context) {
       this.context = context;
       this._lights = [];
+      this.objects = [];
+    },
+
+    addObject: function(obj) {
+      this.objects.push(obj);
+      for (var j = 0; j < this._lights.length; j++)
+        if (obj.isShadowCaster())
+          this._lights[j].registerCaster(obj);
+      this.recalculateBoundingRadius();
+    },
+
+    removeObject: function(obj) {
+      if (this.objects[obj]) {
+        var o = this.objects[obj];
+        this.objects.splice(obj, 1);
+        for (var j = 0; j < this._lights.length; j++)
+          if (o.isShadowCaster())
+            this._lights[j].unregisterCaster(o);
+        this.recalculateBoundingRadius();
+        return o;
+      }
+      for (var i = 0; i < this.objects.length; i++)
+        if (this.objects[i] == obj)
+          return this.removeObject(obj);
+    },
+
+    getShadowCasters: function() {
+      var ret = [];
+      for (var i = 0; i < this.objects.length; i++) {
+        if (this.objects[i].isShadowCaster())
+          ret.push(this.objects[i]);
+      }
+      return ret;
     },
 
     add: function(light) {
       if (this._lights.length == Jax.max_lights)
         throw new Error("Maximum number of light sources in a scene has been exceeded! Try removing some first.");
+      for (var i = 0; i < this.objects.length; i++) {
+        if (this.objects[i].isShadowCaster())
+          light.registerCaster(this.objects[i]);
+      }
       this._lights.push(light);
+      light.boundingRadius = this.boundingRadius || 0;
+    },
+
+    recalculateBoundingRadius: function() {
+      var boundingRadius = null;
+      var i, j;
+      for (i = 0; i < this.objects.length; i++) {
+        j = vec3.length(this.objects[i].camera.getPosition()) + this.objects[i].getBoundingSphereRadius();
+        if (boundingRadius == null || boundingRadius < j)
+          boundingRadius = j;
+      }
+      this.boundingRadius = boundingRadius = boundingRadius || 0;
+
+      for (i = 0; i < this._lights.length; i++)
+        this._lights[i].boundingRadius = boundingRadius;
     },
 
     enable: function() { this.enabled = true; },
@@ -5560,52 +5664,17 @@ Jax.Scene.LightManager = (function() {
       return result;
     },
 
-    illuminate: function(context, objects, options) {
+    illuminate: function(context, options) {
       options = Jax.Util.normalizeOptions(options, {});
 
       this.context.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-      for (var i = 0; i < this._lights.length; i++) {
-        for (var j = 0; j < objects.length; j++) {
-          this._current_light = i;
-          options.model_index = j;
-
-          /* TODO optimization: see if objects[j] is even affected by this._lights[i] (based on attenuation) */
-          if (objects[j].isLit())
-            objects[j].render(context, options);
-        }
-        this.context.glBlendFunc(GL_ONE, GL_ONE);
-      }
-      delete this._current_light;
-    },
-
-    ambient: function(context, objects, options) {
-      options = Jax.Util.normalizeOptions(options, {});
-
       for (var i = 0; i < this._lights.length; i++) {
         this._current_light = i;
-        for (var j = 0; j < objects.length; j++) {
-          options.model_index = j;
-
-          /* TODO optimization: see if objects[j] is even affected by this._lights[i] (based on attenuation) */
-          if (objects[j].isLit())
-            objects[j].render(context, options);
-        }
-      }
-      delete this._current_light;
-    },
-
-    updateShadowMaps: function(context, objects) {
-      var boundingRadius = null;
-      var i, j;
-      for (i = 0; i < objects.length; i++) {
-        j = vec3.length(objects[i].camera.getPosition()) + objects[i].getBoundingSphereRadius();
-        if (boundingRadius == null || boundingRadius < j)
-          boundingRadius = j;
+        this._lights[i].render(context, this.objects, options);
+        if (i == 0) this.context.glBlendFunc(GL_ONE, GL_ONE);
       }
-      boundingRadius = boundingRadius || 0;
 
-      for (i = 0; i < this._lights.length; i++)
-        this._lights[i].updateShadowMap(context, boundingRadius, objects);
+      delete this._current_light;
     },
 
     getDirection: function(index) { return this.getLight(index).getDirection(); },
@@ -5978,7 +6047,12 @@ Jax.World = (function() {
 
     addLightSource: function(light)   { this.lighting.add(light); },
 
-    addObject: function(object) { this.objects.push(object); this.invalidate(); return object; },
+    addObject: function(object) {
+      this.objects.push(object);
+      if (object.isLit() || object.isShadowCaster())
+        this.lighting.addObject(object);
+      return object;
+    },
 
     getObject: function(index) { return this.objects[index]; },
 
@@ -5986,7 +6060,7 @@ Jax.World = (function() {
       if (this.objects[object_or_index]) {
         var obj = this.objects[object_or_index];
         this.objects.splice(object_or_index, 1);
-        this.invalidate();
+        this.lighting.removeObject(obj);
         return obj;
       }
       else
@@ -5994,7 +6068,7 @@ Jax.World = (function() {
           if (this.objects[i] == object_or_index)
           {
             this.objects.splice(i, 1);
-            this.invalidate();
+            this.lighting.removeObject(this.objects[i]);
             return this.objects[i];
           }
     },
@@ -6054,32 +6128,7 @@ Jax.World = (function() {
       return this.objects.length;
     },
 
-    invalidate: function() {
-      while (this.shadow_casters.length > 0) {
-        /* TODO we still need to unregister the camera event listener */
-        this.shadow_casters.pop();
-      }
-
-      var updated = function() { self.shadowmaps_valid = false; };
-
-      var i;
-      for (i = 0; i < this.objects.length; i++) {
-        var self = this;
-        if (this.objects[i].isShadowCaster()) {
-          this.objects[i].camera.addEventListener('matrixUpdated', updated);
-          this.shadow_casters.push(this.objects[i]);
-        }
-      }
-
-      for (i = 0; i < this.lighting.count(); i++) {
-        var light = this.lighting.getLight(i);
-        if (light.isShadowcaster())
-          light.camera.addEventListener('matrixUpdated', updated);
-      }
-      this.shadowmaps_valid = false;
-    },
-
-    getShadowCasters: function() { return this.shadow_casters; },
+    getShadowCasters: function() { return this.lighting.getShadowCasters(); },//return this.shadow_casters; },
 
     render: function(options) {
       var i;
@@ -6091,29 +6140,16 @@ Jax.World = (function() {
       var unlit = Jax.Util.normalizeOptions(options, {unlit:true});
 
       if (this.lighting.isEnabled() && (!unlit.material || unlit.material.supportsLighting())) {
-        /* ambient pass */
-        /*
-          So.... I see a legit need for an ambient pass for A) unlit objects and B)
-          scene lighting. But jax doesn't yet support scene lighting so really only
-          unlit objects need an ambient pass. For lit objects, why not let
-          lighting take care of (ambient + diffuse + specular) all at once?
-        */
+        /* ambient pass - unlit objects only because lit objects get ambient+diffuse+specular in one pass */
         for (i = 0; i < this.objects.length; i++)
-          if (!this.objects[i].lit) {
+          if (!this.objects[i].isLit()) {
             unlit.model_index = i;
             this.objects[i].render(this.context, unlit);
           }
 
-        /* shadowgen pass */
-        this.context.current_pass = Jax.Scene.SHADOWMAP_PASS;
-        if (!this.shadowmaps_valid) {
-          this.lighting.updateShadowMaps(this.context, this.shadow_casters);
-          this.shadowmaps_valid = true;
-        }
-
         /* illumination pass */
         this.context.current_pass = Jax.Scene.ILLUMINATION_PASS;
-        this.lighting.illuminate(this.context, this.objects, options);
+        this.lighting.illuminate(this.context, options);
       } else {
         for (i = 0; i < this.objects.length; i++) {
           unlit.model_index = i;
@@ -6843,7 +6879,7 @@ Jax.Context = (function() {
       var error = this.glGetError();
       if (error != GL_NO_ERROR)
       {
-        var str = "GL error in "+this.canvas.id+": "+error;
+        var str = "GL error in "+this.canvas.id+": "+error+" ("+Jax.Util.enumName(error)+")";
         error = new Error(str);
         var message = error;
         if (error.stack)

data/lib/jax/generators/app/templates/spec/javascripts/support/spec_helpers/jax_spec_environment_helper.js

@@ -0,0 +1,33 @@
+function setupJaxTestEnvironment() {
+  var jasmineEnv = jasmine.getEnv();
+
+  jsApiReporter = new jasmine.JsApiReporter();
+  var trivialReporter = new jasmine.TrivialReporter();
+
+  jasmineEnv.addReporter(jsApiReporter);
+  jasmineEnv.addReporter(trivialReporter);
+
+  jasmineEnv.specFilter = function(spec) {
+    return trivialReporter.specFilter(spec);
+  };
+
+  /*
+    Create a canvas element and add it to the document. 
+    There's nothing special about this element.
+   */
+  var canvas = document.createElement("canvas");
+  canvas.setAttribute("id", "spec-canvas");
+  canvas.style.display = "none";
+  document.body.appendChild(canvas);
+  
+  beforeEach(function() {
+    window.SPEC_CONTEXT = new Jax.Context(canvas);
+  });
+  
+  afterEach(function() {
+    SPEC_CONTEXT.dispose();
+  })
+
+
+  jasmineEnv.execute();
+}

data/lib/jax/generators/app/templates/spec/javascripts/support/spec_layout.html.erb

@@ -14,20 +14,8 @@
   <script type="text/javascript">
     var jsApiReporter;
     (function() {
-      var jasmineEnv = jasmine.getEnv();
-
-      jsApiReporter = new jasmine.JsApiReporter();
-      var trivialReporter = new jasmine.TrivialReporter();
-
-      jasmineEnv.addReporter(jsApiReporter);
-      jasmineEnv.addReporter(trivialReporter);
-
-      jasmineEnv.specFilter = function(spec) {
-        return trivialReporter.specFilter(spec);
-      };
-
       window.onload = function() {
-        jasmineEnv.execute();
+        setupJaxTestEnvironment();
         
         /*
           Create a canvas element and add it to the document. 

data/lib/jax/generators/shader/templates/fragment.ejs.tt

@@ -1,7 +1,6 @@
 /*
-  If you don't need the color attributes, use
-      void main(void)
-  to make your shader more efficient.
+  ambient, diffuse and specular represent the cumulative color to be eventually
+  written to +gl_FragColor+. You should output your colors into these vectors.
 */
 void main(inout vec4 ambient, inout vec4 diffuse, inout vec4 specular) {
 

data/lib/jax/generators/shader/templates/spec.js.tt

@@ -1,20 +1,13 @@
 describe("Shader '<%=file_name%>'", function() {
-  var context, material, mesh;
+  var material, mesh;
 
-  beforeEach(function() {
-    context = new Jax.Context('webgl-canvas');
-    mesh = new Jax.Mesh.Quad();
-  });
-  
-  /* dispose the context so it doesn't continue using
-     resources after the tests have completed */
-  afterEach(function() { context.dispose(); });
+  beforeEach(function() { mesh = new Jax.Mesh.Quad(); });
 
   describe("stand-alone", function() {
     beforeEach(function() { mesh.material = new Jax.Material.<%=class_name%>(); });
 
     it("should render without error", function() {
-      expect(function() { mesh.render(context); }).not.toThrow();
+      expect(function() { mesh.render(SPEC_CONTEXT); }).not.toThrow();
     });
   });
 
@@ -26,7 +19,7 @@ describe("Shader '<%=file_name%>'", function() {
     });
 
     it("should render without error", function() {
-      expect(function() { mesh.render(context); }).not.toThrow();
+      expect(function() { mesh.render(SPEC_CONTEXT); }).not.toThrow();
     });
   });
 });