jax 1.1.1 → 2.0.0

data/lib/assets/javascripts/jax/webgl/scene/light_source.js

@@ -0,0 +1,300 @@
+Jax.POINT_LIGHT       = 1;
+Jax.SPOT_LIGHT        = 2;
+Jax.DIRECTIONAL_LIGHT = 3;
+
+Jax.Scene.LightSource = (function() {
+  function setupProjection(self) {
+    if (self.camera.projection) return;
+    
+    switch(self.type) {
+      case Jax.DIRECTIONAL_LIGHT:
+        self.camera.ortho({left:-1,right:1, top:1,bottom:-1, near:-1,far:1 });
+        self.camera.setPosition(0,0,0);
+        break;
+      case Jax.POINT_LIGHT:
+        self.camera.perspective({fov:45,near:0.01,far:500,width:2048,height:2048});
+        break;
+      case Jax.SPOT_LIGHT:
+        self.camera.perspective({near:0.1,far:500,fov:60,width:2048,height:2048});
+        break;
+      default:
+        throw new Error("Unexpected light type: "+self.type);
+    }
+  }
+  
+  return Jax.Model.create({
+    initialize: function($super, data) {
+      data = Jax.Util.normalizeOptions(data, {
+        enabled: true,
+        type: Jax.POINT_LIGHT,
+        color: {
+          ambient: [0,0,0,1],
+          diffuse: [1,1,1,1],
+          specular: [1,1,1,1]
+        },
+        position: [0,0,0],
+        direction: [0,0,-1],
+        angle: Math.PI/6,
+        attenuation: {
+          constant: 0,
+          linear: 0.02,
+          quadratic: 0
+        },
+        spot_exponent: 0,
+        shadowcaster: true
+      });
+      
+      if (typeof(data.type) == "string") data.type = Jax[data.type] || data.type;
+      data.color.ambient = Jax.Util.colorize(data.color.ambient);
+      data.color.diffuse = Jax.Util.colorize(data.color.diffuse);
+      data.color.specular= Jax.Util.colorize(data.color.specular);
+      $super(data);
+      
+      var self = this;
+      this.camera.addEventListener('updated', function() { self.invalidate(); });
+
+      this.spotExponent = this.spot_exponent;
+      delete this.spot_exponent;
+
+      this.shadowMatrix = mat4.create();
+      
+      this.framebuffers = [new Jax.Framebuffer({width:1024,height:1024,depth:true,color:GL_RGBA}),
+                           new Jax.Framebuffer({width:1024,height:1024,depth:true,color:GL_RGBA})];
+
+      setupProjection(this);
+    },
+    
+    format: function() {
+      this._format = this._format || new glMatrixArrayType(Jax.Scene.LightSource.STRUCT_SIZE);
+      var i, j, len = 0, self = this;
+      function push() { for (j = 0; j < arguments.length; j++) self._format[len++] = arguments[j]; }
+      for (i = 0; i < arguments.length; i++) {
+        switch(arguments[i]) {
+          case Jax.Scene.LightSource.POSITION:              push.apply(this, this.getPosition());      break;
+          case Jax.Scene.LightSource.DIRECTION:             push.apply(this, this.getDirection());     break;
+          case Jax.Scene.LightSource.AMBIENT:               push.apply(this, this.getAmbientColor());  break;
+          case Jax.Scene.LightSource.DIFFUSE:               push.apply(this, this.getDiffuseColor());  break;
+          case Jax.Scene.LightSource.SPECULAR:              push.apply(this, this.getSpecularColor()); break;
+          case Jax.Scene.LightSource.CONSTANT_ATTENUATION:  push(this.getConstantAttenuation());       break;
+          case Jax.Scene.LightSource.LINEAR_ATTENUATION:    push(this.getLinearAttenuation());         break;
+          case Jax.Scene.LightSource.QUADRATIC_ATTENUATION: push(this.getQuadraticAttenuation());      break;
+          case Jax.Scene.LightSource.SPOTLIGHT_EXPONENT:    push(this.getSpotExponent());              break;
+          case Jax.Scene.LightSource.SPOTLIGHT_COS_CUTOFF:  push(this.getSpotCosCutoff());             break;
+          default: throw new Error("Unexpected light source format descriptor: "+arguments[i]);
+        }
+      }
+      return this._format;
+    },
+    
+    getPosition: function() { setupProjection(this); return this.camera.getPosition(); },
+    getDirection: function() { setupProjection(this); return this.camera.getViewVector(); },
+
+    setEnabled: function(b) { this.enabled = b; },
+    enable: function() { this.setEnabled(true); },
+    disable: function() { this.setEnabled(false); },
+
+    isEnabled: function() { return this.enabled; },
+    getType: function() { return this.type; },
+
+    getDiffuseColor: function() { return this.color.diffuse; },
+    getAmbientColor: function() { return this.color.ambient; },
+    getSpecularColor: function() { return this.color.specular; },
+    getConstantAttenuation: function() { return this.attenuation.constant; },
+    getQuadraticAttenuation: function() { return this.attenuation.quadratic; },
+    getLinearAttenuation: function() { return this.attenuation.linear; },
+    getAngle: function() { return this.angle; },
+    getSpotExponent: function() { return this.spotExponent; },
+    getSpotCosCutoff: function() { return Math.cos(this.angle); },
+    
+    getShadowMapTexture: function(context) {
+      setupProjection(this);
+      return this.framebuffers[0].getTexture(context, 0);
+    },
+    
+    getShadowMapTextures: function(context) {
+      setupProjection(this);
+      return [this.framebuffers[0].getTexture(context, 0),
+              this.framebuffers[1].getTexture(context, 0)];
+    },
+    
+    isShadowMapEnabled: function() {
+      return !!(this.framebuffers && this.isShadowcaster());
+    },
+    
+    getShadowMatrix: function() {
+      return this.shadowMatrix;
+    },
+    
+    registerCaster: function(object) {
+      var self = this;
+      function updated() { self.invalidate(); }
+      object.camera.addEventListener('updated', updated);
+      this.invalidate();
+    },
+    
+    unregisterCaster: function(object) {
+      /* FIXME remove the shadowmap event listener from object's camera matrix */
+    },
+    
+    isShadowcaster: function() { return this.shadowcaster; },
+    
+    getDPShadowNear: function() { setupProjection(this); return this.camera.projection.near; },
+    
+    getDPShadowFar: function() { setupProjection(this); return this.camera.projection.far; },
+    
+    invalidate: function() { this.valid = false; },
+    
+    render: function(context, objects, options) {
+      if (!this.valid) {
+        var real_pass = context.current_pass;
+        /* shadowgen pass */
+        context.current_pass = Jax.Scene.SHADOWMAP_PASS;
+        // Look for errors while rendering the shadow map; if any occur, log them, but then
+        // disable shadowmap generation so Jax can continue without shadow support.
+        try {
+          if (this.shadowcaster)
+            this.updateShadowMap(context, this.boundingRadius, objects, options);
+          this.valid = true;
+        } catch(e) {
+          if (Jax.getGlobal().console && Jax.getGlobal().console.log)
+            Jax.getGlobal().console.log(e.toString());
+          this.shadowcaster = false;
+        }
+        context.current_pass = real_pass;
+      }
+      
+      for (var j = 0; j < objects.length; j++) {
+        options.model_index = j;
+        
+        /* TODO optimization: see if objects[j] is even affected by this light (based on attenuation) */
+        if (objects[j].isLit()) // it could be unlit but still in array if it casts a shadow
+          objects[j].render(context, options);
+      }
+    },
+    
+    updateShadowMap: function(context, sceneBoundingRadius, objects, render_options) {
+      // we can't afford to taint the original options
+      render_options = Jax.Util.normalizeOptions(render_options, {});
+      
+      setupProjection(this);
+      
+      var self = this;
+      var sm = this.shadowMatrix;
+      var lightToSceneDistance = vec3.length(this.camera.getPosition());
+      var nearPlane = lightToSceneDistance - sceneBoundingRadius;
+      if (nearPlane < 0.01) nearPlane = 0.01;
+
+      if (this.type == Jax.DIRECTIONAL_LIGHT) {
+        this.camera.ortho({left:-sceneBoundingRadius,right:sceneBoundingRadius,
+                           top:sceneBoundingRadius,bottom:-sceneBoundingRadius,
+                           near:-sceneBoundingRadius,far:sceneBoundingRadius
+        });
+        this.camera.setPosition(0,0,0);
+      } else if (this.type == Jax.SPOT_LIGHT) {
+        // Save the depth precision for where it's useful
+        var fieldOfView = Math.radToDeg(2.0 * Math.atan(sceneBoundingRadius / lightToSceneDistance));
+      
+//        fieldOfView = Math.radToDeg(this.getAngle());
+        fieldOfView = 60;
+        this.camera.perspective({near:nearPlane,far:nearPlane+(2.0*sceneBoundingRadius),fov:fieldOfView,width:2048,height:2048});
+      } else if (this.type == Jax.POINT_LIGHT) {
+        var paraboloid_depthmap = Jax.Material.find("paraboloid-depthmap");
+        
+        context.glDisable(GL_BLEND);
+        context.glEnable(GL_CULL_FACE);
+        context.glCullFace(GL_FRONT);
+        context.glEnable(GL_POLYGON_OFFSET_FILL);
+        context.glPolygonOffset(2.0, 2.0);
+        
+        context.pushMatrix(function() {
+          render_options.direction = 1;
+          render_options.material = paraboloid_depthmap;
+          
+          self.framebuffers[0].bind(context, function() {
+            // front paraboloid
+            self.framebuffers[0].viewport(context);
+            context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            context.loadViewMatrix(self.camera.getTransformationMatrix());
+            mat4.set(context.getInverseViewMatrix(), sm);
+            
+            for (var i = 0; i < objects.length; i++) {
+              objects[i].render(context, render_options);
+            }
+          });
+
+          render_options.direction = -1;
+          
+          self.framebuffers[1].bind(context, function() {
+            // back paraboloid
+            self.framebuffers[1].viewport(context);
+            context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+            context.loadViewMatrix(self.camera.getTransformationMatrix());
+            for (var i = 0; i < objects.length; i++) {
+              objects[i].render(context, render_options);
+            }
+          });
+  
+          context.glDisable(GL_POLYGON_OFFSET_FILL);
+          context.glEnable(GL_BLEND);
+          context.glCullFace(GL_BACK);
+          context.glDisable(GL_CULL_FACE);
+
+          // restore the original context viewport
+          context.glViewport(0, 0, context.canvas.width, context.canvas.height);
+        });
+
+        return;
+      }
+      
+      render_options.material = "depthmap";
+      
+      this.framebuffers[0].bind(context, function() {
+        self.framebuffers[0].viewport(context);
+        context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        context.pushMatrix(function() {
+          self.framebuffers[0].viewport(context);
+          context.matrix_stack.loadProjectionMatrix(self.camera.getProjectionMatrix());
+          context.matrix_stack.loadViewMatrix(self.camera.getTransformationMatrix());
+          mat4.identity(sm);
+          sm[0] = sm[5] = sm[10] = sm[12] = sm[13] = sm[14] = 0.5;
+          mat4.multiply(sm, context.getModelViewProjectionMatrix());
+          
+          context.glEnable(GL_CULL_FACE);
+          context.glCullFace(GL_FRONT);
+          context.glDisable(GL_BLEND);
+          context.glEnable(GL_POLYGON_OFFSET_FILL);
+          context.glPolygonOffset(2.0, 2.0);
+          for (var i = 0; i < objects.length; i++) {
+            objects[i].render(context, render_options);
+          }
+          context.glDisable(GL_POLYGON_OFFSET_FILL);
+          context.glEnable(GL_BLEND);
+          context.glCullFace(GL_BACK);
+          context.glDisable(GL_CULL_FACE);
+        });
+        // restore the original context viewport
+        context.glViewport(0, 0, context.canvas.width, context.canvas.height);
+      });
+    }
+  });
+})();
+
+/*
+  Constants used internally when constructing the flat-array format for a light source.
+  This is so we don't need to make redundant glUniform() calls to specify the attributes of a single
+  light source.
+ */
+Jax.Scene.LightSource.POSITION              =  1;
+Jax.Scene.LightSource.DIRECTION             =  2;
+Jax.Scene.LightSource.AMBIENT               =  3;
+Jax.Scene.LightSource.DIFFUSE               =  4;
+Jax.Scene.LightSource.SPECULAR              =  5;
+Jax.Scene.LightSource.CONSTANT_ATTENUATION  =  6;
+Jax.Scene.LightSource.LINEAR_ATTENUATION    =  7;
+Jax.Scene.LightSource.QUADRATIC_ATTENUATION =  8;
+Jax.Scene.LightSource.SPOTLIGHT_EXPONENT    =  9;
+Jax.Scene.LightSource.SPOTLIGHT_COS_CUTOFF  = 10;
+
+/* The size of the light source structure, in float elements */
+Jax.Scene.LightSource.STRUCT_SIZE = 23;
+

