jax 0.0.0.9 → 0.0.0.10

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

@@ -1,136 +0,0 @@
-//= require "light_source"
-
-Jax.Scene.LightManager = (function() {
-  return Jax.Class.create({
-    initialize: function(context) {
-      this.context = context;
-      this._lights = [];
-      this.objects = [];
-    },
-    
-    addObject: function(obj) {
-      this.objects.push(obj);
-      for (var j = 0; j < this._lights.length; j++)
-        if (obj.isShadowCaster())
-          this._lights[j].registerCaster(obj);
-      this.recalculateBoundingRadius();
-    },
-    
-    removeObject: function(obj) {
-      if (this.objects[obj]) {
-        var o = this.objects[obj];
-        this.objects.splice(obj, 1);
-        for (var j = 0; j < this._lights.length; j++)
-          if (o.isShadowCaster())
-            this._lights[j].unregisterCaster(o);
-        this.recalculateBoundingRadius();
-        return o;
-      }
-      for (var i = 0; i < this.objects.length; i++)
-        if (this.objects[i] == obj)
-          return this.removeObject(obj);
-    },
-    
-    getShadowCasters: function() {
-      var ret = [];
-      for (var i = 0; i < this.objects.length; i++) {
-        if (this.objects[i].isShadowCaster())
-          ret.push(this.objects[i]);
-      }
-      return ret;
-    },
-    
-    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.");
-      for (var i = 0; i < this.objects.length; i++) {
-        if (this.objects[i].isShadowCaster())
-          light.registerCaster(this.objects[i]);
-      }
-      this._lights.push(light);
-      light.boundingRadius = this.boundingRadius || 0;
-    },
-    
-    recalculateBoundingRadius: function() {
-      var boundingRadius = null;
-      var i, j;
-      for (i = 0; i < this.objects.length; i++) {
-        j = vec3.length(this.objects[i].camera.getPosition()) + this.objects[i].getBoundingSphereRadius();
-        if (boundingRadius == null || boundingRadius < j)
-          boundingRadius = j;
-      }
-      this.boundingRadius = boundingRadius = boundingRadius || 0;
-      
-      for (i = 0; i < this._lights.length; i++)
-        this._lights[i].boundingRadius = boundingRadius;
-    },
-    
-    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, options) {
-      // used by individual light sources
-      options = Jax.Util.normalizeOptions(options, {});
-      
-      // Use alpha blending for the first pass, and additive blending for subsequent passes.
-      this.context.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-      for (var i = 0; i < this._lights.length; i++) {
-        this._current_light = i;
-        this._lights[i].render(context, this.objects, options);
-        if (i == 0) this.context.glBlendFunc(GL_ONE, GL_ONE);
-      }
-      
-      delete this._current_light;
-    },
-
-    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

@@ -1,294 +0,0 @@
-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('matrixUpdated', function() { self.invalidate(); });
-
-      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;
-    },
-    
-    registerCaster: function(object) {
-      var self = this;
-      function updated() { self.invalidate(); }
-      object.camera.addEventListener('matrixUpdated', 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;
-        this.updateShadowMap(context, this.boundingRadius, objects, options);
-        this.valid = true;
-        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/src/jax/webgl/shader.js

@@ -1,296 +0,0 @@
-/**
- * class Jax.Shader
- *
- * Wraps around a WebGL shader program.
- **/
-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 sourceWithoutComments(source) {
-    return source.replace(/\/\*.*\*\//g, "");
-  }
-  
-  function numArgumentsInMain(source) {
-    // if a comment contains 'void main' in it, we'll get false positives
-    var result = /void\s*main\((.*?)\)\s*\{/.exec(sourceWithoutComments(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];
-      options = Jax.Util.normalizeOptions(options, {shader_type: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)\\s+(\\w+)\\s+((?!"+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);
-Jax.Shader.max_vertex_textures = gl.getParameter(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-
-// 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"