jax 0.0.0.9 → 0.0.0.10

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

@@ -1,46 +0,0 @@
-describe("Framebuffer", function() {
-  var c; // Jax context
-  var buf;
-  beforeEach(function() { c = new Jax.Context('canvas-element'); });
-  
-  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(c)}).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(c)}).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(c)}).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(c)}).not.toThrow();
-    });
-  });
-});

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

@@ -1,61 +0,0 @@
-describe("LightManager", function() {
-  var mgr;
-  
-  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();
-      });
-    });
-  });
-});

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

@@ -1,118 +0,0 @@
-describe("Jax.Material", function() {
-  var material, context, mesh;
-  var _img = "/images/rss.png";
-  
-  beforeEach(function() { mesh = new Jax.Mesh(); context = new Jax.Context('canvas-element'); });
-  afterEach(function() { context.dispose(); });
-  
-  describe("constructed as though from a Resource", function() {
-    beforeEach(function() {
-      material = new Jax.Material({
-        name: "lighting_with_shadows",
-        "ambient":{"red":1.0,"green":2.0,"blue":3.0,"alpha":4.0},
-        "diffuse":{"red":0.2,"green":0.3,"blue":0.4,"alpha":0.5},
-        "specular":{"red":0.6,"green":0.7,"blue":0.8,"alpha":0.9},
-        "shininess":128,
-        "layers":[
-          {"type":"Texture","path":"/images/rock.png","flip_y":false,"scale":1},
-          {"type":"NormalMap","path":"/images/rockNormal.png","flip_y":false,"scale":1},
-          {"type":"ShadowMap"},
-          {"type":"Fog","algorithm":"EXP2","start":10.0,"end":100.0,"density":0.0015,
-            color:{"red":1.0,"green":1.0,"blue":1.0,"alpha":1.0}}
-        ]
-      });
-    });
-    
-    it("should be usable", function() {
-      material.render(context, mesh, {});
-    });
-    
-    it("should have the correct name", function() {
-      expect(material.getName()).toEqual("lighting_with_shadows");
-    });
-    
-    it("should use the default shader", function() {
-      expect(material.default_shader).toEqual(Jax.default_shader);
-    });
-    
-    it("should have the correct ambient", function() { expect(material.ambient).toEqualVector([1,2,3,4]); });
-    it("should have the correct diffuse", function() { expect(material.diffuse).toEqualVector([0.2,0.3,0.4,0.5]); });
-    it("should have the correct specular", function() { expect(material.specular).toEqualVector([0.6,0.7,0.8,0.9]); });
-    it("should have the correct shininess", function() { expect(material.shininess).toEqual(128); });
-    it("should have 4 layers", function() { expect(material.layers.length).toEqual(4); });
-    
-    it("should have a texture map layer", function() {
-      expect(material.layers[0].klass).toEqual(Jax.Material.Texture);
-    });
-
-    it("should have a normal map layer", function() {
-      expect(material.layers[1].klass).toEqual(Jax.Material.NormalMap);
-    });
-
-    it("should have a shadow map layer", function() {
-      expect(material.layers[2].klass).toEqual(Jax.Material.ShadowMap);
-    });
-
-    it("should have a fog layer", function() {
-      expect(material.layers[3].klass).toEqual(Jax.Material.Fog);
-    });
-  });
-
-  describe("with one texture specified by string", function() {
-    beforeEach(function() { material = new Jax.Material({texture: _img}); });
-    it("should have texture layer", function() {
-      expect(material.layers[0].texture.image.src).toMatch(/\/images\/rss\.png$/);
-    });
-  });
-  
-  describe("with multiple textures specified by string", function() {
-    beforeEach(function() { material = new Jax.Material({textures: [_img, _img]}); });
-    
-    it("should have 2 texture layers", function() {
-      expect(material.layers[0].texture.image.src).toMatch(/\/images\/rss\.png$/);
-      expect(material.layers[1].texture.image.src).toMatch(/\/images\/rss\.png$/);
-    });
-  });
-  
-  describe("with a normal map", function() {
-    beforeEach(function() { material = new Jax.Material({texture:{path:_img,type:Jax.NORMAL_MAP}}); });
-    it("should use Jax.Material.NormalMap", function() {
-      expect(material.layers[0]).toBeKindOf(Jax.Material.NormalMap);
-    });
-  });
-  
-  describe("by default", function() {
-    beforeEach(function() { material = new Jax.Material(); });
-
-    describe("switching shaders", function() {
-      it("should not rebuild the shaders", function() {
-        material.render(context, mesh, {shader:"basic"});
-        material.render(context, mesh, {shader:"blinn-phong"});
-        
-        spyOn(material, 'buildShader').andCallThrough();
-        material.render(context, mesh, {shader:"basic"});
-        expect(material.buildShader).not.toHaveBeenCalled();
-      });
-      
-//      it("should build both shaders", function() {
-//        spyOn(material, 'buildShader').andCallThrough();
-//        material.render(context, mesh, {shader:"blinn-phong"});
-//        material.render(context, mesh, {shader:"basic"});
-//        expect(material.buildShader).toHaveBeenCalledWith('blinn-phong', context);
-//        expect(material.buildShader).toHaveBeenCalledWith('basic', context);
-//      });
-    });
-  
-    
-//    it("should use basic shader", function() {
-//      spyOn(material, 'prepareShader').andCallThrough();
-//      material.render(context, mesh);
-//      // I don't like this, but I don't know a better way to test it.
-//      expect(material.prepareShader).toHaveBeenCalledWith('basic', context);
-//    });
-  });
-
-  it("should have a default material", function() {
-    expect(Jax.Material.find('default')).not.toBeUndefined();
-  });
-});

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

