jax 0.0.0.9 → 0.0.0.10

data/spec/javascripts/jax/helper_spec.js

@@ -1,33 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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("added to world without a mesh", function() {
-    var context;
-    beforeEach(function() { model = new (Jax.Model.create({after_initialize:function(){}}))({position:[0,0,0]}); context = new Jax.Context('canvas-element'); context.world.addObject(model); });
-    afterEach(function() { context.dispose(); });
-    
-    it("should not cause errors when rendering", function() {
-      expect(function() { context.world.render(); }).not.toThrow();
-    });
-  });
-    
-  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

@@ -1,87 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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');
-    });
-  });
-});