jax 1.1.1 → 2.0.0

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

@@ -0,0 +1,85 @@
+describe("Jax.Material exceeding GPU limitations", function() {
+  var matr, 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();
+    // 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() {
+    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(SPEC_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(SPEC_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(SPEC_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(SPEC_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(SPEC_CONTEXT, mesh, {});
+      expect(matr.layers[0]).toBeKindOf(layer_class);
+    });
+    
+    it("should back off shader steps incrementally", function() {
+      matr.render(SPEC_CONTEXT, mesh, {});
+      expect(matr.layers.length).toEqual(0);
+    });
+  });
+});

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

@@ -0,0 +1,65 @@
+describe("Opt: Basic shader", function() {
+  var model;
+  var _tex = "/textures/rss.png", _norm = "/textures/normal_map.jpg";
+  
+  beforeEach(function() {
+    model = new Jax.Model({mesh: new Jax.Mesh.Quad()});
+    SPEC_CONTEXT.world.addObject(model);
+  });
+  
+  describe("without textures", function() {
+    it("should not build tangent space", function() {
+      spyOn(model.mesh, 'getTangentBuffer').andCallThrough();
+      SPEC_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();
+      SPEC_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();
+      SPEC_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();
+      SPEC_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();
+      SPEC_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/webgl/camera_spec.js

@@ -0,0 +1,237 @@
+describe("Camera", function() {
+  var camera, control;
+  
+  beforeEach(function() { camera = new Jax.Camera(); });
+  
+  it("movement with rotations", function() {
+    camera.move(10);
+    camera.yaw(Math.PI/2);
+    camera.move(10);
+    expect(camera.getPosition()).toEqualVector(-10, 0, -10);
+  });
+  
+  it("rotation then reset", function() {
+    camera.setPosition([1,1,1]);
+    camera.pitch(1);
+    camera.yaw(1);
+    camera.roll(1);
+    camera.reset();
+    expect(camera.getViewVector()).toEqualVector([0,0,-1]);
+    expect(camera.getPosition()).toEqualVector([0,0,0]);
+    expect(camera.getUpVector()).toEqualVector([0,1,0]);
+    expect(camera.getRightVector()).toEqualVector([1,0,0]);
+  });
+  
+  it("strafing with rotations", function() {
+    camera.move(10);
+    camera.yaw(Math.PI/2);
+    camera.strafe(10);
+    expect(camera.getPosition()).toEqualVector(0, 0, -20);
+  });
+  
+  it("multiple rotations", function() {
+    camera.pitch(Math.PI/6); // rotate up a bit
+    camera.yaw(Math.PI/6); // rotate to side a bit
+    // check for camera drift
+    expect(camera.getUpVector()).toEqualVector([0.25,0.8660253286361694,0.4330127239227295]);
+  });
+  
+  it("should project move and strafe", function() {
+    var pos = camera.projectMovement(1, 1);
+    vec3.subtract(camera.getPosition(), pos);
+    expect(pos).toEqualVector([1,0,-1])
+  });
+  
+  describe("with fixed yaw axis", function() {
+    // this is the default, no beforeEach necessary
+    
+    it("should not lose up vector", function() {
+      camera.setPosition([-1.8,0.35,1.8]);
+      camera.lookAt([0,0,0]);
+      var up = camera.getUpVector();
+      // FIXME is this safe?
+      expect(Math.abs(up[0])).toBeLessThan(0.1);
+      expect(Math.abs(up[1])).toBeGreaterThan(0.9);
+      expect(Math.abs(up[2])).toBeLessThan(0.1);
+      // expect(camera.getUpVector()).toEqualVector([0,1,0]);
+    });
+  });
+  
+  describe("without fixed yaw axis", function() {
+    beforeEach(function() { camera.setFixedYawAxis(false); });
+
+    it("multiple rotations", function() {
+      camera.pitch(Math.PI/6); // rotate up a bit
+      camera.yaw(Math.PI/6); // rotate to side a bit
+      // check for camera drift
+      expect(camera.getUpVector()).toEqualVector([0,0.8660253286361694,0.4999999701976776]);
+    });
+  });
+  
+  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]);
+    var matr = camera.getTransformationMatrix();
+    expect(matr[12]).toEqual(20);
+    expect(matr[13]).toEqual(0);
+    expect(matr[14]).toEqual(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]);
+    expect(camera.getPosition()).toEqualVector([20,0,20]);
+  });
+  
+  it("should set view relative to position", function() {
+    camera.setPosition(10, 10, 10);
+    camera.setDirection([-1, 0, 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.setDirection([0, 0, -1]);
+    });
+    
+    it("should not change its position", function() { expect(camera.getPosition()).toEqualVector([100,100,100]); });
+    
+  });
+  
+  it("should rotate", function() {
+    camera.rotate(Math.PI, 1,0,0); // 180 deg, we're now pointing backwards
+    expect(camera.getViewVector()).toEqualVector([0,0,1]);
+  });
+  
+  it("should look at a position", function() {
+    camera.lookAt([10, 10, 10], [12, 10, 10]);
+    expect(camera.getPosition()).toEqualVector([12,10,10]);
+    expect(camera.getViewVector()).toEqualVector([-1,0,0]);
+  });
+  
+  describe("orientation", function() {
+    it(" pos(0,0,1), view(0,-1,0)", function() {
+      camera.setPosition(0,0,1);
+      camera.setDirection([0,-1,0]);
+      expect(camera.getViewVector()).toEqualVector([0,-1,0]);
+    });
+  });
+
+  describe("looking", function() {
+    beforeEach(function() { camera.lookAt([0,0,-1], [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.setDirection(0, 0, 1);
+    });
+    
+    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("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 'updated' when setPosition called", function() {
+      camera.setPosition(1, 1, 1);
+      expect(camera.fireEvent).toHaveBeenCalledWith('updated');
+    });
+    
+    it("should fire 'updated' when orient called", function() {
+      camera.setDirection(0, 0, -1);
+      expect(camera.fireEvent).toHaveBeenCalledWith('updated');
+    });
+  });
+});

data/spec/javascripts/jax/webgl/core/events_spec.js

@@ -0,0 +1,47 @@
+describe("Jax.Events.Methods", function() {
+  var emitter, evt, listenerID;
+  
+  beforeEach(function() {
+    emitter = Jax.Class.create({ });
+    emitter.addMethods(Jax.Events.Methods);
+    emitter = new emitter();
+    listenerID = emitter.addEventListener('evt', function(obj) { evt = obj; });
+  });
+  
+  // don't taint other tests
+  afterEach(function() { evt = undefined; });
+  
+  it("should work with no event at all", function() {
+    emitter.fireEvent('evt');
+    expect(evt).toBeUndefined();
+  });
+  
+  it("should set a default +type+ property on events", function() {
+    emitter.fireEvent('evt', { });
+    expect(evt.type).toEqual('evt');
+  });
+  
+  it("should not override a +type+ property on events", function() {
+    emitter.fireEvent('evt', { type: 'one' });
+    expect(evt.type).toEqual('one');
+  });
+  
+  it("should be un-listenenable", function() {
+    emitter.removeEventListener('evt', listenerID);
+    emitter.fireEvent('evt', {});
+    expect(evt).toBeUndefined(); // because the original listener never was fired
+  });
+  
+  it("should be un-listenable out of order", function() {
+    // add a second listener. Its index is 1. If we remove index 0, we should still
+    // be able to remove index 1. At that point no listeners should exist.
+    var second = false, secondID;
+    secondID = emitter.addEventListener('evt', function() { second = true; });
+    emitter.removeEventListener('evt', listenerID);
+    emitter.removeEventListener('evt', secondID);
+    emitter.fireEvent('evt', {});
+    // neither should have fired
+    expect(second).toBeFalsy();
+    expect(evt).toBeUndefined();
+  });
+});

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

@@ -0,0 +1,44 @@
+describe("Framebuffer", function() {
+  var buf;
+  
+  describe("with no attachments", function() {
+    beforeEach(function() { buf = new Jax.Framebuffer(); });
+    
+    it("should bind", function() {
+      // because there's a default GL_RGBA color profile generated.
+      // This was the only way to circumvent an unknown error in FF and Chrome when
+      // using a depth buffer only.
+      expect(function() {buf.bind(SPEC_CONTEXT)}).not.toThrow();
+    });
+  });
+  
+  describe("with only a depth attachment", function() {
+    beforeEach(function() {
+      buf = new Jax.Framebuffer({ depth: true });
+    });
+    
+    it("should bind", function() {
+      expect(function() {buf.bind(SPEC_CONTEXT)}).not.toThrow();
+    });
+  });
+  
+  describe("with only a stencil attachment", function() {
+    beforeEach(function() {
+      buf = new Jax.Framebuffer({ stencil: true });
+    });
+    
+    xit("should bind", function() { // raising GL_FRAMEBUFFER_UNSUPPORTED
+      expect(function() {buf.bind(SPEC_CONTEXT)}).not.toThrow();
+    });
+  });
+
+  describe("with a depth and a stencil attachment", function() {
+    beforeEach(function() {
+      buf = new Jax.Framebuffer({ depth: true, stencil: true });
+    });
+    
+    it("should bind", function() {
+      expect(function() {buf.bind(SPEC_CONTEXT)}).not.toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,108 @@
+describe("LightManager", function() {
+  var mgr;
+  
+  describe("when more than 1 light source is active", function() {
+    beforeEach(function() {
+      mgr = new Jax.Scene.LightManager();
+      mgr.add(new Jax.Scene.LightSource());
+      mgr.add(new Jax.Scene.LightSource());
+    });
+    
+    it("should not leave the blend mode set to GL_ONE, GL_ONE", function() {
+      var src, dst;
+      SPEC_CONTEXT.glBlendFunc = function(a, b) {
+        src = a;
+        dst = b;
+      };
+      mgr.illuminate(SPEC_CONTEXT);
+      // we care about how state looks *after* illumination; therefore, we
+      // check the final values of src and dst
+      expect(src).not.toEqual(GL_ONE);
+      expect(dst).not.toEqual(GL_ONE);
+    });
+  });
+  
+  describe("when an error is raised during shadowmap generation", function() {
+    var _real_console, light;
+    
+    beforeEach(function() {
+      _real_console = Jax.getGlobal().console;
+      Jax.getGlobal().console = {messages:[], log:function(msg) { this.messages.push(msg); }};
+      mgr = new Jax.Scene.LightManager();
+      light = new Jax.Scene.LightSource();
+      mgr.add(light);
+      light.updateShadowMap = function() { throw new Error("Whoops"); };
+    });
+    
+    afterEach(function() { Jax.getGlobal().console = _real_console; });
+    
+    it("should disable shadowcasting", function() {
+      mgr.illuminate(SPEC_CONTEXT, {});
+      expect(light.isShadowcaster()).toBeFalsy();
+    });
+    
+    it("should log the error", function() {
+      expect(function() { mgr.illuminate(SPEC_CONTEXT, {}); }).not.toThrow();
+      expect(Jax.getGlobal().console.messages[0]).toEqual(new Error("Whoops").toString());
+      return true;
+    });
+  });
+  
+  describe("by default", function() {
+    beforeEach(function() { mgr = new Jax.Scene.LightManager(); });
+  
+    it("should not be enabled", function() {
+      expect(mgr.isEnabled()).toBeFalsy();
+    });
+    
+    it("should not allow more than Jax.max_lights", function() {
+      var max = Jax.max_lights;
+      Jax.max_lights = 32;
+      for (var i = 0; i < Jax.max_lights; i++)
+        mgr.add(new Jax.Scene.LightSource());
+      expect(function() { mgr.add(new Jax.Scene.LightSource()); }).
+              toThrow(new Error("Maximum number of light sources in a scene has been exceeded! Try removing some first."));
+      Jax.max_lights = max;
+    });
+
+    describe("with one custom light", function() {
+      beforeEach(function() { mgr.add(new Jax.Scene.LightSource({
+        enabled:false,
+        position:[0,0,1],
+        direction:[0,-1,0],
+        attenuation: {
+          constant: 1,
+          linear: 2,
+          quadratic: 3
+        },
+        color: {
+          ambient: [0.3,0.3,0.3,1],
+          diffuse: [0.75,0.5,0.5,1],
+          specular: [1,0,1,1]
+        }
+      })); });
+      
+      it("should have a light at index 0", function() { expect(mgr.getLight(0)).not.toBeUndefined(); });
+      
+      it("should have ambient [0.3,0.3,0.3,1]",  function() { expect(mgr.getAmbientColor(0)).toEqualVector([0.3,0.3,0.3,1]);  });
+      it("should have diffuse [0.75,0.5,0.5,1]", function() { expect(mgr.getDiffuseColor(0)).toEqualVector([0.75,0.5,0.5,1]); });
+      it("should have specular [1,0,1,1]",       function() { expect(mgr.getSpecularColor(0)).toEqualVector([1,0,1,1]);       });
+      it("should have constant att 1",           function() { expect(mgr.getConstantAttenuation(0)).toEqual(1);               });
+      it("should have linear att 1",             function() { expect(mgr.getLinearAttenuation(0)).toEqual(2);                 });
+      it("should have quadratic att 1",          function() { expect(mgr.getQuadraticAttenuation(0)).toEqual(3);              });
+      it("should shine towards [0,-1,0]",        function() { expect(mgr.getDirection(0)).toEqualVector([0,-1,0]);            });
+      it("should be at [0,0,1]",                 function() { expect(mgr.getPosition(0)).toEqualVector([0,0,1]);              });
+      it("should be enabled",                    function() { expect(mgr.isEnabled()).toBeTruthy(); });
+      it("should have disabled light",           function() { expect(mgr.isEnabled(0)).toBeFalsy(); });
+    });
+    
+    describe("with one default light", function() {
+      beforeEach(function() { mgr.add(new Jax.Scene.LightSource()); });
+      
+      it("should be enabled", function() {
+        expect(mgr.isEnabled()).toBeTruthy();
+        expect(mgr.isEnabled(0)).toBeTruthy();
+      });
+    });
+  });
+});