jax 0.0.0.1

data/src/jax/webgl/core.js

@@ -0,0 +1,6 @@
+Jax.Core = {};
+
+//= require "core/face"
+//= require "core/edge"
+//= require "core/buffer"
+//= require "core/framebuffer"

data/src/jax/webgl/core/buffer.js

@@ -0,0 +1,161 @@
+/**
+ * class Jax.Buffer
+ *
+ * Root class of all WebGL buffer objects.
+ *
+ * Wrapper to manage JS and GL buffer (array) types. Automates context juggling by requiring the context to generate the
+ * buffer for as an argument to #bind. If the context doesn't have a corresponding GL buffer for this data, it will be
+ * created. Calling #refresh will regenerate the buffer data for all contexts.
+ *
+ **/
+Jax.Buffer = (function() {
+  function each_gl_buffer(self, func)
+  {
+    for (var id in self.gl)
+      func(self.gl[id].context, self.gl[id].buffer);
+  }
+
+  return Jax.Class.create({
+    initialize: function(bufferType, classType, drawType, jsarr, itemSize) {
+      if (jsarr.length == 0) throw new Error("No elements in array to be buffered!");
+      if (!itemSize) throw new Error("Expected an itemSize - how many JS array elements represent a single buffered element?");
+      this.classType = classType;
+      this.itemSize = itemSize;
+      this.js = jsarr;
+      this.gl = {};
+      this.numItems = this.length = jsarr.length / itemSize;
+      this.bufferType = bufferType;
+      this.drawType = drawType;
+    },
+
+    refresh: function() {
+      var self = this;
+      if (self.classTypeInstance)
+        for (var i = 0; i < self.js.length; i++)
+          self.classTypeInstance[i] = self.js[i];
+      else
+        self.classTypeInstance = new self.classType(self.js);
+
+      self.numItems = self.length = self.js.length / self.itemSize;
+      if (!self.gl) return;
+
+      each_gl_buffer(self, function(context, buffer) {
+        buffer.numItems = buffer.length = self.js.length;
+        context.glBindBuffer(self.bufferType, buffer);
+        context.glBufferData(self.bufferType, self.classTypeInstance, self.drawType);
+      });
+    },
+
+    dispose: function() {
+      var self = this;
+      each_gl_buffer(this, function(context, buffer) {
+        context.glDeleteBuffer(buffer);
+        self.gl[context.id] = null;
+      });
+      self.gl = {};
+    },
+
+    isDisposed: function() { return !this.gl; },
+
+    bind: function(context) { context.glBindBuffer(this.bufferType, this.getGLBuffer(context)); },
+
+    getGLBuffer: function(context)
+    {
+      if (!context || typeof(context.id) == "undefined")
+        throw new Error("Cannot build a buffer without a context!");
+
+      if (!this.gl[context.id])
+      {
+        var buffer = context.glCreateBuffer();
+        buffer.itemSize = this.itemSize;
+        this.gl[context.id] = {context:context,buffer:buffer};
+        this.refresh();
+      }
+      return this.gl[context.id].buffer;
+    }
+  });
+})();
+
+/**
+ * class Jax.ElementArrayBuffer < Jax.Buffer
+ *
+ * A generic Int16 Array. Initialized with a standard JavaScript Array argument.
+ * Its item size is 1, so each element in the array represents a separate datum,
+ *
+ * This type of buffer is commonly used for vertex indices, etc.
+ *
+ * Example:
+ *     var buf = new Jax.ElementArrayBuffer([...]);
+ **/
+Jax.ElementArrayBuffer = Jax.Class.create(Jax.Buffer, {
+  initialize: function($super, jsarr) {
+    $super(GL_ELEMENT_ARRAY_BUFFER, Uint16Array, GL_STREAM_DRAW, jsarr, 1);
+  }
+});
+
+/**
+ * class Jax.FloatArrayBuffer < Jax.Buffer
+ *
+ * A generic Float Array. Initialized with a standard JavaScript Array argument,
+ * and an item size. As the item size represents how many array elements represent
+ * a single datum, the array must be divisible by this number.
+ *
+ * Unless you're implementing something Jax does not support by default, you're
+ * most likely looking for one of the subclasses of Jax.FloatArrayBuffer.
+ *
+ * Example:
+ *     var buf = new Jax.FloatArrayBuffer([...], 3);
+ **/
+Jax.FloatArrayBuffer = Jax.Class.create(Jax.Buffer, {
+  initialize: function($super, jsarr, itemSize) {
+    $super(GL_ARRAY_BUFFER, Float32Array, GL_STATIC_DRAW, jsarr, itemSize);
+  }
+});
+
+/**
+ * class Jax.VertexBuffer < Jax.FloatArrayBuffer
+ *
+ * Initialized with a standard JavaScript Array argument.
+ *
+ * Example:
+ *     var buf = new Jax.VertexBuffer([...]);
+ **/
+Jax.VertexBuffer = Jax.Class.create(Jax.FloatArrayBuffer, {
+  initialize: function($super, jsarr) { $super(jsarr, 3); }
+});
+
+/**
+ * class Jax.ColorBuffer < Jax.FloatArrayBuffer
+ *
+ * Initialized with a standard JavaScript Array argument.
+ *
+ * Example:
+ *     var buf = new Jax.ColorBuffer([...]);
+ **/
+Jax.ColorBuffer = Jax.Class.create(Jax.FloatArrayBuffer, {
+  initialize: function($super, jsarr) { $super(jsarr, 4); }
+});
+
+/**
+ * class Jax.TextureCoordsBuffer < Jax.FloatArrayBuffer
+ *
+ * Initialized with a standard JavaScript Array argument.
+ *
+ * Example:
+ *     var buf = new Jax.TextureCoordsBuffer([...]);
+ **/
+Jax.TextureCoordsBuffer = Jax.Class.create(Jax.FloatArrayBuffer, {
+  initialize: function($super, jsarr) { $super(jsarr, 2); }
+});
+
+/**
+ * class Jax.NormalBuffer < Jax.FloatArrayBuffer
+ *
+ * Initialized with a standard JavaScript Array argument.
+ *
+ * Example:
+ *     var buf = new Jax.NormalBuffer([...]);
+ **/
+Jax.NormalBuffer = Jax.Class.create(Jax.FloatArrayBuffer, {
+  initialize: function($super, jsarr) { $super(jsarr, 3); }
+});

