jax 0.0.0.1

data/spec/javascripts/jax/helper_spec.js

@@ -0,0 +1,33 @@
+describe("Jax.Helper", function() {
+  var helper;
+  
+  beforeEach(function() {
+    helper = Jax.Helper.create({
+      test_method: function() { return 1; }
+    });
+  });
+  
+  it("should define the helper in requesting controllers", function() {
+    var controller = Jax.Controller.create({
+      helpers: function() { return [helper]; }
+    });
+    expect(controller.prototype.test_method).toEqual(helper.test_method);
+  });
+
+  it("should not define the helper in non-requesting controllers", function() {
+    var controller = Jax.Controller.create({});
+    expect(controller.prototype.test_method).toBeUndefined();
+  });
+
+  it("should define the helper in requesting models", function() {
+    var model = Jax.Class.create(Jax.Model, {
+      helpers: function() { return [helper]; }
+    });
+    expect(model.prototype.test_method).toEqual(helper.test_method);
+  });
+
+  it("should not define the helper in non-requesting models", function() {
+    var model = Jax.Class.create(Jax.Model, {});
+    expect(model.prototype.test_method).toBeUndefined();
+  });
+});

data/spec/javascripts/jax/model_spec.js

@@ -0,0 +1,87 @@
+describe("Jax.Model", function() {
+  var model;
+  
+  describe("as a resource", function() {
+    // do these things only once, because we're going to see how one model instance interacts with another
+    var klass, res_data = { "name": {one: { value : 1 } } };
+    klass = Jax.Model.create({});
+    klass.addResources(res_data);
+
+    beforeEach(function() {
+      model = klass.find("name");
+    });
+    
+    it("should find new resource instances instead of existing ones", function() {
+      model.two = 2;
+      model = klass.find("name");
+      expect(model.two).toBeUndefined();
+    });
+    
+    it("should not alter the original resource data", function() {
+      model.one.value = 2;
+      model = klass.find("name");
+      expect(model.one.value).not.toEqual(2);
+    });
+  });
+    
+  describe("without any custom methods", function() {
+    beforeEach(function() {
+      model = Jax.Model.create({
+        initialize: function($super, data) { $super(Jax.Util.normalizeOptions(data, {mesh:new Jax.Mesh.Quad()})); }
+      });
+    });
+    
+    describe("instantiated", function() {
+      beforeEach(function() { model = new model(); });
+      
+      describe("that is not a shadowcaster", function() {
+        beforeEach(function() { model.shadow_caster = false; });
+        it("should still be lit", function() { expect(model).toBeIlluminated(); });
+      });
+
+      describe("that is not lit", function() {
+        beforeEach(function() { model.lit = false; });
+        it("should not be rendered in illumination pass", function() {
+          expect(model).not.toBeIlluminated();
+        });
+      });
+
+      it("should render properly", function() {
+        var context = new Jax.Context('canvas-element');
+        model.render(context);
+        context.dispose();
+      });
+    });
+  
+    it("should fire after_initialize", function() {
+      model.addResources({ "name": { fired: false } });
+      model.addMethods({ after_initialize: function() { this.fired = true; } });
+      expect(model.find("name").fired).toBeTrue();
+    });
+    
+    it("should raise an error when searching for a missing ID", function() {
+      model.addResources({"one": { } });
+      expect(function() { model.find("two") }).toThrow(new Error("Resource 'two' not found!"));
+    });
+    
+    it("should assign default attribute values", function() {
+      model.addResources({'default':{one:'one'},'name':{two:'two'}});
+      expect(model.find('name').one).toEqual("one");
+      expect(model.find('name').two).toEqual("two");
+    });
+
+    it("should assign attribute values", function() {
+      model.addResources({ "name": { one: "one" } });
+      expect(model.find("name").one).toEqual("one");
+    });
+  
+    it("should instantiate a model that is missing default attributes", function() {
+      expect(function() { new model(); }).not.toThrow();
+    });
+  });
+  
+  describe("with a custom method", function() {
+    beforeEach(function() { model = Jax.Model.create({method: function() { return "called"; } }); });
+    it("should work", function() { expect(new model().method()).toEqual("called"); });
+  });
+});

data/spec/javascripts/jax/optimizations/material_limitations_spec.js