data/lib/assets/javascripts/jax/webgl/scene.js

@@ -0,0 +1,16 @@
+//= require_self
+//= require "jax/webgl/scene/frustum"
+//= require "jax/webgl/scene/light_manager"
+
+/**
+ * Jax.Scene
+ *
+ **/
+Jax.Scene = {};
+
+/* used by some shaders to determine what kind of shading is to be done.
+ * This is stored in context.world.current_pass.
+ */
+Jax.Scene.ILLUMINATION_PASS = 1;
+Jax.Scene.AMBIENT_PASS = 2;
+Jax.Scene.SHADOWMAP_PASS = 3;

data/lib/assets/javascripts/jax/webgl/shader/delegator/attribute.js

@@ -0,0 +1,53 @@
+//= require "../delegator"
+
+Jax.Shader.AttributeDelegator = (function() {
+  return Jax.Class.create(Jax.Shader.Delegator, {
+    initialize: function($super, context, program) {
+      var numAttributes = context.glGetProgramParameter(program, GL_ACTIVE_ATTRIBUTES);
+      var attributes = {};
+      for (var i = 0; i < numAttributes; i++)
+      {
+        var attrib = context.glGetActiveAttrib(program, i);
+        attributes[attrib.name] = {
+          length:attrib.length,
+          size:attrib.size,
+          type:attrib.type,
+          type_str:Jax.Util.enumName(attrib.type),
+          location: context.glGetAttribLocation(program, attrib.name)
+        };
+      }
+      $super(context, program, attributes);
+    },
+    
+    set: function(name, value) {
+      var v, c = this.context, i, variables = this.variables;
+      
+      function _set(name, value) {
+        if (value == undefined) return;
+//        if (value == undefined) throw new Error("Value is undefined for shader attribute "+JSON.stringify(name));
+        
+        if (v = variables[name]) {
+          value.bind(c);
+          c.glEnableVertexAttribArray(v.location);
+          c.glVertexAttribPointer(v.location, value.itemSize, GL_FLOAT, false, 0, 0);
+//        } else {
+//          console.warn("skipping assignment of attribute %s (variables: %s)", name, JSON.stringify(variables));
+        }
+      }
+      
+      if (arguments.length == 1 && typeof(arguments[0]) == "object")
+        for (i in arguments[0])
+          _set(i, arguments[0][i]);
+      else
+        for (i = 0; i < arguments.length; i += 2)
+          _set(arguments[i], arguments[i+1]);
+    },
+    
+    disableAll: function() {
+      for (var v in this.variables) {
+        v = this.variables[v];
+        this.context.glDisableVertexAttribArray(v.location);
+      }
+    }
+  });
+})();

