jax 1.1.1 → 2.0.0

data/spec/javascripts/jax/builtin/meshes/quad_spec.js

@@ -0,0 +1,8 @@
+describe("Jax.Mesh.Quad", function() {
+  var quad;
+  
+  describe("with no options", function() {
+    beforeEach(function() { quad = new Jax.Mesh.Quad(); });
+    it("should initialize", function() { });
+  });
+});

data/spec/javascripts/jax/builtin/meshes/sphere_spec.js

@@ -0,0 +1,8 @@
+describe("Jax.Mesh.Sphere", function() {
+  var sphere;
+  
+  describe("with no options", function() {
+    beforeEach(function() { sphere = new Jax.Mesh.Sphere(); });
+    it("should initialize", function() { });
+  });
+});

data/spec/javascripts/jax/builtin/meshes/teapot_spec.js

@@ -0,0 +1,8 @@
+describe("Jax.Mesh.Teapot", function() {
+  var teapot;
+  
+  describe("with no options", function() {
+    beforeEach(function() { teapot = new Jax.Mesh.Teapot(); });
+    it("should initialize", function() { });
+  });
+});

data/spec/javascripts/jax/builtin/meshes/torus_spec.js

@@ -0,0 +1,8 @@
+describe("Jax.Mesh.Torus", function() {
+  var torus;
+  
+  describe("with no options", function() {
+    beforeEach(function() { torus = new Jax.Mesh.Torus(); });
+    it("should initialize", function() { });
+  });
+});

data/spec/javascripts/jax/compatibility_spec.js

@@ -0,0 +1,46 @@
+describe("LCD Compatibility tests", function() {
+  /* these tests verify that different aspects of Jax can perform on lowest-common-denominator machines */
+  
+  /*
+    From the GL ES SL spec, section 7.8:
+    
+    //
+    // Implementation dependent constants. The example values below
+    // are the minimum values allowed for these maximums.
+    //
+        
+    So, the "basic" shader must define no more than at most the above
+    uniforms, varyings, etc. -- or else the basic shader itself may
+    fail on some implementations!
+    
+    Jax will dynamically step back from other shader chain elements,
+    but if the 'basic' shader exceeds these limits then Jax is out of
+    the running entirely on some processors -- not good!
+    
+    TODO add some tests to validate 'basic' shader against the following:
+      const mediump int gl_MaxVertexTextureImageUnits = 0;
+      const mediump int gl_MaxCombinedTextureImageUnits = 8;
+      const mediump int gl_MaxTextureImageUnits = 8;
+      const mediump int gl_MaxDrawBuffers = 1;
+  */
+  describe("Basic shader", function() {
+    var matr, shader;
+    beforeEach(function() { matr = new Jax.Material(); shader = matr.prepareShader(); });
+    
+    it("should not have more than 16 uniforms", function() {
+      // const mediump int gl_MaxVertexUniformVectors = 128;
+      // const mediump int gl_MaxFragmentUniformVectors = 16;
+      expect(shader.countUniforms(matr)).toBeLessThan(17);
+    });
+    
+    it("should not have more than 8 varyings", function() {
+      // const mediump int gl_MaxVaryingVectors = 8;
+      expect(shader.countVaryings(matr)).toBeLessThan(9);
+    });
+    
+    it("should not have more than 8 attribs", function() {
+      // const mediump int gl_MaxVertexAttribs = 8;
+      expect(shader.countAttributes(matr)).toBeLessThan(9);
+    });
+  });
+});

data/spec/javascripts/jax/context_events_spec.js