@@ -0,0 +1,87 @@
+describe("Jax.Material exceeding GPU limitations", function() {
+  var matr, context, mesh;
+  var layer, layer_class;
+  var real = { varyings: Jax.Shader.max_varyings, uniforms: Jax.Shader.max_uniforms, attributes: Jax.Shader.max_attributes };
+  
+  beforeEach(function() {
+    matr = new Jax.Material();
+    mesh = new Jax.Mesh.Quad();
+    context = new Jax.Context('canvas-element');
+    // a layer that uses at least 1 of everything we'll test
+    Jax.shaders['_debug_layer'] = new Jax.Shader({name:"_debug_layer",
+                            common:"uniform float X; varying float Z;",
+                            vertex:"attribute float Y; void main(void) { Z = X + Y; gl_Position = vec4(0,0,0,1); }",
+                            fragment: "void main(void) { gl_FragColor = vec4(Z); }"
+    });
+    layer_class = Jax.Class.create(Jax.Material, {initialize:function($super) { $super({shader:"_debug_layer"}); }});
+    layer = new layer_class();
+    matr.addLayer(new Jax.Material.Lighting());
+    matr.addLayer(layer);
+  });
+  
+  afterEach(function() {
+    context.dispose();
+    Jax.Shader.max_varyings = real.varyings;
+    Jax.Shader.max_uniforms = real.uniforms;
+    Jax.Shader.max_attributes = real.attributes;
+  });
+  
+  // fake out the max. number of varyings so we can test reliably
+  function stub(what) {
+    var chain = new Jax.ShaderChain();
+    chain.addShader(Jax.shaders[Jax.default_shader]);
+    switch(what) {
+      case 'varyings':  Jax.Shader.max_varyings  = chain.countVaryings(matr);  break;
+      case 'uniforms':  Jax.Shader.max_uniforms  = chain.countUniforms(matr);  break;
+      case 'attributes':Jax.Shader.max_attributes= chain.countAttributes(matr);break;
+      default: throw new Error("wtf?");
+    }
+  }
+  
+  describe("on number of varyings", function() {
+    beforeEach(function() { stub('varyings'); });
+    
+    it("should first cull any materials which cannot possibly be used", function() {
+      Jax.Shader.max_varyings++; // 1 for the most recent shader; render should produce 1 layer ('lighting'), not 0
+      matr.render(context, mesh, {});
+      // we expect it to be Lighting and not shader_class, because Lighting only has 1 varying. :)
+      expect(matr.layers[0]).toBeKindOf(Jax.Material.Lighting);
+    });
+    
+    it("should back off shader steps incrementally", function() {
+      matr.render(context, mesh, {});
+      expect(matr.layers.length).toEqual(0);
+    });
+  });
+
+  describe("on number of attributes", function() {
+    beforeEach(function() { stub('attributes'); });
+    
+    it("should first cull any materials which cannot possibly be used", function() {
+      Jax.Shader.max_attributes++; // 1 for the most recent shader; render should produce 1 layer ('lighting'), not 0
+      matr.render(context, mesh, {});
+      // we expect it to be Lighting instead of layer_class, becuase LIghting has no varyings.
+      expect(matr.layers[0]).toBeKindOf(Jax.Material.Lighting);
+    });
+    
+    it("should back off shader steps incrementally", function() {
+      matr.render(context, mesh, {});
+      expect(matr.layers.length).toEqual(1); // see above
+    });
+  });
+  
+  describe("on number of uniforms", function() {
+    beforeEach(function() { stub('uniforms'); });
+    
+    it("should first cull any materials which cannot possibly be used", function() {
+      Jax.Shader.max_uniforms++; // 1 for the most recent shader; render should produce 1 layer ('shader_class'), not 0
+      matr.render(context, mesh, {});
+      expect(matr.layers[0]).toBeKindOf(layer_class);
+    });
+    
+    it("should back off shader steps incrementally", function() {
+      matr.render(context, mesh, {});
+      expect(matr.layers.length).toEqual(0);
+    });
+  });
+});

data/spec/javascripts/jax/optimizations/shaders/basic_spec.js

