jax 1.1.1 → 2.0.0

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

@@ -0,0 +1,117 @@
+describe("Jax.Material", function() {
+  var material, mesh;
+  var _img = "/textures/rss.png";
+  
+  beforeEach(function() { mesh = new Jax.Mesh(); });
+  
+  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":"/textures/rock.png","flip_y":false,"scale":1},
+          {"type":"NormalMap","path":"/textures/rock_normal.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(SPEC_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(/\/textures\/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(/\/textures\/rss\.png$/);
+      expect(material.layers[1].texture.image.src).toMatch(/\/textures\/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(SPEC_CONTEXT, mesh, {shader:"basic"});
+        material.render(SPEC_CONTEXT, mesh, {shader:"blinn-phong"});
+        
+        spyOn(material, 'buildShader').andCallThrough();
+        material.render(SPEC_CONTEXT, mesh, {shader:"basic"});
+        expect(material.buildShader).not.toHaveBeenCalled();
+      });
+      
+//      it("should build both shaders", function() {
+//        spyOn(material, 'buildShader').andCallThrough();
+//        material.render(SPEC_CONTEXT, mesh, {shader:"blinn-phong"});
+//        material.render(SPEC_CONTEXT, mesh, {shader:"basic"});
+//        expect(material.buildShader).toHaveBeenCalledWith('blinn-phong', SPEC_CONTEXT);
+//        expect(material.buildShader).toHaveBeenCalledWith('basic', SPEC_CONTEXT);
+//      });
+    });
+  
+    
+//    it("should use basic shader", function() {
+//      spyOn(material, 'prepareShader').andCallThrough();
+//      material.render(SPEC_CONTEXT, mesh);
+//      // I don't like this, but I don't know a better way to test it.
+//      expect(material.prepareShader).toHaveBeenCalledWith('basic', SPEC_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,228 @@
+describe("Jax.Mesh", function() {
+  var mesh;
+  
+  it("points", function() {
+    var realDrawMode;
+    var mat = new Jax.Material();
+    mat.render = function(context, mesh, options) {
+      realDrawMode = options.draw_mode;
+    };
+    mesh = new Jax.Mesh({
+      init: function() { this.draw_mode = GL_POINTS; },
+      material: mat
+    });
+    mesh.rebuild();
+    mesh.render(SPEC_CONTEXT);
+    expect(realDrawMode).toEqual(GL_POINTS);
+  });
+  
+  describe("triangles", function() {
+    describe("GL_TRIANGLES vertices", function() {
+      beforeEach(function() {
+        mesh = new Jax.Mesh({init: function(v) {
+          this.draw_mode = GL_TRIANGLES;
+          v.push(0,0,0,  1,0,0,  0,1,0);
+          v.push(0,1,0,  1,0,0,  1,1,0);
+        }});
+      });
+      
+      it("should build triangles", function() {
+        var tri1 = mesh.getTriangles()[0];
+        var tri2 = mesh.getTriangles()[1];
+        
+        expect(tri1.a).toEqualVector([0,0,0]);
+        expect(tri1.b).toEqualVector([1,0,0]);
+        expect(tri1.c).toEqualVector([0,1,0]);
+
+        expect(tri2.a).toEqualVector([0,1,0]);
+        expect(tri2.b).toEqualVector([1,0,0]);
+        expect(tri2.c).toEqualVector([1,1,0]);
+      });
+    });
+
+    describe("GL_TRIANGLE_STRIP vertices", function() {
+      beforeEach(function() {
+        mesh = new Jax.Mesh({init: function(v) {
+          this.draw_mode = GL_TRIANGLE_STRIP;
+          v.push(0,0,0,  1,0,0);
+          v.push(0,1,0,  1,1,0);
+        }});
+      });
+      
+      it("should build triangles", function() {
+        var tri1 = mesh.getTriangles()[0];
+        var tri2 = mesh.getTriangles()[1];
+        
+        expect(tri1.a).toEqualVector([0,0,0]);
+        expect(tri1.b).toEqualVector([1,0,0]);
+        expect(tri1.c).toEqualVector([0,1,0]);
+
+        expect(tri2.a).toEqualVector([0,1,0]);
+        expect(tri2.b).toEqualVector([1,0,0]);
+        expect(tri2.c).toEqualVector([1,1,0]);
+      });
+    });
+
+    describe("GL_TRIANGLE_FAN vertices", function() {
+      beforeEach(function() {
+        mesh = new Jax.Mesh({init: function(v) {
+          this.draw_mode = GL_TRIANGLE_FAN;
+          v.push(0,0,0,  1,0,0);
+          v.push(1,1,0,  0,1,0);
+        }});
+      });
+      
+      it("should build triangles", function() {
+        var tri1 = mesh.getTriangles()[0];
+        var tri2 = mesh.getTriangles()[1];
+        
+        expect(tri1.a).toEqualVector([0,0,0]);
+        expect(tri1.b).toEqualVector([1,0,0]);
+        expect(tri1.c).toEqualVector([1,1,0]);
+
+        expect(tri2.a).toEqualVector([0,0,0]);
+        expect(tri2.b).toEqualVector([1,1,0]);
+        expect(tri2.c).toEqualVector([0,1,0]);
+      });
+    });
+  });
+  
+  describe("without vertices", function() {
+    beforeEach(function() {
+      mesh = new Jax.Mesh({init: function(v) { } });
+      mesh.getBounds().left = 1;
+      mesh.rebuild();
+    });
+    
+    it("should be renderable", function() {
+      expect(function() { mesh.render(SPEC_CONTEXT); }).not.toThrow();
+    });
+    
+    it("should have valid (but zero) bounds", function() {
+      expect(mesh.getBounds().left).toEqual(0);
+      expect(mesh.getBounds().right).toEqual(0);
+      expect(mesh.getBounds().top).toEqual(0);
+      expect(mesh.getBounds().bottom).toEqual(0);
+      expect(mesh.getBounds().front).toEqual(0);
+      expect(mesh.getBounds().back).toEqual(0);
+      expect(mesh.getBounds().width).toEqual(0);
+      expect(mesh.getBounds().height).toEqual(0);
+      expect(mesh.getBounds().depth).toEqual(0);
+    });
+  });
+  
+  describe("without normals", function() {
+    beforeEach(function() {
+      mesh = new Jax.Mesh({init: function(v) { v.push(0,1,0, -1,0,0, 1,0,0); }});
+      mesh.rebuild();
+    });
+    
+    it("should auto-generate the normals when requested, but not before", function() {
+      // This is cheating BDD a bit because the only way to get the normal
+      // buffer without requesting it is to access the mesh's private properties.
+      // We'll test the data buffer and add some mocks, rather than test the data segments directly,
+      // to make the test a little less brittle.
+      expect((mesh.buffers.normal_buffer || {length:0}).length).toEqual(0);
+      expect(mesh.getNormalBuffer().getTypedArray()).toEqualVector([
+        0,0,1,  0,0,1,  0,0,1
+      ]);
+    });
+  });
+  
+  describe("a torus", function() {
+    beforeEach(function() { mesh = new Jax.Mesh.Torus(); mesh.rebuild(); });
+    
+    it("should build", function() { });
+  });
+  
+  describe("#setColor", function() {
+    beforeEach(function() {
+      mesh = new Jax.Mesh({init: function(vertices, colors) {
+        vertices.push(0,0,0); // need a vertex to color
+      }});
+    });
+    
+    it("should set with rgba args", function() {
+      try { mesh.setColor(1,0,0,1); } catch(e) { alert(e+"\n\n"+e.stack); }
+      expect(mesh.getColorBuffer().getTypedArray()).toEqualVector([1,0,0,1]);
+    });
+    
+    it("should set with vec4 args", function() {
+      mesh.setColor([1,0,0,1]);
+      expect(mesh.getColorBuffer().getTypedArray()).toEqualVector([1,0,0,1]);
+    });
+  });
+  
+  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();
+        var color = vec4.create();
+        for (var i = 0; i < mesh.getVertexBuffer().js.length / 3; i += 4) {
+          color[0] = cbuf.js[i]; color[1] = cbuf.js[i+1]; color[2] = cbuf.js[i+2]; color[3] = cbuf.js[i+3];
+          expect(color).toEqualVector([0.5, 0, 0.4, 0.2]);
+        }
+      });
+    });
+    
+    it("should set color", function() {
+      mesh.color = [0.5,0,0.4,0.2];
+      mesh.rebuild();
+      var cbuf = mesh.getColorBuffer();
+      var color = vec4.create();
+      for (var i = 0; i < cbuf.js.length; i += 4) {
+        color[0] = cbuf.js[i]; color[1] = cbuf.js[i+1]; color[2] = cbuf.js[i+2]; color[3] = cbuf.js[i+3];
+        expect(color).toEqualVector([0.5, 0, 0.4, 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(SPEC_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,57 @@
+describe("Jax.Shader.Manifest", function() {
+  var manifest;
+  var img = "/textures/rss.png";
+  
+  beforeEach(function() {
+    manifest = new Jax.Shader.Manifest();
+  });
+  
+  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(SPEC_CONTEXT, 'glActiveTexture');
+          spyOn(tex0, 'bind');
+          spyOn(tex1, 'bind');
+          manifest.texture('Texture0', tex0, SPEC_CONTEXT);
+          manifest.texture('Texture1', tex1, SPEC_CONTEXT);
+          return true;
+        }
+        return false;
+      });
+    });
+    
+    // see Jax.Material for the reason this is disabled
+    xit("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, SPEC_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, SPEC_CONTEXT);
+      expect(manifest.getValue('Texture0')).toEqual(i);
+    });
+    
+    it("should activate the textures", function() {
+      expect(SPEC_CONTEXT.glActiveTexture).toHaveBeenCalledWith(GL_TEXTURE0);
+      expect(SPEC_CONTEXT.glActiveTexture).toHaveBeenCalledWith(GL_TEXTURE1);
+    });
+    
+    it("should bind the textures", function() {
+      expect(tex0.bind).toHaveBeenCalledWith(SPEC_CONTEXT, 0);
+      expect(tex1.bind).toHaveBeenCalledWith(SPEC_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,211 @@
+describe("Jax.ShaderChain", function() {
+  var chain, material;
+  
+  beforeEach(function() {
+    material = new Jax.Material();
+    chain = new Jax.ShaderChain("shader");
+  });
+  
+  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() {
+      // mock up the context's uniforms if the webgl context isn't a real implementation
+      if (SPEC_CONTEXT.gl.fake) {
+        // --- here's how the mocks will be used ---
+        // var numUniforms = context.glGetProgramParameter(program, GL_ACTIVE_UNIFORMS);
+        // for (var i = 0; i < numUniforms; i++)
+        //   var unif = context.glGetActiveUniform(program, i);
+        //   uniforms[unif.name] = {
+        //     length:unif.length,
+        //     size:unif.size,
+        //     type:unif.type,
+        //     type_str:Jax.Util.enumName(unif.type),
+        //     location: context.glGetUniformLocation(program, unif.name)
+        //   };
+        // if (!context.glGetProgramParameter(program, GL_LINK_STATUS))
+        SPEC_CONTEXT.gl.getProgramParameter = function(p, en) {
+          if (en == GL_ACTIVE_UNIFORMS) return 1;
+          if (en == GL_LINK_STATUS) return {};
+          return 0;
+        };
+        SPEC_CONTEXT.gl.getActiveUniform = function() { return { length:1, size:1, type:1, name:prefix+"TextureScaleX" } };
+      }
+      
+      chain.link(SPEC_CONTEXT, material);
+      chain.manifest.variable_prefix = prefix;
+      chain.manifest.set('TextureScaleX', 1);
+      var uniforms = chain.getUniformDelegator(SPEC_CONTEXT);
+      spyOn(uniforms, 'set');
+      chain.manifest.apply(uniforms, chain.getAttributeDelegator(SPEC_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(SPEC_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\(\);/);
+          });
+        });
+      });
+    });
+  });
+});