@@ -0,0 +1,212 @@
+describe("Jax.Context.Events", function() {
+  // I don't want to tie to a specific # of listeners because of nuances like tracking
+  // (move,down,up) for 'dragged' events; it stands to reason that each event should
+  // require greater than 0 listeners, but not one of +every+ listener (totalling 6).
+  
+  describe("with no controller", function() {
+    it("sanity check", function() { expect(SPEC_CONTEXT.current_controller).toBeUndefined(); });
+    
+    it("should have registered no event listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners()).toBeEmpty();
+    });
+    
+    describe("redirecting to a controller", function() {
+      beforeEach(function() {
+        /* TODO make this easier! No reason we can't autogen routes and possibly views. */
+        var c = Jax.Controller.create('test', {
+          index: function() { },
+          mouse_pressed: function(evt) { }
+        });
+        Jax.views.push('test/index', function() { });
+        Jax.routes.map('test/index', c, 'index');
+        SPEC_CONTEXT.redirectTo('test');
+      });
+      
+      it("should have registered listeners", function() {
+        expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+        expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+      });
+    });
+  });
+  
+  function withListener(which, fn) {
+    describe("with "+which, function() {
+      beforeEach(function() {
+        var c = Jax.Controller.create('test', { index: function() { } });
+        c.prototype[which] = function(evt) { }
+        Jax.views.push('test/index', function() { });
+        Jax.routes.map('test/index', c, 'index');
+        SPEC_CONTEXT.redirectTo('test');
+      });
+
+      describe("listener", fn);
+    });
+  }
+  
+  describe("controller mouse events", function() {
+    var controller, evt;
+    beforeEach(function() {
+      controller = Jax.Controller.create('test', { index: function() { } });
+      Jax.views.push('test/index', function() { });
+      // Jax.routes.map('test/index', controller, 'index');
+    });
+    
+    function sendMouseEvent(type, x, y) {
+      evt = document.createEvent('MouseEvents');
+      evt.initMouseEvent(type, true, true, Jax.getGlobal(), 1, x, y, x, y, false, false, false, false, 0, null);
+      SPEC_CONTEXT.canvas.dispatchEvent(evt);
+    }
+    
+    describe("with a scaled canvas", function() {
+      beforeEach(function() {
+        SPEC_CONTEXT.canvas.offsetWidth  = SPEC_CONTEXT.canvas.width*2;
+        SPEC_CONTEXT.canvas.offsetHeight = SPEC_CONTEXT.canvas.height*2;
+      });
+
+      it("should translate event to real dimensions", function() {
+        if (SPEC_CONTEXT.canvas.offsetWidth) {
+          var evt;
+          controller.prototype.mouse_moved = function(e) { evt = e; };
+          SPEC_CONTEXT.redirectTo('test');
+          sendMouseEvent("mousemove", SPEC_CONTEXT.canvas.width, SPEC_CONTEXT.canvas.height);
+          expect(evt.x).toEqual(SPEC_CONTEXT.canvas.width/2);
+          expect(evt.y).toEqual(SPEC_CONTEXT.canvas.height/2);
+        }
+      });
+    });
+
+    
+    describe("mouse exit canvas (mouseout)", function() {
+      var dragged;
+      beforeEach(function() {
+        dragged = false;
+        controller.prototype.mouse_dragged = function() { dragged = true; };
+        SPEC_CONTEXT.redirectTo('test');
+      });
+      
+      it("should not continue dragging", function() {
+        // simulate mouse down, then drag, then exit
+        sendMouseEvent('mousedown');
+        sendMouseEvent('mousemove');
+        sendMouseEvent('mouseout');
+        // reset +dragged+ so we can track the next result
+        dragged = false;
+        // bring mouse back in
+        sendMouseEvent('mouseover');
+        sendMouseEvent('mousemove');
+        
+        expect(dragged).toBeFalsy();
+      });
+    });
+
+    describe("mouse move", function() {
+      var dragged;
+      beforeEach(function() {
+        dragged = false;
+        controller.prototype.mouse_dragged = function() { dragged = true; };
+        SPEC_CONTEXT.redirectTo('test');
+      });
+      
+      it("should not be dragged after clicking", function() {
+        // simulate a click
+        sendMouseEvent('mousedown');
+        sendMouseEvent('mouseup');
+        sendMouseEvent('click');
+        // move the mouse
+        sendMouseEvent('mousemove');
+        
+        expect(dragged).toBeFalsy();
+      });
+    });
+
+    describe("mouse click", function() {
+      var clicked;
+
+      beforeEach(function() {
+        clicked = false;
+        controller.prototype.mouse_clicked = function() { clicked = true; };
+        SPEC_CONTEXT.redirectTo('test');
+        sendMouseEvent('mousedown');
+        expect(Jax.click_speed).toBeGreaterThan(0); // sanity check
+      });
+
+      it("should not be interfered with by mouse movement", function() {
+        Jax.uptime += Jax.click_speed / 2 + 1;
+        sendMouseEvent('mousemove');
+        Jax.uptime += Jax.click_speed / 2 + 1;
+        sendMouseEvent('click');
+        expect(clicked).toBeFalsy();
+      });
+
+      it("should not fire if too much time elapses between down and up", function() {
+        Jax.uptime += Jax.click_speed+1;
+        sendMouseEvent('click');
+        expect(clicked).toBeFalsy();
+      });
+
+      it("should carry through if time elapsed < click_speed", function() {
+        Jax.uptime += Jax.click_speed-1;
+        sendMouseEvent('click');
+        expect(clicked).toBeTruthy();
+      });
+
+      it("should carry through if click_speed is nil", function() {
+        var speed = Jax.click_speed;
+        Jax.click_speed = null;
+        sendMouseEvent('click');
+        expect(clicked).toBeTruthy();
+        Jax.click_speed = speed;
+      });
+    });
+  });
+
+  // test listeners individually.
+  withListener('mouse_entered', function() {
+    it("should have some listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+    });
+  });
+
+  withListener('mouse_exited', function() {
+    it("should have some listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+    });
+  });
+
+  withListener('mouse_released', function() {
+    it("should have some listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+    });
+  });
+
+  withListener('mouse_pressed', function() {
+    it("should have some listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+    });
+  });
+
+  withListener('mouse_clicked', function() {
+    it("should have some listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+    });
+  });
+
+  withListener('mouse_moved', function() {
+    it("should have some listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+    });
+  });
+
+  withListener('mouse_dragged', function() {
+    it("should have some listeners", function() {
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeGreaterThan(0);
+      expect(SPEC_CONTEXT.canvas.getEventListeners().length).toBeLessThan(6);
+    });
+  });
+});

data/spec/javascripts/jax/context_spec.js

@@ -0,0 +1,305 @@
+describe("Jax.Context", function() {
+  var context, canvas;
+  
+  describe("root", function() {
+    beforeEach(function() {
+      Jax.routes.clear();
+      Jax.Controller.create("welcome", {index: function() { }});
+      Jax.views.push('welcome/index', function() { });
+      
+      canvas = document.createElement('canvas');
+      canvas.setAttribute("id", "c");
+      canvas.setAttribute("width", "100");
+      canvas.setAttribute("height", "100");
+      canvas.style.display = "none";
+      document.body.appendChild(canvas);
+    });
+    
+    afterEach(function() {
+      if (context) context.dispose();
+      document.body.removeChild(canvas);
+    });
+
+    it("should redirect to the root when given", function() {
+      context = new Jax.Context(canvas, {root: "welcome/index"});
+      expect(context.current_controller.getControllerName()).toEqual("welcome");
+    });
+  });
+  
+  describe("errors", function() {
+    beforeEach(function() {
+      Jax.routes.clear();
+
+      context = null;
+      canvas = document.createElement('canvas');
+      canvas.setAttribute("id", "c");
+      canvas.setAttribute("width", "100");
+      canvas.setAttribute("height", "100");
+      canvas.style.display = "none";
+      document.body.appendChild(canvas);
+    });
+    
+    afterEach(function() {
+      if (context) context.dispose();
+      document.body.removeChild(canvas);
+    });
+    
+    describe("encountering a non-compatability error during init", function() {
+      beforeEach(function() {
+        Jax.routes.clear();
+
+        Jax.views.push('one/index', function() { });
+        var one = Jax.Controller.create("one", {index:function() {throw new Error("my bad")}});
+      });
+      
+      afterEach(function() { Jax.routes.clear(); });
+      
+      it("should not redirect", function() {
+        var href = document.location.pathname;
+        try { context = new Jax.Context(canvas, {alertErrors: false, root: "one"}); } catch(e) { }
+        expect(document.location.pathname).toEqual(href);
+      });
+    });
+    
+    describe("with an error function in ApplicationController", function() {
+      var _app, _error;
+
+      beforeEach(function() {
+        _error = undefined;
+        _app = Jax.getGlobal().ApplicationController;
+        Jax.getGlobal().ApplicationController = Jax.Controller.create("application", Jax.Controller, {
+          error: function(error) {
+            _error = error;
+            return true;
+          }
+        });
+      });
+      
+      afterEach(function() {
+        if (!_app) delete Jax.getGlobal().ApplicationController;
+        else Jax.getGlobal().ApplicationController = _app;
+      });
+      
+      it("should let ApplicationController process the error", function() {
+        canvas.getContext = function() { return null; };
+        context = new Jax.Context(canvas);
+      });
+    });
+  });
+  
+  describe("with no routes", function() {
+    beforeEach(function() { 
+      Jax.routes.clear();
+      canvas = document.createElement('canvas');
+      canvas.setAttribute("id", "c");
+      canvas.setAttribute("width", "100");
+      canvas.setAttribute("height", "100");
+      canvas.style.display = "none";
+      document.body.appendChild(canvas);
+      context = new Jax.Context(canvas);
+    });
+    afterEach(function() { context.dispose(); document.body.removeChild(canvas); });
+  
+    it("should keep a handle to canvas", function() {
+      expect(context.canvas.id).toEqual("c");
+    });
+  
+    it("should not be rendering, because there's no root controller", function() {
+      expect(context.isRendering()).toBeFalsy();
+    });
+    
+    describe("after disposal", function() {
+      beforeEach(function() { context.dispose(); });
+      
+      it("should unregister all event handlers", function() {
+        expect(context.canvas.getEventListeners('click')).toBeEmpty();
+        expect(context.canvas.getEventListeners('mousedown')).toBeEmpty();
+        expect(context.canvas.getEventListeners('mousemove')).toBeEmpty();
+        expect(context.canvas.getEventListeners('mouseout')).toBeEmpty();
+        expect(context.canvas.getEventListeners('mouseover')).toBeEmpty();
+        expect(context.canvas.getEventListeners('mouseup')).toBeEmpty();
+        expect(context.canvas.getEventListeners('keydown')).toBeEmpty();
+        expect(context.canvas.getEventListeners('keypress')).toBeEmpty();
+        expect(context.canvas.getEventListeners('keyup')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onclick')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onmousedown')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onmousemove')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onmouseout')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onmouseover')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onmouseup')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onkeydown')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onkeypress')).toBeEmpty();
+        expect(context.canvas.getEventListeners('onkeyup')).toBeEmpty();
+      });
+    });
+  });
+  
+  describe("when redirecting", function() {
+    beforeEach(function() {
+      jasmine.Clock.useMock();
+      
+      Jax.routes.clear();
+      
+      Jax.views.push('one/index', function() { });
+      Jax.views.push('two/index', function() { });
+
+      var one = Jax.Controller.create("one", {index:function() {}});
+      var two = Jax.Controller.create("two", {
+        index:function() { this.world.addObject(new Jax.Model()); },
+        second: function() { },
+        update: function(tc) {  }
+      });
+      
+      Jax.routes.map("/", one);
+      Jax.routes.map("two", two);
+      Jax.routes.map("two/second", two, "second");
+      
+      context = new Jax.Context(SPEC_CONTEXT.canvas);
+      context.alertErrors = false;
+    });
+    
+    afterEach(function() { context.dispose(); });
+    
+    describe("to a different action in the same controller", function() {
+      describe("without a view", function() {
+        var view;
+        beforeEach(function() {
+          context.redirectTo("two");
+          view = context.current_view;
+          expect(view).not.toBeUndefined(); // sanity check
+          context.redirectTo("two/second");
+        });
+
+        it("should not unload the world", function() {
+          expect(context.world.countObjects()).toEqual(1);
+        });
+
+        it("should not change the view", function() {
+          expect(view).toBe(context.current_view);
+        });
+      });
+      
+      describe("with a view", function() {
+        var view;
+        beforeEach(function() {
+          Jax.views.push('two/second', function() { });
+          context.redirectTo("two");
+          view = context.current_view;
+          expect(view).not.toBeUndefined(); // sanity check
+          context.redirectTo("two/second");
+        });
+
+        it("should not unload the world", function() {
+          expect(context.world.countObjects()).toEqual(1);
+        });
+
+        it("should not change the view", function() {
+          expect(view).not.toBe(context.current_view);
+        });
+      });
+    });
+    
+    it("should dispose the world", function() {
+      spyOn(context.world, 'dispose').andCallThrough();
+      context.redirectTo("two");
+      expect(context.world.dispose).toHaveBeenCalled();
+    });
+    
+    it("should reset the player camera", function() {
+      context.player.camera.setPosition([10,10,10]);
+      context.player.camera.rotate(1, [1,1,1]);
+      context.redirectTo("two");
+      expect(context.player.camera.getPosition()).toEqualVector([0,0,0]);
+      expect(context.player.camera.getViewVector()).toEqualVector([0,0,-1]);
+      expect(context.player.camera.getUpVector()).toEqualVector([0,1,0]);
+      expect(context.player.camera.getRightVector()).toEqualVector([1,0,0]);
+    });
+    
+    it("to a bad route should stop execution of current controller", function() {
+      context.redirectTo("two");
+      var two_instance = context.current_controller;
+      
+      jasmine.Clock.tick(Jax.update_speed+1);
+      try {
+        context.redirectTo("invalid");
+        throw new Error("No error raised!");
+      } catch(e) {
+        expect(e.toString()).toMatch("Route not recognized: 'invalid'");
+      }
+      // no reason to make this assertion here... and i'm not convinced
+      // it matters, so long as rendering and updating stop; this is an
+      // error condition after all
+      // expect(context.world.objects.length).toEqual(0);
+      
+      spyOn(two_instance, "update"); // notice we can't do this earlier because it *does* get called above
+      jasmine.Clock.tick(Jax.update_speed+1);
+      expect(two_instance.update).not.toHaveBeenCalled();
+    });
+  });
+  
+  describe("with routes", function() {
+    var controller;
+    var action_called = 0, view_called = 0;
+    
+    beforeEach(function() {
+      Jax.routes.clear();
+      Jax.Controller.create("welcome", {index: function() { action_called++; }});
+      Jax.views.push("welcome/index", function() {
+        this.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        this.world.render();
+        view_called++;
+      });
+      context = new Jax.Context(SPEC_CONTEXT.canvas, {root:"welcome"});
+    });
+    afterEach(function() { context.dispose(); });
+  
+    it("should be rendering, because there's a controller", function() {
+      expect(context.isRendering()).toBeTruthy();
+    });
+    
+    it("should fire onError events during render", function() {
+      var fired = false;
+      context.addEventListener('error', function(error) {
+        // silence error. this prevents console.log() and alert() from firing.
+        error.silence = true;
+        fired = true;
+        expect(error.phase).toEqual('render');
+      });
+      
+      var obj = new Jax.Model();
+      obj.render = function() { throw new Error("err"); };
+      context.world.addObject(obj);
+      
+      waitsFor(function() { return fired; });
+    });
+
+    it("should fire onError events during object update", function() {
+      var fired = false;
+      context.addEventListener('error', function(error) {
+        // silence error. this prevents console.log() and alert() from firing.
+        error.silence = true;
+        fired = true;
+        expect(error.phase).toEqual('update');
+      });
+      
+      var obj = new Jax.Model();
+      obj.update = function() { throw new Error("err"); };
+      context.world.addObject(obj);
+      
+      waitsFor(function() { return fired; });
+    });
+
+    it("should fire onError events during controller update", function() {
+      var fired = false;
+      context.addEventListener('error', function(error) {
+        // silence error. this prevents console.log() and alert() from firing.
+        error.silence = true;
+        fired = true;
+        expect(error.phase).toEqual('update');
+      });
+      
+      context.current_controller.update = function() { throw new Error("err"); };
+      waitsFor(function() { return fired; });
+    });
+  });
+});