data/lib/assets/javascripts/jax/webgl/shader/delegator/uniform.js

@@ -0,0 +1,71 @@
+//= require "../delegator"
+
+Jax.Shader.UniformDelegator = (function() {
+  return Jax.Class.create(Jax.Shader.Delegator, {
+    initialize: function($super, context, program) {
+      var numUniforms = context.glGetProgramParameter(program, GL_ACTIVE_UNIFORMS);
+      var 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)
+        };
+      }
+      $super(context, program, uniforms);
+    },
+    
+    set: function(name, value) {
+      var self = this;
+      var variables = this.variables, v, c = this.context, i;
+      
+      function _set(name, value) {
+        if (value == undefined) throw new Error("Value is undefined for shader uniform "+JSON.stringify(name));
+        
+        if (v = variables[name]) {
+          try {
+            switch(v.type) {
+              case GL_FLOAT:
+                value.length != undefined ? c.glUniform1fv(v.location, value) : c.glUniform1f(v.location, value);
+                break;
+              case GL_BOOL: // same as int
+              case GL_INT:
+                value.length != undefined ? c.glUniform1iv(v.location, value) : c.glUniform1i(v.location, value);
+                break;
+              case GL_FLOAT_VEC2:   c.glUniform2fv(v.location, value); break;
+              case GL_FLOAT_VEC3:   c.glUniform3fv(v.location, value); break;
+              case GL_FLOAT_VEC4:   c.glUniform4fv(v.location, value); break;
+              case GL_FLOAT_MAT2:   c.glUniformMatrix2fv(v.location, false, value); break;
+              case GL_FLOAT_MAT3:   c.glUniformMatrix3fv(v.location, false, value); break;
+              case GL_FLOAT_MAT4:   c.glUniformMatrix4fv(v.location, false, value); break;
+              case GL_BOOL_VEC2:    // same as int
+              case GL_INT_VEC2:     c.glUniform2iv(v.location, value); break;
+              case GL_BOOL_VEC3:    // same as int
+              case GL_INT_VEC3:     c.glUniform3iv(v.location, value); break;
+              case GL_BOOL_VEC4:    // same as int
+              case GL_INT_VEC4:     c.glUniform4iv(v.location, value); break;
+              case GL_SAMPLER_2D:   c.glUniform1i(v.location, value); break;
+              case GL_SAMPLER_CUBE: c.glUniform1i(v.location, value); break;
+              default:
+                throw new Error("Unexpected attribute type: "+v.type+" ("+JSON.stringify(v)+")");
+            }
+          } catch(e) {
+            var error = new Error("Failed to set uniform for "+name+' ('+value+") in shader program:\n\n"+e);
+            Jax.reraise(e, error);
+          }
+        }
+      }
+      
+      if (arguments.length == 1 && typeof(arguments[0]) == "object")
+        for (i in arguments[0])
+          _set(i, arguments[0][i]);
+      else
+        for (i = 0; i < arguments.length; i += 2)
+          _set(arguments[i], arguments[i+1]);
+    }
+  });
+})();