data/src/jax/webgl/core/edge.js

@@ -0,0 +1,6 @@
+Jax.Core.Edge = Jax.Class.create({
+  initialize: function() {
+    this.faceIndices = [];
+    this.vertexIndices = [];
+  }
+});

data/src/jax/webgl/core/events.js

@@ -0,0 +1,25 @@
+Jax.Events = (function() {
+  return {
+    Methods: {
+      getEventListeners: function(name) {
+        this.event_listeners = this.event_listeners || {};
+        return this.event_listeners[name] = this.event_listeners[name] || [];
+      },
+      
+      addEventListener: function(name, callback) {
+        this.getEventListeners(name).push(callback);
+        return this.getEventListeners(name).length - 1;
+      },
+      
+      removeEventListener: function(name, index) {
+        this.getEventListeners(name).splice(index, 1);
+      },
+      
+      fireEvent: function(name, event_object) {
+        var listeners = this.getEventListeners(name);
+        for (var i = 0; i < listeners.length; i++)
+          listeners[i].call(this, event_object);
+      }
+    }
+  };
+})();

data/src/jax/webgl/core/face.js

@@ -0,0 +1,8 @@
+Jax.Core.Face = Jax.Class.create({
+  initialize: function(vertexIndices) {
+    if (arguments.length > 1)
+      this.vertexIndices = vec3.create(arguments);
+    else if (vertexIndices)
+      this.vertexIndices = vec3.create(vertexIndices);
+  }
+});

data/src/jax/webgl/core/framebuffer.js

