jax 0.0.0.1

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

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

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

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

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

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

@@ -0,0 +1,192 @@
+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:"void 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\(\);/);
+          });
+        });
+      });
+    });
+  });
+});