jax 0.0.0.1

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

@@ -0,0 +1,276 @@
+describe("Jax::Shader", function() {
+  var shader;
+  
+  describe("with shared uniforms", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        vertex: "shared uniform mat4 mvMatrix; void main(void) { gl_Position = mvMatrix * vec4(0,0,0,1); }",
+        name: "shader"
+      });
+    });
+    
+    it("should not mangle the uniform name", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).not.toMatch(/uniform mat4 shader0_mvMatrix;/);
+    });
+    
+    it("should not mangle the uniform reference", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).not.toMatch(/gl_Position = shader0_mvMatrix \* vec4/);
+    });
+    
+    it("should not include the word 'shared'", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).not.toMatch(/shared/);
+    });
+    
+    it("should add mvMatrix to the input map", function() {
+      expect(shader.getInputMap({export_prefix:"shader0"})['mvMatrix'].full_name).toEqual("mvMatrix");
+    });
+  });
+  
+  describe("with shared attributes", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        vertex: "shared attribute vec4 position; void main(void) { gl_Position = mvMatrix * position; }",
+        name: "shader"
+      });
+    });
+    
+    it("should not mangle the attribute name", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).not.toMatch(/attribute vec4 shader0_position;/);
+    });
+    
+    it("should not mangle the attribute reference", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).not.toMatch(/gl_Position = mvMatrix \* shader0_position/);
+    });
+    
+    it("should not include the word 'shared'", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).not.toMatch(/shared/);
+    });
+    
+    it("should add position to the input map", function() {
+      expect(shader.getInputMap({export_prefix:"shader0"})['position'].full_name).toEqual("position");
+    });
+  });
+  
+  describe("with shared varyings", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        vertex: "shared varying vec2 tex; void main(void) { tex = vec2(1,1); }",
+        fragment: "shared varying vec2 tex; void main(void) { gl_FragCoord = tex.xy; }",
+        name: "shader"
+      });
+    });
+    
+    it("should not mangle the vertex varying name", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).toMatch(/varying vec2 tex;/);
+    });
+    
+    it("should not mangle the vertex varying reference", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).toMatch(/ tex = vec2\(1,1\);/);
+    });
+
+    it("should add tex to the input map", function() {
+      expect(shader.getInputMap({export_prefix:"shader0"})['tex'].full_name).toEqual("tex");
+    });
+
+    it("should not mangle the fragment varying name", function() {
+      expect(shader.getFragmentSource({export_prefix:"shader0"})).toMatch(/varying vec2 tex;/);
+    });
+    
+    it("should not mangle the fragment varying reference", function() {
+      expect(shader.getFragmentSource({export_prefix:"shader0"})).toMatch(/ gl_FragCoord = tex.xy;/);
+    });
+  });
+  
+  describe("with uniforms", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        vertex: "uniform mat4 mvMatrix; void main(void) { gl_Position = mvMatrix * vec4(0,0,0,1); }",
+        name: "shader-name"
+      });
+    });
+    
+    it("should mangle the uniform name", function() {
+      expect(shader.getVertexSource({export_prefix:"shader-name0"})).toMatch(/uniform mat4 shader_name0_mvMatrix;/);
+    });
+    
+    it("should mangle the uniform reference", function() {
+      expect(shader.getVertexSource({export_prefix:"shader-name0"})).toMatch(/gl_Position = shader_name0_mvMatrix \* vec4/);
+    });
+
+    it("should add mvMatrix to the input map", function() {
+      expect(shader.getInputMap({export_prefix:"shader-name0"})['mvMatrix'].full_name).toEqual("shader_name0_mvMatrix");
+    });
+  });
+  
+  describe("with attributes", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        vertex: "attribute vec4 position; void main(void) { gl_Position = mvMatrix * position; }",
+        name: "shader"
+      });
+    });
+    
+    it("should mangle the attribute name", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).toMatch(/attribute vec4 shader0_position;/);
+    });
+    
+    it("should mangle the attribute reference", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).toMatch(/gl_Position = mvMatrix \* shader0_position/);
+    });
+
+    it("should add mvMatrix to the input map", function() {
+      expect(shader.getInputMap({export_prefix:"shader0"})['position'].full_name).toEqual("shader0_position");
+    });
+  });
+  
+  describe("with varyings", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        vertex: "varying vec2 tex; void main(void) { tex = vec2(1,1); }",
+        fragment: "varying vec2 tex; void main(void) { gl_FragCoord = tex.xy; }",
+        name: "shader"
+      });
+    });
+    
+    it("should mangle the vertex varying name", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).toMatch(/varying vec2 shader0_tex;/);
+    });
+    
+    it("should mangle the vertex varying reference", function() {
+      expect(shader.getVertexSource({export_prefix:"shader0"})).toMatch(/ shader0_tex = vec2\(1,1\);/);
+    });
+
+    it("should add tex to the input map", function() {
+      expect(shader.getInputMap({export_prefix:"shader0"})['tex'].full_name).toEqual("shader0_tex");
+    });
+
+    it("should mangle the fragment varying name", function() {
+      expect(shader.getFragmentSource({export_prefix:"shader0"})).toMatch(/varying vec2 shader0_tex;/);
+    });
+    
+    it("should mangle the fragment varying reference", function() {
+      expect(shader.getFragmentSource({export_prefix:"shader0"})).toMatch(/ gl_FragCoord = shader0_tex.xy;/);
+    });
+  });
+  
+  describe("with implicitly valued exports", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        fragment: "void main(void) { vec4 ambient; export(vec4, ambient); }",
+        exports: {"ambient":"vec4"},
+        name: "shader"
+      });
+    });
+    
+    it("should construct export definitions", function() {
+      expect(shader.getExportDefinitions('shader')).toMatch(/vec4 _shader_ambient;/);
+    });
+    
+    it("should add export definitions to source", function() {
+      expect(shader.getFragmentSource()).toMatch(/vec4 _shader_ambient;/);
+    });
+    
+    describe("and an overriding prefix", function() {
+      var options;
+      beforeEach(function() { options = { export_prefix: "test" }; });
+      
+      it("should define the overriding prefix", function() {
+        expect(shader.getFragmentSource(options)).toMatch(/vec4 _test_ambient;/);
+      });
+      
+      it("should reference the overriding prefix", function() {
+        expect(shader.getFragmentSource(options)).toMatch(/ _test_ambient = ambient;/);
+      });
+    });
+  });
+  
+  describe("with exports", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+//        fragment: "void main(void) { vec4 ambient; _shader_ambient = ambient; }",
+        fragment: "void main(void) { vec4 ambient; export(vec4, ambient, ambient); }",
+        exports: {"ambient":"vec4"},
+        name: "shader"
+      });
+    });
+    
+    describe("without spaces", function() {
+      beforeEach(function() {
+        shader = new Jax.Shader({
+          fragment: "void main(void) { vec4 ambient; export(vec4,ambient,ambient); }",
+          exports: {"ambient":"vec4"},
+          name: "shader"
+        });
+      });
+
+      it("should construct export definitions", function() {
+        expect(shader.getExportDefinitions('shader')).toMatch(/vec4 _shader_ambient;/);
+      });
+    });
+    
+    it("should construct export definitions", function() {
+      expect(shader.getExportDefinitions('shader')).toMatch(/vec4 _shader_ambient;/);
+    });
+    
+    it("should add export definitions to source", function() {
+      expect(shader.getFragmentSource()).toMatch(/vec4 _shader_ambient;/);
+    });
+    
+    describe("and an overriding prefix", function() {
+      var options;
+      beforeEach(function() { options = { export_prefix: "test" }; });
+      
+      it("should define the overriding prefix", function() {
+        expect(shader.getFragmentSource(options)).toMatch(/vec4 _test_ambient;/);
+      });
+      
+      it("should reference the overriding prefix", function() {
+        expect(shader.getFragmentSource(options)).toMatch(/ _test_ambient = ambient;/);
+      });
+    });
+    
+    describe("and imports", function() {
+      beforeEach(function() {
+        shader = new Jax.Shader({
+          fragment: "void main(void) { vec4 a = vec4(0); import(ambient, a += ambient); }",
+//          exports: {"ambient":"vec4"},
+          name: "shader"
+        });
+      });
+    
+      describe("without spaces", function() {
+        beforeEach(function() {
+          shader = new Jax.Shader({
+            fragment: "void main(void) { vec4 a = vec4(0); import(ambient,a+=ambient); }",
+            name: "shader"
+          });
+        });
+    
+        it("should use the export", function() {
+          expect(shader.getFragmentSource({export_prefix:"shader",exports:{"ambient":"vec4"}}))
+                  .toMatch(/vec4 a = vec4\(0\); a\+=_shader_ambient;/);
+        });
+      }); 
+    
+      it("should use the export", function() {
+        expect(shader.getFragmentSource({export_prefix:"shader",exports:{"ambient":"vec4"}}))
+                .toMatch(/vec4 a = vec4\(0\); a \+= _shader_ambient;/);
+      });
+    });
+  });
+  
+  describe("with no export and an import", function() {
+    beforeEach(function() {
+      shader = new Jax.Shader({
+        fragment: "void main(void) { vec4 a = vec4(0); import(ambient, a += ambient); }",
+//        exports: {"ambient":"vec4"},
+        name: "shader"
+      });
+    });
+    
+    it("should use the default", function() {
+      expect(shader.getFragmentSource()).toMatch(/vec4 a = vec4\(0\);/);
+      expect(shader.getFragmentSource()).not.toMatch(/a += _shader_ambient;/);
+    });
+  });
+});

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