@@ -0,0 +1,206 @@
+Jax.Framebuffer = (function() {
+  function build(context, self) {
+    var handle = context.glCreateFramebuffer();
+    var width = self.options.width, height = self.options.height;
+
+    self.setHandle(context, handle);
+    context.glBindFramebuffer(GL_FRAMEBUFFER, handle);
+
+    // depth and stencil attachment
+    if (self.options.depth && self.options.stencil) {
+      handle.depthstencilbuffer = context.glCreateRenderbuffer();
+      context.glBindRenderbuffer(GL_RENDERBUFFER, handle.depthstencilbuffer);
+      context.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, width, height);
+      context.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, handle.depthstencilbuffer);
+      context.glBindRenderbuffer(GL_RENDERBUFFER, null);
+    }
+    
+    // depth attachment
+    if (self.options.depth && !self.options.stencil) {
+      handle.depthbuffer = context.glCreateRenderbuffer();
+      context.glBindRenderbuffer(GL_RENDERBUFFER, handle.depthbuffer);
+      context.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
+      context.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, handle.depthbuffer);
+      context.glBindRenderbuffer(GL_RENDERBUFFER, null);
+    }
+    
+    // stencil attachment
+    if (self.options.stencil && !self.options.depth) {
+      handle.stencilbuffer = context.glCreateRenderbuffer();
+      context.glBindRenderbuffer(GL_RENDERBUFFER, handle.stencilbuffer);
+      context.glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);
+      context.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, handle.stencilbuffer);
+      context.glBindRenderbuffer(GL_RENDERBUFFER, null);
+    }
+    
+    // texture attachments
+    handle.textures = [];
+    var attachment = GL_COLOR_ATTACHMENT0;
+    for (var i = 0; i < self.options.colors.length; i++) {
+      var format = self.options.colors[i];
+      var texture_options = {
+        format:GL_RGBA,
+        width:width,
+        height:height,
+        min_filter:GL_LINEAR,
+        mag_filter:GL_LINEAR,
+        wrap_s:GL_CLAMP_TO_EDGE,
+        wrap_t:GL_CLAMP_TO_EDGE,
+        generate_mipmap:false
+      };
+      if (typeof(format) != "number") { texture_options = Jax.Util.normalizeOptions(format, texture_options); }
+      else { texture_options.format = format; }
+      handle.textures[i] = new Jax.Texture(texture_options);
+      
+      if (handle.textures[i].getTarget() == GL_TEXTURE_2D)
+        context.glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_2D, handle.textures[i].getHandle(context), 0);
+      else
+        context.glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+                handle.textures[i].getHandle(context), 0);
+      
+      attachment++;
+    }
+
+    checkStatus(context, self);
+  }
+  
+  function checkStatus(context, self) {
+    var status = context.glCheckFramebufferStatus(GL_FRAMEBUFFER);
+    self.unbind(context);
+    switch(status) {
+      case GL_FRAMEBUFFER_COMPLETE:
+        // success!
+        break;
+      case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+        throw new Error("Jax.Framebuffer: one or more attachments is incomplete. (GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT)");
+      case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+        throw new Error("Jax.Framebuffer: there are no images attached to the framebuffer. (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT)");
+      case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+        throw new Error("Jax.Framebuffer: all attachments must have the same dimensions. (GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS)");
+      case GL_FRAMEBUFFER_UNSUPPORTED:
+        throw new Error("Jax.Framebuffer: the requested framebuffer layout is unsupported on this hardware. (GL_FRAMEBUFFER_UNSUPPORTED)");
+      case (window['GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER'] || 0x8cdb):
+        // a cryptic error that is not in the WebGL spec. Took me way too long to figure this out and I'm still not
+        // sure why it happens...
+        // but it seems to crop up primarily when no textures are attached.
+        // from opengl (not webgl) spec: The value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT must not be NONE for any
+        // color attachment point(s) named by DRAW_BUFFER.
+        throw new Error("Jax.Framebuffer: make sure the framebuffer has at least 1 texture attachment. (GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER)");
+      default:
+        var which;
+        for (which in context.gl)
+          if (context.gl[which] == status)
+            throw new Error("Jax.Framebuffer: an unknown error occurred. ("+status+" - "+which+")");
+        throw new Error("Jax.Framebuffer: an unknown error occurred. ("+status+")");
+    }
+  }
+  
+  return Jax.Class.create({
+    /**
+     * new Jax.Framebuffer([options])
+     * - options (Object): a generic object containing the following optional properties:
+     * 
+     *   * colors: an array of color formats such as GL_RGBA, GL_RGB, etc. The _colors_ array may
+     *             be empty if no color attachments are needed. Defaults to [GL_RGBA] unless _color_
+     *             is specified.
+     *             
+     *             Alternatively, an options object can be used. This object will be passed into
+     *             Jax.Texture().
+     *             
+     *   * color: optionally, in place of a colors array, a single color format as above. If both
+     *            _color_ and _colors_ are specified, _color_ is simply added to the _colors_ array.
+     *   * depth: true if a depth attachment is required, false otherwise.
+     *   * stencil: true if a stencil attachment is required, false otherwise.
+     *   * width: the width of the render and color buffers. All render and color buffers for a given
+     *            framebuffer must have the same width. Defaults to 2048.
+     *   * height: the height of the render and color buffers. All render and color buffers for a given
+     *             framebuffer must have the same height. Defaults to 2048.
+     *     
+     **/
+    initialize: function(options) {
+      var defaults = {
+        depth: false,
+        stencil: false,
+        width:512,
+        height:512
+      };
+      if (!(options && (options.color || options.colors))) defaults.colors = [GL_RGBA];
+      
+      this.handles = {};
+      this.options = options = Jax.Util.normalizeOptions(options, defaults);
+      if (options.color != undefined) {
+        if (options.colors != undefined) options.colors.push(options.color);
+        else options.colors = [options.color];
+        delete options.color;
+      }
+    },
+
+    /**
+     * Jax.Framebuffer#cubeFace(context, texIndex, faceEnum[, callback]) -> Jax.Framebuffer
+     * - context (Jax.Context): a Jax context
+     * - texIndex (number): the index of the cube map texture
+     * - faceEnum (enum): the cube map face to bind
+     * - callback (function): an optional callback. If given, the framebuffer will be automatically unbound
+     *                        after the callback returns. Otherwise, the framebuffer will remain bound.
+     *                        
+     * For cube map framebuffers only, this will bind the specified cube map face to its color buffer position.
+     * The faceEnum can be any of the following face enums:
+     * 
+     *     0: GL_TEXTURE_CUBE_MAP_POSITIVE_X
+     *     1: GL_TEXTURE_CUBE_MAP_NEGATIVE_X
+     *     2: GL_TEXTURE_CUBE_MAP_POSITIVE_Y
+     *     3: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
+     *     4: GL_TEXTURE_CUBE_MAP_POSITIVE_Z
+     *     5: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+     * 
+     * Example:
+     * 
+     *     fb.bindCubeFace(context, 0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, function() {
+     *       // render to +X cube face
+     *     });
+     *     fb.bindCubeFace(context, 0, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, function() {
+     *       // render to -Z cube face
+     *     });
+     **/
+    bindCubeFace: function(context, texIndex, faceEnum, callback) {
+      if (!this.getHandle(context)) build(context, this);
+      var texture = this.getHandle(context).textures[texIndex];
+      if (texture.options.target != GL_TEXTURE_CUBE_MAP)
+        throw new Error("Texture at index "+texIndex+" is not a cube map!");
+      
+      this.bind(context);
+      context.glFramebufferTexture2D(GL_FRAMEBUFFER, window['GL_COLOR_ATTACHMENT'+texIndex],
+              faceEnum, texture.getHandle(context), 0);
+      
+      if (callback) {
+        callback();
+        this.unbind(context);
+      }
+    },
+    
+    bind: function(context, callback) {
+      if (!this.getHandle(context)) build(context, this);
+      context.glBindFramebuffer(GL_FRAMEBUFFER, this.getHandle(context));
+      
+      
+      if (callback) {
+        callback.call(this);
+        this.unbind(context);
+      }
+    },
+    
+    unbind: function(context) {            
+      context.glBindFramebuffer(GL_FRAMEBUFFER, null);
+    },
+    
+    viewport: function(context) {
+      context.glViewport(0,0,this.options.width,this.options.height);
+    },
+    
+    getTextureBuffer: function(context, index) { return this.getHandle(context) && this.getHandle(context).textures[index]; },
+    getTextureBufferHandle: function(context, index) { return this.getTextureBuffer().getHandle(context); },
+    
+    getHandle: function(context) { return this.handles[context.id]; },
+    setHandle: function(context, handle) { this.handles[context.id] = handle; }
+  });
+})();