data/lib/assets/javascripts/jax/webgl/shader/delegator.js

@@ -0,0 +1,13 @@
+Jax.Shader.Delegator = (function() {
+  return Jax.Class.create({
+    initialize: function(context, program, variables) {
+      this.context = context;
+      this.program = program;
+      this.variables = variables;
+    },
+    
+    doesExist: function(key) {
+      return this.variables[key] != undefined;
+    }
+  });
+})();

data/lib/assets/javascripts/jax/webgl/shader/manifest.js

@@ -0,0 +1,70 @@
+/**
+ * class Jax.Shader.Manifest
+ *   
+ * Used to track variable assignments. After all assignments have been made just prior to committing a render phase,
+ * the manifest will be used to actually pass variable values into the shader. This keeps from specifying shader
+ * values more than once. Manifest can also be used to cache values between render passes, because its values are
+ * never reset.
+ **/
+Jax.Shader.Manifest = Jax.Class.create({
+  initialize: function(existing) {
+    this.values = {};
+    this.texture_tracker = 0;
+    this.variable_prefix = "";
+    this.existing = existing || [];
+  },
+  
+  set: function(name, value) {
+    var i;
+    if (value === undefined)
+      if (typeof(name) == "object")
+        for (i in name)
+          this.set(i, name[i]);
+      else throw new Error("Invalid argument (or the value given is undefined): "+
+              JSON.stringify(name)+"\n\n"+new Error().stack);
+    else
+      for (i = 0; i < arguments.length; i += 2) {
+        if (this.existing.indexOf(arguments[i]) != -1)
+          this.values[arguments[i]] = arguments[i+1];
+        else
+          this.values[this.variable_prefix+arguments[i]] = arguments[i+1];
+      }
+  },
+  
+  getValue: function(name) {
+    if (this.existing.indexOf(name) != -1)
+      return this.values[name];
+    else return this.values[this.variable_prefix+name];
+  },
+  
+  texture: function(name, tex, context) {
+    if (!context) throw new Error("Can't bind texture without a context");
+    if (this.texture_tracker == GL_MAX_ACTIVE_TEXTURES-1) {
+      /* FIXME add a callback for Materials to enter compatibility mode and recompile their shaders
+         before throwing a hard error. Until this is implemented, the hard error itself is disabled
+         because it causes unnecessary barfing on machines that are otherwise capable of running the
+         scene. Using too many textures doesn't seem to have any catastrophic results on tested
+         hardware, except some visual anomolies, so there's no reason to crash out catastrophically.
+      */
+//      throw new Error("Maximum number of textures ("+GL_MAX_ACTIVE_TEXTURES+") has been reached!");
+    }
+    
+    if (typeof(this.getValue(name)) != "number")
+      this.set(name, this.texture_tracker++);
+    
+    if (tex.loaded) {
+      context.glActiveTexture(GL_TEXTURES[this.getValue(name)]);
+      tex.bind(context, this.getValue(name));
+    }
+  },
+  
+  apply: function(uniforms, attributes) {
+    attributes.disableAll();
+    for (var name in this.values) {
+      if (uniforms.doesExist(name))
+        uniforms.set(name, this.values[name]);
+      else if (attributes.doesExist(name))
+        attributes.set(name, this.values[name]);
+    }
+  }
+});

