jax 0.0.0.1

data/src/jax/webgl/scene/light_manager.js

@@ -0,0 +1,112 @@
+//= require "light_source"
+
+Jax.Scene.LightManager = (function() {
+  return Jax.Class.create({
+    initialize: function(context) {
+      this.context = context;
+      this._lights = [];
+    },
+    
+    add: function(light) {
+      if (this._lights.length == Jax.max_lights)
+        throw new Error("Maximum number of light sources in a scene has been exceeded! Try removing some first.");
+      this._lights.push(light);
+    },
+    
+    enable: function() { this.enabled = true; },
+    
+    disable: function() { this.enabled = false; },
+    
+    isEnabled: function() {
+      if (arguments.length == 1) {
+        if (this._lights.length > arguments[0])
+          return this._lights[arguments[0]].isEnabled();
+        return false;
+      }
+      
+      if (this.enabled != undefined)
+        return this.enabled;
+      return this._lights.length > 0;
+    },
+    
+    count: function() { return this._lights.length; },
+    
+    remove: function(index) {
+      var result = this._lights.splice(index, 1);
+      if (this._lights.length == 0) delete this.enabled;
+      return result;
+    },
+    
+    illuminate: function(context, objects, options) {
+      for (var i = 0; i < this._lights.length; i++) {
+        this._current_light = i;
+        for (var j = 0; j < objects.length; j++) {
+          /* TODO optimization: see if objects[j] is even affected by this._lights[i] (based on attenuation) */
+          if (objects[j].isLit())
+            objects[j].render(context, options);
+        }
+      }
+      delete this._current_light;
+    },
+    
+    ambient: function(context, objects, options) {
+      for (var i = 0; i < this._lights.length; i++) {
+        this._current_light = i;
+        for (var j = 0; j < objects.length; j++) {
+          /* TODO optimization: see if objects[j] is even affected by this._lights[i] (based on attenuation) */
+          if (objects[j].isLit())
+            objects[j].render(context, options);
+        }
+      }
+      delete this._current_light;
+    },
+    
+    updateShadowMaps: function(context, objects) {
+      var boundingRadius = null;
+      var i, j;
+      for (i = 0; i < objects.length; i++) {
+        j = vec3.length(objects[i].camera.getPosition()) + objects[i].getBoundingSphereRadius();
+        if (boundingRadius == null || boundingRadius < j)
+          boundingRadius = j;
+      }
+      boundingRadius = boundingRadius || 0;
+      
+//      context.glPolygonOffset(1.1, 4.0);
+//      context.glPolygonOffset(2,2);
+//      context.glEnable(GL_POLYGON_OFFSET_FILL);
+      for (i = 0; i < this._lights.length; i++)
+        this._lights[i].updateShadowMap(context, boundingRadius, objects);
+//      context.glDisable(GL_POLYGON_OFFSET_FILL);
+//      context.glPolygonOffset(0.0, 0.0);
+    },
+    
+    getDirection: function(index) { return this.getLight(index).getDirection(); },
+    
+    getPosition: function(index) { return this.getLight(index).getPosition(); },
+    
+    getLight: function(index) {
+      if (index == undefined)
+        if (this._current_light != undefined) return this._lights[this._current_light];
+        else return (this.default_light = this.default_light || new Jax.Scene.LightSource());
+      return this._lights[index];
+    },
+    
+    getType: function(index) { return this.getLight(index).getType(); },
+    
+    getDiffuseColor: function(index) { return this.getLight(index).getDiffuseColor(); },
+    
+    getSpecularColor: function(index) { return this.getLight(index).getSpecularColor(); },
+    
+    getAmbientColor: function(index) { return this.getLight(index).getAmbientColor(); },
+    
+    getConstantAttenuation: function(index) { return this.getLight(index).getConstantAttenuation(); },
+    
+    getLinearAttenuation: function(index) { return this.getLight(index).getLinearAttenuation(); },
+                                                                                                                                  
+    getQuadraticAttenuation: function(index) { return this.getLight(index).getQuadraticAttenuation(); },
+    
+    getSpotCosCutoff: function(index) { return this.getLight(index).getSpotCosCutoff(); },
+    
+    getSpotExponent: function(index) { return this.getLight(index).getSpotExponent(); }
+  });
+})();

data/src/jax/webgl/scene/light_source.js