data/src/jax/webgl/material.js

@@ -0,0 +1,375 @@
+//= require "shader"
+
+/**
+ * class Jax.Material
+ * 
+ * Represents a single material, which has its own color, lighting and texture properties.
+ * 
+ * Example:
+ * 
+ *     var material = new Jax.Material({ shininess: 1,
+ *                                       diffuse:  [0.8, 0.8, 0.8, 1.0],
+ *                                       ambient:  [0.8, 0.8, 0.8, 1.0],
+ *                                       specular: [1.0, 1.0, 1.0, 1.0],
+ *                                       emissive: [0.0, 0.0, 0.0, 1.0]
+ *                                     });
+ *                                     
+ * IMPORTANT: Note that shaders are no longer directly tied to a given Material. Instead, the shader
+ * should be specified as a property (or render option) of the mesh to be rendered. In most cases,
+ * however, the appropriate shader will be determined automatically by Jax.
+ **/
+Jax.Material = (function() {
+  function updatePrevious(self) {
+    self.previous = self.previous || {subshaders:[]};
+    for (var i = 0; i < self.layers.length; i++)
+      self.previous.subshaders[i] = self.layers[i].getName();
+  }
+  
+  function instantiate_layer(options) {
+    if (options.isKindOf && options.isKindOf(Jax.Material))
+      return options;
+    else {
+      if (options.type) {
+        var klass = Jax.Material[options.type];
+        if (!klass) throw new Error("Could not find material layer type: "+options.type);
+        delete options.type;
+        return new klass(options);
+      }
+      else
+        throw new Error("Could not create layer: property 'type' was missing!");
+    }
+  }
+  
+  return Jax.Class.create({
+    initialize: function(options) {
+      options = Jax.Util.normalizeOptions(options, {
+        ambient: [1,1,1,1],
+        diffuse: [1,1,1,1],
+        specular:[1,1,1,1],
+        emissive: [0, 0, 0, 1.0],
+        shininess: 10,
+        default_shader: Jax.default_shader
+      });
+      options.ambient = Jax.Util.colorize(options.ambient);
+      options.diffuse = Jax.Util.colorize(options.diffuse);
+      options.specular = Jax.Util.colorize(options.specular);
+      options.emissive = Jax.Util.colorize(options.emissive);
+
+      for (var i in options) { this[i] = options[i]; }
+      this.option_properties = Jax.Util.properties(options);
+      this.protected_properties = ['name', 'shader', 'default_shader', 'shaders', 'layers'];
+      
+      this.name = options.name || options.shader || options.default_shader;
+      this.shaders = {};
+      this.layers = [];
+
+      var tex;
+      if (options.texture) {
+        tex = new Jax.Texture(options.texture);
+        this.addTextureLayer(tex);
+        delete options.texture;
+      } else if (options.textures) {
+        for (i = 0; i < options.textures.length; i++) {
+          tex = new Jax.Texture(options.textures[i]);
+          this.addTextureLayer(tex);
+        }
+        delete options.textures;
+      }
+      
+      if (options.layers) {
+        for (i = 0; i < options.layers.length; i++) {
+          this.addLayer(instantiate_layer(options.layers[i]));
+        }
+      }
+    },
+    
+    getName: function() { return this.name; },
+    
+    addTextureLayer: function(tex) {
+      var mat;
+      switch(tex.options.type) {
+        case Jax.NORMAL_MAP:
+          mat = new Jax.Material.NormalMap(tex);
+          break;
+        default:
+          mat = new Jax.Material.Texture(tex);
+      }
+      this.addLayer(mat);
+    },
+    
+    addLayer: function(layer) {
+      if (!layer.option_properties) layer = instantiate_layer(layer);
+      this.layers.push(layer);
+
+      for (var i = 0; i < layer.option_properties.length; i++) {
+        var name = layer.option_properties[i];
+        if (this.protected_properties.indexOf(name) == -1 && this[name] == undefined) {
+          this[name] = layer[name];
+        }
+      }
+    },
+
+    /**
+     * Jax.Material#buildShader(name) -> Jax.Shader
+     * 
+     * Forces a rebuild of the specified shader. If the shader doesn't exist, one will be instantiated.
+     * Note that this doesn't result in an immediate recompile (as that would require a Jax.Context).
+     * Instead, it schedules the rebuild for the next render pass, when the Jax.Context is readily
+     * available.
+     **/
+    buildShader: function() {
+      if (this.shaderChain)
+        this.shaderChain.removeAllShaders();
+      else
+        this.shaderChain = new Jax.ShaderChain(this.getName());
+      
+      this.addShadersToChain(this.shaderChain);
+
+      return this.shaderChain;
+    },
+    
+    addShadersToChain: function(chain) {
+      this.shader_variable_prefix = chain.addShader(this.getBaseShader());
+      for (var i = 0; i < this.layers.length; i++)
+        this.layers[i].addShadersToChain(chain);
+    },
+    
+    getBaseShader: function() {
+      return (this.shader || this.default_shader);
+    },
+    
+    /**
+     * Jax.Material#updateModifiedShaders() -> self
+     * 
+     * If this Material has been modified, all shaders attached to it will be rebuilt.
+     **/
+    updateModifiedShaders: function() {
+      if (this.isChanged()) {
+        this.buildShader();
+        updatePrevious(this);
+      }
+      return this;
+    },
+
+    /**
+     * Jax.Material#prepareShader(name) -> Jax.Shader
+     * 
+     * Prepares the specified shader for rendering. If this Material has been modified,
+     * then all related shaders are updated. The specified shader is either built or returned,
+     * depending on whether it has already been built.
+     **/
+    prepareShader: function() {
+      var shader;
+      
+      if (this.shaderChain) shader = this.shaderChain;
+      else shader = this.buildShader();
+      
+      this.updateModifiedShaders();
+      return shader;
+    },
+    
+    setUniforms: function(context, mesh, options, uniforms) {},
+    setAttributes: function(context, mesh, options, attributes) { },
+    
+    setShaderVariables: function(context, mesh, options, manifest) {
+      manifest.variable_prefix = this.shader_variable_prefix;
+
+      manifest.set({
+        mMatrix: context.getModelMatrix(),
+        vnMatrix: mat3.transpose(mat4.toMat3(context.getViewMatrix())),
+        ivMatrix:  context.getInverseViewMatrix(),
+        vMatrix:   context.getViewMatrix(),
+        mvMatrix:  context.getModelViewMatrix(),
+        pMatrix:   context.getProjectionMatrix(),
+        nMatrix:   context.getNormalMatrix(),
+        
+        PASS_TYPE: context.current_pass,
+        
+        materialAmbient: this.ambient,
+        materialDiffuse: this.diffuse,
+        materialSpecular: this.specular,
+        materialShininess: this.shininess
+      });
+      manifest.set('VERTEX_POSITION',  mesh.getVertexBuffer() || null);
+      manifest.set('VERTEX_COLOR',     mesh.getColorBuffer() || null);
+      manifest.set('VERTEX_NORMAL',    mesh.getNormalBuffer() || null);
+      manifest.set('VERTEX_TEXCOORDS', mesh.getTextureCoordsBuffer() || null);
+
+      
+      this.setUniforms(context, mesh, options, manifest);
+      this.setAttributes(context, mesh, options, manifest);
+
+      for (var i = 0; i < this.layers.length; i++) {
+        manifest.variable_prefix = this.layers[i].shader_variable_prefix;
+        this.layers[i].setUniforms(context, mesh, options, manifest);
+        this.layers[i].setAttributes(context, mesh, options, manifest);
+      }
+    },
+    
+    /**
+     * Jax.Material#render(context, mesh) -> undefined
+     * Renders the specified object to the specified context, using this material.
+     *
+     * This action will build and compile the shader for the given context if necessary.
+     **/
+    render: function(context, mesh, options) {
+      this.lights = context.world.lighting._lights;
+      this.light_count = context.world.lighting._lights.length;
+      
+      try {
+        var shader = this.prepareShader(context);
+        
+        shader.render(context, mesh, this, options);
+      } catch(error) {
+        if (error instanceof RangeError) {
+          // we've hit hardware limits. Back off a layer. If we are down to no layers, raise a coherent error.
+          if (this.layers.length > 0) {
+            this.adaptShaderToHardwareLimits(shader, error);
+            this.render(context, mesh, options);
+          }
+          else throw error;
+        }
+        else throw error;
+      }
+    },
+    
+    adaptShaderToHardwareLimits: function(shader, error) {
+      function log(msg) {
+        if (window.console)
+          console.log(msg);
+        else
+          setTimeout(function() { throw new Error(msg); }, 1);
+      }
+            
+      log("WARNING: Hardware limits reached for material '"+this.getName()+"'! (original message: "+error+")");
+      
+      /*
+        choose which shader(s) to remove. We know off the bat that we can remove any shaders which would
+        push us over the threshold on their own (e.g. not combined with any except 'basic'), so let's remove
+        those first.
+      */
+      
+      var map = shader.getPerShaderInputMap(this);
+      
+      var uniformsRemaining = Jax.Shader.max_uniforms - map[this.getBaseShader()].uniforms.length;
+      var varyingsRemaining = Jax.Shader.max_varyings - map[this.getBaseShader()].varyings.length;
+      var attributesRemaining = Jax.Shader.max_attributes - map[this.getBaseShader()].attributes.length;
+      
+      // we'll use these to determine if we *still* need to pop at the end.
+      var totalUniformsInUse = 0, totalVaryingsInUse = 0, totalAttributesInUse = 0;
+      
+      for (var i = 0; i < this.layers.length; i++) {
+        var entry = map[this.layers[i].getBaseShader()];
+
+        if (entry.uniforms.length > uniformsRemaining || entry.varyings.length > varyingsRemaining ||
+                entry.attributes.length > attributesRemaining)
+        {
+          log("WARNING: Removing shader '"+this.layers[i].getName()+"' due to hardware limitations!");
+          this.layers.splice(i, 1);
+          i = 0;
+        } else {
+          totalUniformsInUse += entry.uniforms.length;
+          totalVaryingsInUse += entry.varyings.length;
+          totalAttributesInUse += entry.attributes.length;
+        }
+      }
+      
+      if (totalUniformsInUse > uniformsRemaining || totalVaryingsInUse > varyingsRemaining ||
+              totalAttributesInUse > attributesRemaining)
+      {
+        log("WARNING: Removing shader '"+this.layers[this.layers.length-1].getName()+"' due to hardware limitations!");
+        this.layers.pop();
+      }
+    },
+    
+    /**
+     * Jax.Material#isChanged() -> Boolean
+     * Returns true if this material's properties have been changed since
+     * the last time its internal shader was compiled.
+     **/
+    isChanged: function() {
+      if (!this.previous) return true;
+
+      if (this.previous.subshaders.length != this.layers.length) return true;
+      
+      for (var i = 0; i < this.layers.length; i++)
+        if (this.previous.subshaders[i] != this.layers[i].getName())
+          return true;
+
+      return false;
+    }
+  });
+})();
+
+Jax.Material.instances = {};
+
+/**
+ * Jax.Material.find(name) -> Jax.Material
+ * - name (String): the unique name of the material you're looking for
+ * 
+ * Returns the instance of Jax.Material matching the specified name, or throws
+ * an error if the material can't be found.
+ **/
+Jax.Material.find = function(name) {
+  var result;
+  if (result = Jax.Material.instances[name])
+    return result;
+  throw new Error("Material {material:'"+name+"'} could not be found.");
+};
+
+/**
+ * Jax.Material.create(name, options) -> Jax.Material
+ * - name (String): the unique name of this material
+ * - options (Object): a set of options to be passed to the material constructor
+ * 
+ * Creates a material and adds it to the material registry. This way,
+ * the material can be later retrieved using:
+ * 
+ *     var matr = Jax.Material.find(name);
+ *     
+ * Note that unlike instances of Jax.Model, specifying a name for a material that
+ * already exists will not raise an error. Instead, the previous material will be
+ * replaced with a new material constructed using the new options. This allows you
+ * to override Jax defaults like so:
+ * 
+ *     Jax.Material.create("default", {...});
+ *     
+ **/
+Jax.Material.create = function(name, options) {
+  options = Jax.Util.normalizeOptions(options, { name: name });
+  
+  var klass = Jax.Material;
+  if (options.type) klass = klass[options.type];
+  
+  if (!klass) throw new Error("Material type '"+options.type+"' not found!");
+  return Jax.Material.instances[name] = new klass(options);
+};
+
+/**
+ * Jax.Material.all() -> Array
+ * 
+ * Returns an array containing the names of all Materials currently registered
+ * with Jax. Note that this does not include one-off materials created directly,
+ * for example, using "new Jax.Material()".
+ **/
+Jax.Material.all = function() {
+  return Jax.Util.properties(Jax.Material.instances);
+};
+
+Jax.Material.addResources = function(resources) {
+  for (var i in resources) {
+    if (Jax.Material.instances[i]) throw new Error("Duplicate material resource ID: "+i);
+    Jax.Material.create(i, resources[i]);
+  }
+};
+
+//= require "../../../builtin/shaders/texture/material"
+//= require "../../../builtin/shaders/normal_map/material"
+//= require "../../../builtin/shaders/shadow_map/material"
+//= require "../../../builtin/shaders/paraboloid-depthmap/material"
+//= require "../../../builtin/shaders/fog/material"
+
+Jax.Material.create("basic");
+Jax.Material.create("default", {default_shader:'basic'});
+Jax.Material.create("depthmap", {default_shader:"depthmap"});
+Jax.Material.create("paraboloid-depthmap", {type:"DualParaboloid",default_shader:"paraboloid-depthmap"});