data/lib/assets/javascripts/jax/webgl/shader/program.js

@@ -0,0 +1,138 @@
+//= require "jax/webgl/shader/delegator/attribute"
+//= require "jax/webgl/shader/delegator/uniform"
+//= require "jax/webgl/shader/manifest"
+
+Jax.Shader.Program = (function() {
+  function buildShaderSources(self, context, material) {
+    for (var i = 0; i < self.shaders.length; i++) {
+      self.shaders[i].build(context, material);
+    }
+  }
+  
+  function getShaderProgram(self, context) {
+    if (self.programs[context.id]) return self.programs[context.id];
+    return self.programs[context.id] = context.glCreateProgram();
+  }
+  
+  function addToVariableList(self, delegator) {
+    for (var name in delegator.variables) {
+      self.variable_names.push(name);
+    }
+  }
+  
+  function updateVariableList(self, context) {
+    while (self.variable_names.length > 0) self.variable_names.pop();
+    addToVariableList(self, self.getAttributeDelegator(context));
+    addToVariableList(self, self.getUniformDelegator(context));
+  }
+  
+  function linkProgram(self, context, material, program) {
+    /* really attach those shaders that we've pretended to have attached already */
+    for (var i = 0; i < self.shaders.length; i++) {
+      var shader = self.shaders[i];
+      var vert = shader.getVertexShader(context),
+          frag = shader.getFragmentShader(context);
+      
+      if (vert) {
+        program.vertex = vert;
+        program.vertex_shader = vert;
+        context.glAttachShader(program, vert);
+      }
+      if (frag) {
+        program.fragment = true;
+        program.fragment_shader = frag;
+        context.glAttachShader(program, frag);
+      }
+    }
+
+    if (!program.vertex || !program.fragment)
+      throw new Error("Attempted to link program missing either a vertex or fragment shader! " +
+                      "(WebGL requires at least 1 of each.)");
+    
+    buildShaderSources(self, context, material);
+    context.glLinkProgram(program);
+    
+    if (!context.glGetProgramParameter(program, GL_LINK_STATUS))
+      throw new Error("Could not initialize shader!\n\n"+context.glGetProgramInfoLog(program));
+    else program.linked = true;
+    
+    context.glUseProgram(program);
+
+    self.attribute_delegator[context.id] = new Jax.Shader.AttributeDelegator(context, program);
+    self.uniform_delegator[context.id] = new Jax.Shader.UniformDelegator(context, program);
+  }
+  
+  return Jax.Class.create({
+    initialize: function() {
+      this.shaders = [];
+      this.programs = {};
+      this.attribute_delegator = {};
+      this.uniform_delegator = {};
+      this.variable_names = [];
+      this.manifest = new Jax.Shader.Manifest(this.variable_names);
+    },
+    
+    attach: function(shaderName, context) {
+      if (!context) throw new Error("No context!");
+      var shader = Jax.shaders[shaderName];
+      if (!shader)
+        throw new Error("Could not find shader named '"+shaderName+"'! " +
+                        "Does it exist in Jax.shaders?");
+      this.shaders.push(shader);
+    },
+    
+    invalidate: function() {
+      for (var i in this.programs)
+        this.programs[i].linked = false;
+    },
+    
+    link: function(context, material) {
+      var program = this.getGLProgram(context);
+      
+      if (!program.linked)
+        linkProgram(this, context, material, program);
+      
+      // update list of variable names
+      updateVariableList(this, context);
+      
+      return program;
+    },
+    
+    setShaderVariables: function(context, mesh, material, options) {
+      material.setShaderVariables(context, mesh, options, this.manifest);
+      this.manifest.apply(this.getUniformDelegator(context), this.getAttributeDelegator(context));
+    },
+    
+    render: function(context, mesh, material, options) {
+      var program = this.link(context, material);
+      
+      context.glUseProgram(program);
+      
+      this.setShaderVariables(context, mesh, material, options);
+      
+      try {
+        var buffer;
+        if ((buffer = mesh.getIndexBuffer()) && buffer.length > 0) {
+          buffer.bind(context);
+          context.glDrawElements(options.draw_mode, buffer.length, GL_UNSIGNED_SHORT, 0);
+        }
+        else if ((buffer = mesh.getVertexBuffer()) && buffer.length > 0) {
+          context.glDrawArrays(options.draw_mode, 0, buffer.length);
+        }
+      } catch(e) {
+        var error = new Error("Fatal error encountered while drawing mesh:\n\n"+e+"\n\nShaders: "+this.getShaderNames());
+        Jax.reraise(e, error);
+      }
+    },
+    
+    getShaderNames: function() {
+      var shaderNames = [];
+      for (var i = 0; i < this.shaders.length; i++) shaderNames[i] = this.shaders[i].getName();
+      return shaderNames;
+    },
+    
+    getGLProgram: function(context) { return getShaderProgram(this, context); },
+    getAttributeDelegator: function(context) { return this.attribute_delegator[context.id]; },
+    getUniformDelegator: function(context) { return this.uniform_delegator[context.id]; }
+  });
+})();