@@ -0,0 +1,142 @@
+describe("Tangent space", function() {
+  var mesh;
+  it("should work with spheres", function() {
+    expect(new Jax.Mesh.Sphere().getTangentBuffer().js).not.toBeEmpty();
+  });
+  
+  describe("with a triangle strip", function() {
+    beforeEach(function() {
+      mesh = new Jax.Mesh({
+        init: function(verts, colors, textureCoords, normals) {
+          var width = 1, height = 1;
+      
+          verts.push(-width,  height, 0);
+          verts.push(-width, -height, 0);
+          verts.push( width,  height, 0);
+          verts.push( width, -height, 0);
+
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          
+          textureCoords.push(0, 1);
+          textureCoords.push(0, 0);
+          textureCoords.push(1, 1);
+          textureCoords.push(1, 0);
+      
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+        },
+        
+        draw_mode: GL_TRIANGLE_STRIP
+      });
+    });
+    
+    describe("converted into a triangle fan", function() {
+      beforeEach(function() {
+        mesh.getTangentBuffer(); // to generate the buffer
+        mesh.getVertexBuffer().js        = [0,0,0,   -1,1,0,  -1,-1,0,  1,-1,0,    1,1,0 ];
+        mesh.getTextureCoordsBuffer().js = [0.5,0.5,    0,1    ,  0,0,     1,0,      1,1];
+        mesh.getNormalBuffer().js        = [0,0,1,    0,0,1,    0,0,1,     0,0,1,  0,0,1];
+        mesh.getVertexBuffer().refresh();
+        mesh.getTextureCoordsBuffer().refresh();
+        mesh.getNormalBuffer().refresh();
+        mesh.draw_mode = GL_TRIANGLE_FAN;
+      });
+
+      it("should calculate tangents appropriately", function() {
+        expect(mesh.rebuildTangentBuffer().js).toEqualVector([1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1]);
+      });
+    });
+  });
+  
+  describe("with a triangle fan", function() {
+    beforeEach(function() {
+      mesh = new Jax.Mesh({
+        init: function(verts, colors, textureCoords, normals) {
+          var width = 1, height = 1;
+      
+          verts.push(0, 0, 0);
+          verts.push(-width,  height, 0);
+          verts.push(-width, -height, 0);
+          verts.push( width, -height, 0);
+          verts.push( width,  height, 0);
+
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          
+          textureCoords.push(0.5, 0.5);
+          textureCoords.push(0, 1);
+          textureCoords.push(0, 0);
+          textureCoords.push(1, 0);
+          textureCoords.push(1, 1);
+      
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+        },
+        
+        draw_mode: GL_TRIANGLE_FAN
+      });
+    });
+    
+    it("should calculate tangents appropriately", function() {
+      expect(mesh.getTangentBuffer().js).toEqualVector([1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1]);
+    });
+  });
+
+  describe("with triangles", function() {
+    beforeEach(function() {
+      mesh = new Jax.Mesh({
+        init: function(verts, colors, textureCoords, normals) {
+          var width = 1, height = 1;
+      
+          verts.push(-width,  height, 0); // 0
+          verts.push(-width, -height, 0); // 1
+          verts.push( width,  height, 0); // 2
+          
+          verts.push( width,  height, 0); // 4
+          verts.push(-width, -height, 0); // 3
+          verts.push( width, -height, 0); // 5
+
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          colors.push(1,1,1,1);
+          
+          textureCoords.push(0, 1); // 0
+          textureCoords.push(0, 0); // 1
+          textureCoords.push(1, 1); // 2
+
+          textureCoords.push(1, 1); // 4
+          textureCoords.push(0, 0); // 3
+          textureCoords.push(1, 0); // 5
+      
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+          normals.push(0,0,1);
+        },
+        
+        draw_mode: GL_TRIANGLES
+      });
+    });
+    
+    it("should calculate tangents appropriately", function() {
+      expect(mesh.getTangentBuffer().js).toEqualVector([1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1, 1,0,0,1]);
+    });
+  });
+
+});

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