@@ -1,86 +0,0 @@
-describe("Mesh:", function() {
-  var mesh, context;
-  
-  beforeEach(function() { context = new Jax.Context(document.getElementById('canvas-element')); });
-  afterEach(function() { context.dispose(); });
-  
-  describe("a torus", function() {
-    beforeEach(function() { mesh = new Jax.Mesh.Torus(); mesh.rebuild(); });
-    
-  });
-  
-  describe("a sphere", function() {
-    beforeEach(function() { mesh = new Jax.Mesh.Sphere(); });
-    
-    describe("that is already built", function() {
-      beforeEach(function() { mesh.rebuild(); });
-
-      it("should set color", function() {
-        mesh.color = [0.5,0,0.4,0.2];
-        mesh.rebuild();
-        var cbuf = mesh.getColorBuffer();
-        for (var i = 0; i < mesh.getVertexBuffer().js.length / 3; i += 4) {
-          expect(cbuf.js[i+0]).toEqual(0.5);
-          expect(cbuf.js[i+1]).toEqual(0);
-          expect(cbuf.js[i+2]).toEqual(0.4);
-          expect(cbuf.js[i+3]).toEqual(0.2);
-        }
-      });
-    });
-    
-    it("should set color", function() {
-      mesh.color = [0.5,0,0.4,0.2];
-      mesh.rebuild();
-      var cbuf = mesh.getColorBuffer();
-      for (var i = 0; i < cbuf.js.length; i += 4) {
-        expect(cbuf.js[i+0]).toEqual(0.5);
-        expect(cbuf.js[i+1]).toEqual(0);
-        expect(cbuf.js[i+2]).toEqual(0.4);
-        expect(cbuf.js[i+3]).toEqual(0.2);
-      }
-    });
-  });
-  
-  describe("a simple quad", function() {
-    beforeEach(function() {
-      mesh = new Jax.Mesh.Quad(2);
-    });
-    
-    describe("with a specific material", function() {
-      beforeEach(function() { mesh.material = 'basic'; });
-      
-      it("should use the specific material", function() {
-        expect(mesh.getNormalizedRenderOptions().material.getName()).toEqual("basic");
-      });
-      
-      it("should override the specific material", function() {
-        expect(mesh.getNormalizedRenderOptions({material:"depthmap"}).material.name).toEqual("depthmap");
-      });
-    });
-    
-    it("should be renderable", function() {
-      /*
-        we can't verify that it's rendering *properly* without a human to verify -- but,
-        we can at least assume that webgl will work properly, and check for other logical errors
-        in the render process itself. For now I'm basically just seeing whether #render fails.
-       */
-      expect(function() { mesh.render(context); }).not.toThrow();
-    });
-    
-    describe("that has been built", function() {
-      beforeEach(function() { mesh.rebuild(); });
-      
-      it("should have appropriate boundaries", function() {
-        expect(mesh.bounds.left).toEqual(-1);
-        expect(mesh.bounds.right).toEqual(1);
-        expect(mesh.bounds.top).toEqual(1);
-        expect(mesh.bounds.bottom).toEqual(-1);
-        expect(mesh.bounds.front).toEqual(0);
-        expect(mesh.bounds.back).toEqual(0);
-        expect(mesh.bounds.width).toEqual(2);
-        expect(mesh.bounds.height).toEqual(2);
-        expect(mesh.bounds.depth).toEqual(0);
-      });
-    });
-  });
-});