@@ -0,0 +1,248 @@
+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);
+
+      this.spotExponent = this.spot_exponent;
+      delete this.spot_exponent;
+
+      this.shadowMatrix = mat4.create();
+      
+      this.framebuffers = [new Jax.Framebuffer({width:2048,height:2048,depth:true,color:GL_RGBA}),
+                           new Jax.Framebuffer({width:2048,height:2048,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].getTextureBuffer(context, 0);
+//      return this.framebuffers[0].getTextureBufferHandle(context, 0);
+    },
+    
+    getShadowMapTextures: function(context) {
+      setupProjection(this);
+      return [this.framebuffers[0].getTextureBuffer(context, 0),
+              this.framebuffers[1].getTextureBuffer(context, 0)];
+//      return [this.framebuffers[0].getTextureBufferHandle(context, 0),
+//              this.framebuffers[1].getTextureBufferHandle(context, 0)];
+    },
+    
+    isShadowMapEnabled: function() {
+      return !!(this.framebuffers && this.isShadowcaster());
+    },
+    
+    getShadowMatrix: function() {
+      return this.shadowMatrix;
+    },
+    
+    isShadowcaster: function() { return this.shadowcaster; },
+    
+    getDPShadowNear: function() { setupProjection(this); return this.camera.projection.near; },
+    
+    getDPShadowFar: function() { setupProjection(this); return this.camera.projection.far; },
+    
+    updateShadowMap: function(context, sceneBoundingRadius, objects) {
+      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) {
+        
+        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() {
+          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.getModelViewMatrix());
+            mat4.set(context.getInverseViewMatrix(), sm);
+            
+            for (var i = 0; i < objects.length; i++) {
+              objects[i].render(context, {material:'paraboloid-depthmap', 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.getModelViewMatrix());
+            for (var i = 0; i < objects.length; i++) {
+              objects[i].render(context, {material:'paraboloid-depthmap',direction:-1});
+            }
+          });
+  
+          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;
+      }
+      
+      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.getModelViewMatrix());
+          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, {material:'depthmap'});
+          }
+          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/src/jax/webgl/shader.js