@@ -0,0 +1,68 @@
+describe("Opt: Basic shader", function() {
+  var model, context;
+  var _tex = "/images/rss.png", _norm = "/images/normal_map.jpg";
+  
+  beforeEach(function() {
+    context = new Jax.Context('canvas-element');
+    model = new Jax.Model({mesh: new Jax.Mesh.Quad()});
+    context.world.addObject(model);
+  });
+  
+  afterEach(function() { context.dispose(); });
+  
+  describe("without textures", function() {
+    it("should not build tangent space", function() {
+      spyOn(model.mesh, 'getTangentBuffer').andCallThrough();
+      context.world.render();
+      expect(model.mesh.getTangentBuffer).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("with 1 regular texture", function() {
+    beforeEach(function() {
+      model.mesh.material = new Jax.Material({texture: _tex});
+    });
+    
+    it("should not build tangent space", function() {
+      spyOn(model.mesh, 'getTangentBuffer').andCallThrough();
+      context.world.render();
+      expect(model.mesh.getTangentBuffer).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("with 1 normal map texture", function() {
+    beforeEach(function() {
+      model.mesh.material = new Jax.Material({texture: {path:_norm, type:Jax.NORMAL_MAP}});
+    });
+    
+    it("should build tangent space", function() {
+      spyOn(model.mesh, 'getTangentBuffer').andCallThrough();
+      context.world.render();
+      expect(model.mesh.getTangentBuffer).toHaveBeenCalled();
+    });
+  });
+
+  describe("with 2 regular textures", function() {
+    beforeEach(function() {
+      model.mesh.material = new Jax.Material({textures: [_tex, _tex]});
+    });
+    
+    it("should not build tangent space", function() {
+      spyOn(model.mesh, 'getTangentBuffer').andCallThrough();
+      context.world.render();
+      expect(model.mesh.getTangentBuffer).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("with 1 normal and 1 regular texture", function() {
+    beforeEach(function() {
+      model.mesh.material = new Jax.Material({textures: [_tex, {path:_norm,type:Jax.NORMAL_MAP}]});
+    });
+    
+    it("should build tangent space", function() {
+      spyOn(model.mesh, 'getTangentBuffer').andCallThrough();
+      context.world.render();
+      expect(model.mesh.getTangentBuffer).toHaveBeenCalled();
+    });
+  });
+});

data/spec/javascripts/jax/prototype/extensions_spec.js

@@ -0,0 +1,34 @@
+describe("Prototype extensions:", function() {
+  describe("Class", function() {
+    var klass;
+    var subklass;
+      
+    beforeEach(function() {
+      klass = Jax.Class.create({ });
+      subklass = Jax.Class.create(klass, {});
+    });
+
+    it("should be a kind of itself", function() {
+      expect(new klass()).toBeKindOf(klass);
+    });
+    
+    it("should not be a kind of its subclass", function() {
+      expect(new klass()).not.toBeKindOf(subklass);
+    });
+    
+    describe("Subclass", function() {
+      it("should be a kind of itself", function() {
+        expect(new subklass()).toBeKindOf(subklass);
+      });
+
+      it("should be a kind of its superclass", function() {
+        expect(new subklass()).toBeKindOf(subklass.superclass);
+      });
+      
+      /* theoretically the same as above, but... */
+      it("should be a kind of klass", function() {
+        expect(new subklass()).toBeKindOf(klass);
+      });
+    });
+  });
+});

data/spec/javascripts/jax/route_set_spec.js

@@ -0,0 +1,67 @@
+describe("Jax.RouteSet", function() {
+  var map;
+  var controller_class = Jax.Controller.create({index: function() { }});
+  Jax.views.push("generic/index", function() { });
+  
+  beforeEach(function() { map = new Jax.RouteSet(); });
+  
+  describe("route descriptor", function() {
+    var descriptor;
+    
+    it("from descriptor", function() {
+      descriptor = map.getRouteDescriptor({controller:controller_class, id: 1});
+      expect(descriptor.controller).toEqual(controller_class);
+      expect(descriptor.action).toEqual("index");
+      expect(descriptor.id).toEqual(1);
+    });
+    
+    it("from controller (klass)", function() {
+      descriptor = map.getRouteDescriptor(controller_class);
+      expect(descriptor.controller).toEqual(controller_class);
+      expect(descriptor.action).toEqual("index");
+    });
+    
+    it("from controller (klass) and action name (string)", function() {
+      descriptor = map.getRouteDescriptor(controller_class, "action_name");
+      expect(descriptor.controller).toEqual(controller_class);
+      expect(descriptor.action).toEqual("action_name");
+    });
+  });
+  
+  describe("with a map", function() {
+    beforeEach(function() { map.map("generic/index", controller_class, "index"); });
+    it("should recognize the route without /index", function() {
+      var route = map.recognize_route("generic");
+      
+      expect(route.controller).toEqual(controller_class);
+      expect(route.action).toEqual("index");
+    });
+  });
+  
+  describe("with a root", function() {
+    beforeEach(function() { map.root(controller_class, "index"); });
+    
+    it("should recognize the root route", function() {
+      var route = map.recognize_route("/");
+      
+      expect(route.controller).toEqual(controller_class);
+      expect(route.action).toEqual("index");
+    });
+    
+    it("should dispatch to the root controller", function() {
+      spyOn(controller_class, 'invoke').andCallThrough();
+      map.dispatch("/");
+      expect(controller_class.invoke).toHaveBeenCalledWith("index", undefined);
+    });
+    
+    it("should return the controller instance", function() {
+      expect(map.dispatch("/")).toBeKindOf(controller_class);
+    });
+  });
+  
+  describe("with no root", function() {
+    it("should throw an error recognizing the root route", function() {
+      expect(function() { map.recognize_route("/") }).toThrow(new Error("Route not recognized: '/'"));
+    });
+  });
+});

data/spec/javascripts/jax/view_manager_spec.js

@@ -0,0 +1,17 @@
+describe("Jax.ViewManager", function() {
+  var views;
+  
+  beforeEach(function() { views = new Jax.ViewManager(); });
+  
+  describe("with one registered view", function() {
+    beforeEach(function() { views.push("controller/action", function() { }); });
+    
+    it("should return the registered view", function() {
+      expect(views.get("controller/action")).toBeKindOf(Jax.View);
+    });
+    
+    it("should throw an error when requesting a missing view", function() {
+      expect(function() { return views.get("missing/action"); }).toThrow(new Error("Could not find view at 'missing/action'!"));
+    });
+  });
+});

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

@@ -0,0 +1,159 @@
+describe("Camera", function() {
+  var camera, control;
+  
+  beforeEach(function() { camera = new Jax.Camera(); });
+  
+  describe("by default", function() {
+    it("should have position [0,0,0]", function() { expect(camera.getPosition()).toEqualVector([0,0,0]); });
+    it("should have view [0,0,-1]", function() { expect(camera.getViewVector()).toEqualVector([0,0,-1]); });
+    it("should have right [1,0,0]", function() { expect(camera.getRightVector()).toEqualVector([1,0,0]); });
+    it("should have up [0,1,0]", function() { expect(camera.getUpVector()).toEqualVector([0,1,0]); });
+  });
+  
+  describe("perspective projection", function() {
+    beforeEach(function() { camera.perspective({fov:45,near:0.1,far:500,width:2048,height:1024}); });
+    
+    it("should have fov 45", function() { expect(camera.projection.fov).toEqual(45); });
+    it("should have near 0.1", function() { expect(camera.projection.near).toEqual(0.1); });
+    it("should have far 500", function() { expect(camera.projection.far).toEqual(500); });
+    it("should have width 2048", function() { expect(camera.projection.width).toEqual(2048); });
+    it("should have height 1024", function() { expect(camera.projection.height).toEqual(1024); });
+  });
+  
+  describe("ortho projection", function() {
+    beforeEach(function() { camera.ortho({left:-1,right:2,top:3,bottom:-4,near:0.1,far:500}); });
+    
+    it("should have left -1", function() { expect(camera.projection.left).toEqual(-1); });
+    it("should have right 2", function() { expect(camera.projection.right).toEqual(2); });
+    it("should have top 3", function() { expect(camera.projection.top).toEqual(3); });
+    it("should have bottom -4", function() { expect(camera.projection.bottom).toEqual(-4); });
+    it("should have near 0.1", function() { expect(camera.projection.near).toEqual(0.1); });
+    it("should have far 500", function() { expect(camera.projection.far).toEqual(500); });
+  });
+  
+  it("should set and get position accurately", function() {
+    camera.setPosition(20, 0, 20);
+    expect(camera.getPosition()).toEqualVector([20,0,20]);
+  });
+  
+  it("should lookAt the origin without losing position", function() {
+    camera.setPosition(20, 0, 20);
+    expect(camera.getPosition()).toEqualVector([20,0,20]);
+    camera.lookAt([0,0,0], [0,1,0]);
+    expect(camera.getPosition()).toEqualVector([20,0,20]);
+  });
+  
+  it("should set view relative to position", function() {
+    camera.setPosition(10, 10, 10);
+    camera.orient([-1, 0, 0], [0, 1, 0]);
+    
+    expect(camera.getPosition()).toEqualVector([10,10,10]);
+    expect(camera.getViewVector()).toEqualVector([-1,0,0]);
+    expect(camera.getUpVector()).toEqualVector([0,1,0]);
+  });
+  
+  describe("orienting the camera after translation", function() {
+    beforeEach(function() {
+      camera.setPosition(100, 100, 100);
+      camera.orient([0, 0, -1], [0, 1, 0]);
+    });
+    
+    it("should not change its position", function() { expect(camera.getPosition()).toEqualVector([100,100,100]); });
+    
+  });
+  
+  describe("orientation", function() {
+    it(" pos(0,0,1), view(0,-1,0)", function() {
+      camera.setPosition(0,0,1);
+      camera.orient(0,-1,0);
+      expect(camera.getViewVector()).toEqualVector([0,-1,0]);
+    });
+  });
+
+  describe("looking", function() {
+    beforeEach(function() { camera.lookAt([0,0,-1], [0,1,0], [0,0,0]); });
+    
+    it("should return position accurately", function() {
+      expect(camera.getPosition()).toEqualVector([0,0,0]);
+    });
+
+    it("should return view accurately", function() {
+      expect(camera.getViewVector()).toEqualVector([0,0,-1]);
+    });
+
+    it("should return up accurately", function() {
+      expect(camera.getUpVector()).toEqualVector([0,1,0]);
+    });
+
+    it("should return right accurately", function() {
+      expect(camera.getRightVector()).toEqualVector([1,0,0]);
+    });
+  });
+  
+  it("should set the position using numbers", function() {
+    camera.setPosition(1, 1, 1);
+    expect(camera.getPosition()).toEqualVector([1,1,1]);
+  });
+  
+  it("should set the position using a vector", function() {
+    camera.setPosition([1,1,1]);
+    expect(camera.getPosition()).toEqualVector([1,1,1]);
+  });
+  
+  describe("orienting the camera with numeric arguments and no position", function() {
+    beforeEach(function() {
+      camera.orient(0, 0, 1,  0, -1, 0);
+    });
+    
+    it("position should be 0,0,0", function() { expect(camera.getPosition()).toEqualVector([0,0,0]);      });
+    it("view should be 0,0,1",     function() { expect(camera.getViewVector()).toEqualVector([0, 0, 1]);  });
+    it("up should be 0,-1,0",      function() { expect(camera.getUpVector()).toEqualVector([0, -1, 0]);   });
+    it("right should be 1,0,0",    function() { expect(camera.getRightVector()).toEqualVector([1, 0, 0]); });
+  });
+  
+  it("should strafe right", function() {
+    camera.strafe(10);
+    expect(camera.getPosition()).toEqualVector([10, 0, 0]);
+  });
+
+  it("should strafe left", function() {
+    camera.strafe(-10);
+    expect(camera.getPosition()).toEqualVector([-10, 0, 0]);
+  });
+  
+  it("should move forward", function() {
+    camera.move(10);
+    expect(camera.getPosition()).toEqualVector([0,0,-10]);
+  });
+  
+  it("should move backward", function() {
+    camera.move(-10);
+    expect(camera.getPosition()).toEqualVector([0,0,10]);
+  });
+  
+  it("should move 'forward' along a given vector", function() {
+    camera.move(10, [0,1,0]);
+    expect(camera.getPosition()).toEqualVector([0,10,0]);
+  });
+  
+  it("should move 'backward' along a given vector", function() {
+    camera.move(-10, [0,1,0]);
+    expect(camera.getPosition()).toEqualVector([0,-10,0]);
+  });
+
+  describe("events", function() {
+    beforeEach(function() {
+      spyOn(camera, 'fireEvent').andCallThrough();
+    });
+    
+    it("should fire matrixUpdated when setPosition called", function() {
+      camera.setPosition(1, 1, 1);
+      expect(camera.fireEvent).toHaveBeenCalledWith('matrixUpdated');
+    });
+    
+    it("should fire matrixUpdated when orient called", function() {
+      camera.orient(0, 0, -1, 0, 1, 0);
+      expect(camera.fireEvent).toHaveBeenCalledWith('matrixUpdated');
+    });
+  });
+});