data/spec/javascripts/jax/webgl/shader/manifest_spec.js

@@ -1,60 +0,0 @@
-describe("Jax.Shader.Manifest", function() {
-  var manifest;
-  var img = "/images/rss.png";
-  var context;
-  
-  beforeEach(function() {
-    manifest = new Jax.Shader.Manifest();
-    context = new Jax.Context('canvas-element');
-  });
-  
-  afterEach(function() { context.dispose(); });
-  
-  describe("special handling for Jax textures", function() {
-    var tex0, tex1;
-    
-    beforeEach(function() {
-      tex0 = new Jax.Texture(img);
-      tex1 = new Jax.Texture(img);
-      waitsFor(function() {
-        if (tex0.loaded && tex1.loaded) {
-          spyOn(context, 'glActiveTexture');
-          spyOn(tex0, 'bind');
-          spyOn(tex1, 'bind');
-          manifest.texture('Texture0', tex0, context);
-          manifest.texture('Texture1', tex1, context);
-          return true;
-        }
-        return false;
-      });
-    });
-    
-    it("should not allow more than the maximum number of textures to be bound", function() {
-      expect(function() {
-        for (var j = 0; j < GL_MAX_ACTIVE_TEXTURES+1; j++) {
-          manifest.texture('Texture'+j, tex0, context);
-        }
-      }).toThrow("Maximum number of textures ("+GL_MAX_ACTIVE_TEXTURES+") has been reached!");
-    });
-    
-    it("should recycle texture slots", function () {
-      var i = manifest.getValue('Texture0');
-      manifest.texture('Texture0', tex1, context);
-      expect(manifest.getValue('Texture0')).toEqual(i);
-    });
-    
-    it("should activate the textures", function() {
-      expect(context.glActiveTexture).toHaveBeenCalledWith(GL_TEXTURE0);
-      expect(context.glActiveTexture).toHaveBeenCalledWith(GL_TEXTURE1);
-    });
-    
-    it("should bind the textures", function() {
-      expect(tex0.bind).toHaveBeenCalledWith(context, 0);
-      expect(tex1.bind).toHaveBeenCalledWith(context, 1);
-    });
-    
-    it("should set unique texture IDs", function() {
-      expect(manifest.getValue('Texture0')).not.toEqual(manifest.getValue('Texture1'));
-    });
-  });
-});

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