@@ -0,0 +1,282 @@
+Jax.Shader = (function() {
+  function buildStackTrace(context, glShader, source) {
+    source = source.split(/\n/);
+    var log = context.glGetShaderInfoLog(glShader).split(/\n/);
+    
+    /* build a detailed backtrace with error information so devs can actually find the error */
+    var current = 1, injected = [], li;
+    function strToInject() { return current+" : "+source[current-1]; }
+    for (li = 0; li < log.length; li++) {
+      var line = log[li];
+      var match = /0:(\d+):(.*)/.exec(line);
+      if (!match) continue; // blank line
+      var line_number = parseInt(match[1]);
+      if (line_number > current)
+        for (; current < line_number; current++)
+          injected.push(strToInject());
+      if (line_number == current) {
+        injected.push(strToInject());
+        injected.push(":: ERROR : "+match[2]); /* error message */
+      }
+      current = line_number+1;
+    }
+    
+    /* prepend a summary so user can debug simple errors at a glance */
+    injected.unshift("");
+    for (li = log.length-1; li >= 0; li--)
+      injected.unshift(log[li]);
+        
+    /* finally, add 3 more lines so the user has an easier time finding the problem in ambiguous code */
+    li = current;
+    for (current = li; current < li+3; current++)
+      injected.push(strToInject());
+        
+    return injected.join("\n");
+  }
+  
+  function compile(context, shader, source) {
+    context.glShaderSource(shader, source);
+    shader.source = source;
+    context.glCompileShader(shader);
+    if (!context.glGetShaderParameter(shader, GL_COMPILE_STATUS))
+      throw new Error(buildStackTrace(context, shader, source));
+  }
+  
+  function sanitizeName(name) {
+    return name.replace(/-/, '_');
+  }
+  
+  function getExportedVariableName(exportPrefix, name) {
+    return sanitizeName("_"+exportPrefix+"_"+name);
+  }
+  
+  /*
+    preprocess shader source code to replace "import(varname, expression)" with the globalized varname if it's been
+    exported (as an attribute of material.exports || self.options.exports), or expression if it hasn't.
+   */
+  function applyImports(self, options, source) {
+    var rx = /import\((.*?),\s*(.*?)\)/, result;
+    var exp;
+    while (result = rx.exec(source)) {
+      var name = result[1];
+      if (options && (exp = (options.exports && options.exports[name]) || (self.options.exports && self.options.exports[name]))) {
+        var exportedVariableName = getExportedVariableName(options.export_prefix || self.getName(), name);
+        source = source.replace(result[0], result[2].replace(new RegExp(name, "g"), exportedVariableName));
+      }
+      else source = source.replace(result[0], "");
+    }
+    return source;
+  }
+  
+  function applyExports(self, options, source) {
+    var rx = /export\((.*?),\s*(.*?)(,\s*(.*?))?\)/, result;
+    // rx should match both 'export(vec4, ambient)' and 'export(vec4, ambient, ambient)'
+    var replacement, name, type, assignment;
+    while (result = rx.exec(source)) {
+      type = result[1];
+      name = result[2];
+      assignment = result[4] || null;
+      replacement = getExportedVariableName(options && options.export_prefix || self.getName(), name)+" = ";
+      if (assignment) replacement += assignment;
+      else replacement += name;
+      source = source.replace(result[0], replacement);
+    }
+    return source;
+  }
+  
+  function mangleUniformsAndAttributes(self, material, source) {
+    var map = self.getInputMap(material);
+    for (var name in map)
+      source = source.replace(new RegExp("(^|[^a-zA-Z0-9])"+name+"([^a-zA-Z0-9]|$)", "g"), "$1"+map[name].full_name+"$2");
+    
+    // remove the "shared" directive
+    return source.replace(/(^|[^\w])shared\s+/g, "$1");
+  }
+  
+  function stripSharedDefinitions(self, options, source) {
+    var map = self.getInputMap(options);
+    for (var i in map) {
+      if (map[i].shared) {
+        if (options.skip_global_definitions && options.skip_global_definitions.indexOf(map[i].full_name) != -1) {
+          var rx = new RegExp("(shared\\s+)?"+map[i].scope+"\\s*"+map[i].type+"[^;]*?"+map[i].full_name+"[^;]*?;\n?", "g");
+          source = source.replace(rx, "");
+        }
+//        else source = source.replace(rx, map[i].scope+" "+map[i].type+" "+map[i].full_name+";\n");
+      }
+    }
+    return source.replace(/shared\s+/, '');
+  }
+  
+  /* TODO separate preprocessing from shader and friends; perhaps a Jax.Shader.Preprocessor class? */
+  function preprocess(self, options, source, isVertex) {
+    source = stripSharedDefinitions(self, options, source);
+//    source = source.replace(/^\s*(shared\s+|)(uniform|attribute|varying)([^;]*)?;\n?/, '');
+//    if (!options || !options.skip_global_definitions)
+//      source = self.getGlobalDefinitions(options, isVertex) + source;
+    source = applyExports(self, options, source);
+    source = applyImports(self, options, source);
+    source = mangleUniformsAndAttributes(self, options, source);
+    return source;
+  }
+  
+  function numArgumentsInMain(source) {
+    var result = /void\s*main\((.*?)\)\s*\{/.exec(source);
+    if (result) {
+      result = result[1].replace(/\s*/g, '');
+      if (result == "" || result == "void") return 0;
+      else return result[1].split(/,/).length;
+    }
+    else throw new Error("Could not find main() function in source!\n\n"+source);
+  }
+  
+  return Jax.Class.create({
+    initialize: function(obj) {
+      this.options = obj;
+      
+      if (obj.vertex)   this.setRawSource(obj.vertex,   'vertex');
+      if (obj.fragment) this.setRawSource(obj.fragment, 'fragment');
+      if (obj.common)   this.setRawSource(obj.common,   'common');
+      
+      this.shaders = { vertex: {}, fragment: {} };
+    },
+    
+    getName: function() { return this.options.name; },
+    
+    getVertexShader: function(context) {
+      if (!this.options.vertex) return null;
+      this.shaders.vertex[context.id] = this.shaders.vertex[context.id] || context.glCreateShader(GL_VERTEX_SHADER);
+      return this.shaders.vertex[context.id];
+    },
+    
+    getFragmentShader: function(context) {
+      if (!this.options.fragment) return null;
+      this.shaders.fragment[context.id] = this.shaders.fragment[context.id] || context.glCreateShader(GL_FRAGMENT_SHADER);
+      return this.shaders.fragment[context.id];
+    },
+    
+    getCommonSource: function(material) {
+      return this.options.common ? this.options.common.render(material) : "";
+    },
+    
+    getVertexSource: function(material) {
+      var source = this.getRawSource(material, 'vertex');
+      return source && preprocess(this, material, source, true);
+    },
+    
+    getPreamble: function(options) {
+      return options && options.ignore_es_precision ? "" : "#ifdef GL_ES\nprecision highp float;\n#endif\n";
+    },
+    
+    getFragmentSource: function(material) {
+      var source = this.getRawSource(material, 'fragment');
+      return source && preprocess(this, material, source, false);
+    },
+    
+    getVertexArgumentCount: function(options) {
+      var source = this.getVertexSource(options);
+      return numArgumentsInMain(source);
+    },
+    
+    getFragmentArgumentCount: function(options) {
+      var source = this.getFragmentSource(options);
+      return numArgumentsInMain(source);
+    },
+    
+    getRawSource: function(options, which) {
+      var source = this.options[which];
+      if (source && (source = source.render(options))) {
+        var result = this.getPreamble(options);
+        if (!options || !options.skip_export_definitions)
+          result += this.getExportDefinitions(options && options.export_prefix || this.getName());
+        if (!options || !options.skip_common_source)
+          result += this.getCommonSource(options) + "\n";
+        result += source;
+        return result;
+      }
+      return null;
+    },
+    
+    getGlobalDefinitions: function(options, isVertex) {
+      var map = this.getInputMap(options);
+      var source = "";
+      for (var i in map) {
+        if (map[i].scope == "attribute" && !isVertex) continue;
+        source += map[i].scope+" "+map[i].type+" "+map[i].full_name+";\n";
+      }
+      return source;
+    },
+    
+    setRawSource: function(source, which) { this.options[which] = source && new EJS({text:source}); },
+    
+    setVertexSource: function(source) { this.setRawSource(source, 'vertex'); },
+    
+    setFragmentSource: function(source) { this.setRawSource(source, 'fragment'); },
+    
+    getInputMap: function(options) {
+      var map = {};
+      var prefix = "";
+      
+      if (options && options.local_prefix)  prefix = options.local_prefix+"_";
+      else if (options && options.export_prefix) prefix = options.export_prefix+"_";
+      
+      var source = (this.getRawSource(options, 'common')   || "") + "\n\n" +
+                   (this.getRawSource(options, 'vertex')   || "")  + "\n\n" +
+                   (this.getRawSource(options, 'fragment') || "");
+      
+      // if it's not a "shared" uniform, mangle its name.
+      var rx = new RegExp("(^|\\n|\\s+)((shared\\s+)?)(uniform|attribute|varying) (\\w+) ((?!"+prefix+")[^;]*);"), result;
+      while (result = rx.exec(source)) {
+        var shared = /shared/.test(result[2]);
+        var scope = result[4];
+        var type = result[5];
+        var names = result[6].split(/,/);
+
+        for (var i = 0; i < names.length; i++) {
+          names[i] = names[i].replace(/^\s+/, '').replace(/\s+$/, '');
+          if (shared) map[names[i]] = names[i];
+          else map[names[i]] = sanitizeName(prefix+names[i]);
+          map[names[i]] = { full_name: map[names[i]], type: type, scope: scope, shared: shared };
+          source = source.replace(new RegExp("(^|[^a-zA-Z0-9_])"+names[i]+"([^a-zA-Z0-9_]|$)", "g"),
+                                  "$1"+prefix+names[i]+"$2");
+        }
+      }
+      
+      return map;
+    },
+    
+    getExportDefinitions: function(exportPrefix, skip) {
+      var exports = "";
+      if (this.options.exports) {
+        for (var name in this.options.exports) {
+          if (!skip || skip.indexOf(name) == -1)
+            exports += this.options.exports[name]+" "+getExportedVariableName(exportPrefix, name)+";\n";
+        }
+      }
+      return exports + "\n";
+    },
+    
+    build: function(context, material) {
+      var count = 0;
+      if (this.getVertexShader(context)) {
+        count++;
+        compile(context, this.getVertexShader(context), this.getVertexSource(material));
+      }
+      if (this.getFragmentShader(context)) {
+        count++;
+        compile(context, this.getFragmentShader(context), this.getFragmentSource(material));
+      }
+      if (count == 0) throw new Error("No sources specified for shader '"+this.getName()+"'!");
+    }
+  });
+})();
+
+
+Jax.Shader.max_varyings = gl.getParameter(GL_MAX_VARYING_VECTORS);
+Jax.Shader.max_vertex_uniforms = gl.getParameter(GL_MAX_VERTEX_UNIFORM_VECTORS);
+Jax.Shader.max_fragment_uniforms = gl.getParameter(GL_MAX_FRAGMENT_UNIFORM_VECTORS);
+Jax.Shader.max_attributes = gl.getParameter(GL_MAX_VERTEX_ATTRIBS);
+
+// FIXME differentiate between vertex & fragment uniforms
+Jax.Shader.max_uniforms = Math.min(Jax.Shader.max_fragment_uniforms, Jax.Shader.max_vertex_uniforms);
+
+//= require "shader/program"