@@ -0,0 +1,162 @@
+describe("Texture", function() {
+  var _img = "/images/rss.png";
+  
+  var c; // Jax context
+  var tex;
+  beforeEach(function() { c = new Jax.Context('canvas-element'); });
+  
+  /* _it calls spec only when texture is ready */
+  var _it = function(desc, testFunc) { 
+    return jasmine.getEnv().it(desc, function() { 
+      waitsFor(function() { if (tex.ready()) { testFunc(); return true; } return false; }, 1000); 
+    }); 
+  };
+  
+  describe("using strings instead of enums", function() {
+    // which is what happens when loaded from a resource
+    it("should detect enums", function() {
+      var tex = new Jax.Texture({
+        min_filter: 'GL_NEAREST',
+        mag_filter: 'GL_NEAREST',
+        mipmap_hint: 'GL_DONT_CARE',
+        format: 'GL_RGBA',
+        target: 'GL_TEXTURE_2D',
+        data_type: 'GL_UNSIGNED_BYTE',
+        wrap_s: 'GL_REPEAT',
+        wrap_t: 'GL_REPEAT'
+      });
+      
+      expect(tex.options.min_filter).toEqual(GL_NEAREST);
+      expect(tex.options.mag_filter).toEqual(GL_NEAREST);
+      expect(tex.options.mipmap_hint).toEqual(GL_DONT_CARE);
+      expect(tex.options.format).toEqual(GL_RGBA);
+      expect(tex.options.target).toEqual(GL_TEXTURE_2D);
+      expect(tex.options.data_type).toEqual(GL_UNSIGNED_BYTE);
+      expect(tex.options.wrap_s).toEqual(GL_REPEAT);
+      expect(tex.options.wrap_t).toEqual(GL_REPEAT);
+    });
+  });
+  
+  describe("NPOT", function() {
+    beforeEach(function() {
+      tex = new Jax.Texture("/images/brickwall.jpg");
+    });
+    
+    _it("should automatically use NPOT-compatible options", function() {
+      expect(tex.options.mag_filter).toEqual(GL_LINEAR);
+      expect(tex.options.min_filter).toEqual(GL_LINEAR);
+      expect(tex.options.wrap_s).toEqual(GL_CLAMP_TO_EDGE);
+      expect(tex.options.wrap_t).toEqual(GL_CLAMP_TO_EDGE);
+      expect(tex.options.generate_mipmap).toBeFalsy();
+    });
+    
+    _it("should render successfully", function() {
+      var matr = new Jax.Material.Texture(tex);
+      var m = new Jax.Model({mesh: new Jax.Mesh.Quad({material: matr})});
+      var context = new Jax.Context('canvas-element');
+      m.render(context);
+      context.dispose();
+    });
+  });
+  
+  describe("cube map", function() {
+    describe("with no image", function() {
+      beforeEach(function() {
+        tex = new Jax.Texture(null, {target:GL_TEXTURE_CUBE_MAP,width:128,height:128});
+        spyOn(c, 'glBindTexture').andCallThrough();
+      });
+      
+      it("should bind successfully", function() {
+        expect(function(){tex.bind(c);}).not.toThrow();
+        expect(c.glBindTexture).toHaveBeenCalled();
+      });
+    });
+    
+    describe("with a single POT texture", function() {
+      beforeEach(function() { tex = new Jax.Texture(_img, {target:GL_TEXTURE_CUBE_MAP}); });
+      
+      _it("should bind successfully", function() {
+        expect(function() { tex.bind(c); }).not.toThrow();
+      });
+    });
+
+    describe("with 6 POT textures", function() {
+      beforeEach(function() { tex = new Jax.Texture([_img,_img,_img,_img,_img,_img], {target:GL_TEXTURE_CUBE_MAP}); });
+      
+      _it("should bind successfully", function() {
+        expect(function() { tex.bind(c); }).not.toThrow();
+      });
+    });
+  });
+  
+  describe("with no image", function() {
+    beforeEach(function() {
+      tex = new Jax.Texture(null, {target:GL_TEXTURE_2D,width:128,height:128});
+      spyOn(c, 'glBindTexture').andCallThrough();
+    });
+      
+    it("should bind successfully", function() {
+      expect(function(){tex.bind(c);}).not.toThrow();
+      expect(c.glBindTexture).toHaveBeenCalled();
+    });
+  });
+    
+  describe("POT with default options", function() {
+    beforeEach(function() { tex = new Jax.Texture(_img); });
+    
+    describe("when bound with block", function() {
+      _it("should increment textureLevel", function() {
+        tex.bind(c, function(textureLevel0) {
+          expect(textureLevel0).toEqual(0);
+          expect(this).toEqual(tex);
+          expect(tex.textureLevel).toEqual(0);
+          
+          tex.bind(c, function(textureLevel1) {
+            expect(textureLevel1).toEqual(1);
+            expect(this).toEqual(tex);
+            expect(tex.textureLevel).toEqual(1);
+          });
+        });
+        
+        expect(tex.textureLevel).toBeUndefined();
+      });
+    });
+    
+    describe("when bound without block with level", function() {
+      beforeEach(function() {
+        waitsFor(function() { return tex.ready(); }, 1000);
+        spyOn(c, 'glActiveTexture').andCallThrough();
+      });
+      
+      it("should use texture 1", function() {
+        tex.bind(c, 1);
+        expect(c.glActiveTexture).toHaveBeenCalledWith(GL_TEXTURE1);
+      });
+    });
+    
+    describe("when bound without block", function() {
+      beforeEach(function() { waitsFor(function() { return tex.ready(); }, 1000); tex.bind(c); });
+      
+      it("should create a GL texture handle", function() {
+        expect(tex.getHandle(c)).not.toBeUndefined();
+      });
+      
+      it("should bind without error", function() {
+        expect(function() { tex.bind(c); }).not.toThrow();
+      });
+    });
+    
+    _it("should initialize", function() {
+      expect(tex.ready()).toBeTruthy();
+    });
+  });
+  
+  describe("POT with #onload", function() {
+    var loaded;
+    beforeEach(function() { loaded = false;tex = new Jax.Texture(_img, {onload:function(){loaded=true;}}); });
+    
+    _it("should call #onload", function() {
+      expect(loaded).toBeTruthy();
+    });
+  });
+});