@@ -1,192 +0,0 @@
-describe("Jax.ShaderChain", function() {
-  var chain, material, context;
-  
-  beforeEach(function() {
-    material = new Jax.Material();
-    context = new Jax.Context('canvas-element');
-    chain = new Jax.ShaderChain("shader");
-  });
-  
-  afterEach(function() { context.dispose(); });
-  
-  describe("with a vertex main with 1 unqualified argument", function() {
-    beforeEach(function() {
-      chain.addShader(new Jax.Shader({vertex:"void main(vec4 pos) { }",name:"one"}));
-    });
-    
-    it("should mangle #main but keep the arguments", function() {
-      expect(chain.getVertexSource(material)).toMatch(/void one0_main_v\(vec4 pos\) \{/);
-    });
-    
-    it("should send the 3 arguments from #main", function() {
-      expect(chain.getVertexSource(material)).toMatch(/one0_main_v\(gl_Position\);/);
-    });
-  });
-
-  describe("with a fragment main with 3 unqualified arguments", function() {
-    beforeEach(function() {
-      chain.addShader(new Jax.Shader({fragment:"/* comment with void main(void) in it*/\nvoid main(vec4 amb, vec4 dif, vec4 spec) { }",name:"one"}));
-    });
-    
-    it("should mangle #main but keep the arguments", function() {
-      expect(chain.getFragmentSource(material)).toMatch(/void one0_main_f\(vec4 amb, vec4 dif, vec4 spec\) \{/);
-    });
-    
-    it("should send the 3 arguments from #main", function() {
-      expect(chain.getFragmentSource(material)).toMatch(/one0_main_f\(ambient, diffuse, specular\);/);
-    });
-  });
-  
-  describe("with a fragment main with 3 inout arguments", function() {
-    beforeEach(function() {
-      chain.addShader(new Jax.Shader({fragment:"void main(inout vec4 amb, inout vec4 dif, inout vec4 spec) { }",name:"one"}));
-    });
-    
-    it("should mangle #main but keep the arguments", function() {
-      expect(chain.getFragmentSource(material)).toMatch(/void one0_main_f\(inout vec4 amb, inout vec4 dif, inout vec4 spec\) \{/);
-    });
-    
-    it("should send the 3 arguments from #main", function() {
-      expect(chain.getFragmentSource(material)).toMatch(/one0_main_f\(ambient, diffuse, specular\);/);
-    });
-  });
-  
-  describe("with a local texture", function() {
-    beforeEach(function() {
-      chain.addShader(new Jax.Shader({vertex:"uniform sampler2D Texture; void main(void) { }",name:"one"}));
-    });
-    
-    it("should rename the uniform", function() {
-      expect(chain.getVertexSource(material)).toMatch(/uniform sampler2D one0_Texture;/);
-    });
-  });
-  
-  describe("with a local float uniform", function() {
-    var prefix;
-    beforeEach(function() {
-      prefix = chain.addShader(new Jax.Shader({
-                                      vertex:"uniform float TextureScaleX; void main(void) { float f = TextureScaleX; gl_Position = vec4(0,0,0,1); }",
-                                      fragment:"void main(void) { }",name:"one"
-      }));
-    });
-    
-    it("should delegate to the expanded uniform name", function() {
-      chain.link(context, material);
-      chain.manifest.variable_prefix = prefix;
-      chain.manifest.set('TextureScaleX', 1);
-      var uniforms = chain.getUniformDelegator(context);
-      spyOn(uniforms, 'set');
-      chain.manifest.apply(uniforms, chain.getAttributeDelegator(context));
-      
-      expect(uniforms.set).toHaveBeenCalledWith(prefix+'TextureScaleX', 1);
-    });
-  });
-  
-  describe("with multiple identical uniforms", function() {
-    beforeEach(function() {
-      chain.addShader(new Jax.Shader({vertex:"shared uniform int x; void main(void) { }",name:"one"}));
-      chain.addShader(new Jax.Shader({vertex:"shared uniform int x; void main(void) { }",name:"two"}));
-    });
-    
-    it("should not redefine the uniform", function() {
-      var source = chain.getVertexSource();
-      expect(source.split(/uniform int x;/).length).toEqual(2);
-    });
-  });
-  
-  describe("with a shader that exports", function() {
-    describe("and a shader that imports", function() {
-      beforeEach(function() {
-        chain.addShader(new Jax.Shader({vertex:"uniform int x; void main(void) { vec3 p; _shader_position = p;  gl_Position = vec4(0,0,0,1); }",
-                                        fragment:"void main(void) { vec4 a; _shader_ambient = a; }",
-                                        exports:{"ambient":"vec4", "position":"vec3"},
-                                        name:"one"}));
-        chain.addShader(new Jax.Shader({vertex:"void main(void) { vec3 p; import(position, p = position); }",
-                                        fragment:"uniform float y; void main(void) { vec4 a; import(ambient, a = ambient); }",
-                                        name:"two"}));
-      });
-      
-      it("should produce a master shader", function() {
-        chain.link(context, material);
-        expect(chain.getMasterShader().getFragmentSource()).not.toBeNull();
-        expect(chain.getMasterShader().getVertexSource()).not.toBeNull();
-      });
-      
-      it("should produce an input map", function() {
-        expect(Jax.Util.properties(chain.getInputMap(material))).toEqualVector(['one_x', 'one_y']);
-      });
-      
-      describe(" - fragment - ", function() {
-        it("should use local for uniform name", function() {
-          expect(chain.getFragmentSource(material)).toMatch(/uniform float two1_y;/);
-        });
-        
-        it("should perform import", function() {
-          expect(chain.getFragmentSource(material)).toMatch(/a = _shader_ambient;/);
-        });
-      
-        it("should define one_main", function() {
-          expect(chain.getFragmentSource(material)).toMatch(/void one0_main_f\(void\)/);
-        });
-
-        it("should define two_main", function() {
-          expect(chain.getFragmentSource(material)).toMatch(/void two1_main_f\(void\)/);
-        });
-      
-        it("should define exported variables", function() {
-          expect(chain.getFragmentSource(material)).toMatch(/vec4 _shader_ambient;/);
-        });
-      
-        it("should build a main()", function() {
-          expect(chain.getFragmentSource(material)).toMatch(/void main\(void/);
-        });
-      
-        describe("#main", function() {
-          it("should call main for 'one'", function() {
-            expect(chain.getFragmentMain()).toMatch(/one0_main_f\(\);/);
-          });
-
-          it("should call main for 'two'", function() {
-            expect(chain.getFragmentMain()).toMatch(/two1_main_f\(\);/);
-          });
-        });
-      });
-      
-      describe(" - vertex - ", function() {
-        it("should use local for uniform name", function() {
-          expect(chain.getVertexSource(material)).toMatch(/uniform int one0_x;/);
-        });
-        
-        it("should perform import", function() {
-          expect(chain.getVertexSource(material)).toMatch(/p = _shader_position;/);
-        });
-        
-        it("should define one_main", function() {
-          expect(chain.getVertexSource(material)).toMatch(/void one0_main_v\(void\)/);
-        });
-        
-        it("should define two_main", function() {
-          expect(chain.getVertexSource(material)).toMatch(/void two1_main_v\(void\)/);
-        });
-        
-        it("should define exported variables", function() {
-          expect(chain.getVertexSource(material)).toMatch(/vec3 _shader_position;/);
-        });
-        
-        it("should build a main()", function() {
-          expect(chain.getVertexSource(material)).toMatch(/void main\(void/);
-        });
-        
-        describe("#main", function() {
-          it("should call main for 'one'", function() {
-            expect(chain.getVertexMain()).toMatch(/one0_main_v\(\);/);
-          });
-          
-          it("should call main for 'two'", function() {
-            expect(chain.getVertexMain()).toMatch(/two1_main_v\(\);/);
-          });
-        });
-      });
-    });
-  });
-});