jax 1.1.1 → 2.0.0

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

@@ -0,0 +1,299 @@
+//= require_self
+//= require "jax/webgl/shader/program"
+
+/**
+ * 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:this,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()+"'!");
+    }
+  });
+})();
+
+(function() {
+  var gl = Jax.getGlobal()['GL'];
+  Jax.Shader.max_varyings          = gl ? gl.getParameter(GL_MAX_VARYING_VECTORS) : 0;
+  Jax.Shader.max_vertex_uniforms   = gl ? gl.getParameter(GL_MAX_VERTEX_UNIFORM_VECTORS) : 0;
+  Jax.Shader.max_fragment_uniforms = gl ? gl.getParameter(GL_MAX_FRAGMENT_UNIFORM_VECTORS) : 0;
+  Jax.Shader.max_attributes        = gl ? gl.getParameter(GL_MAX_VERTEX_ATTRIBS) : 0;
+  Jax.Shader.max_vertex_textures   = gl ? gl.getParameter(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS) : 0;
+
+  // FIXME differentiate between vertex & fragment uniforms
+  Jax.Shader.max_uniforms           = Math.min(Jax.Shader.max_fragment_uniforms, Jax.Shader.max_vertex_uniforms);
+})();

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

@@ -0,0 +1,267 @@
+//= require "jax/webgl/shader"
+
+Jax.ShaderChain = (function() {
+  function sanitizeName(name) {
+    return name.replace(/-/, '_');
+  }
+  
+  function preprocessFunctions(self, prefix, suffix, source) {
+    /* TODO mangle all function and structure names to prevent conflicts -- right now we only mangle main() */
+    
+    return source.replace(/void\s*main\s*\(/g, 'void '+sanitizeName(prefix)+'_main_'+sanitizeName(suffix)+'(');
+  }
+  
+  function preprocessorOptions(self) {
+    return {
+      shader: self,
+      ignore_es_precision: true,
+      export_prefix: self.getName(),
+      exports: self.gatherExports(),
+      skip_export_definitions: true,
+      skip_global_definitions: [] // array containing definitions so they aren't accidentally redefined
+    };
+  }
+  
+  function preventRedefinition(imap, options) {
+    for (var j in imap)
+      options.skip_global_definitions.push(imap[j].full_name);
+  }
+  
+  return Jax.Class.create(Jax.Shader.Program, {
+    initialize: function($super, name) {
+      $super();
+      this.name = name;
+      this.shaders.push(this.getMasterShader());
+      this.phases = [];
+    },
+    
+    getMasterShader: function() {
+      return this.master_shader = this.master_shader || new Jax.Shader({});
+    },
+    
+    addShader: function(shader) {
+      if (typeof(shader) == "string")
+        if (Jax.shaders[shader])
+          shader = Jax.shaders[shader];
+        else throw new Error("Shader is not defined: "+shader);
+      else if (!shader) throw new Error("Argument must be a Jax.Shader, or a String equal to its name");
+      this.phases.push(shader);
+      this.invalidate();
+      if (!shader.getName) throw new Error("Not an instance of Jax.Shader: "+JSON.stringify(shader));
+      return sanitizeName(shader.getName()+(this.phases.length - 1)+"_");
+    },
+    
+    getShaderNames: function() {
+      var result = [];
+      for (var i = 0; i < this.phases.length; i++)
+        result[i] = this.phases[i].getName();
+      return result;
+    },
+    
+    removeAllShaders: function() {
+      while (this.phases.length > 0) this.phases.pop();
+    },
+    
+    link: function($super, context, material) {
+      var program = this.getGLProgram(context);
+      
+      if (!program.linked) {
+        var master = this.getMasterShader();
+        
+        var numVaryings = this.countVaryings(material),
+            numUniforms = this.countUniforms(material),
+            numAttributes = this.countAttributes(material);
+        
+        if (numVaryings > Jax.Shader.max_varyings)
+          throw new RangeError("Varyings ("+numVaryings+") exceed maximum number of varyings ("+Jax.Shader.max_varyings+") supported by GPU! Try using a shorter chain.");
+        if (numUniforms > Jax.Shader.max_uniforms)
+          throw new RangeError("Uniforms ("+numUniforms+") exceed maximum number of uniforms ("+Jax.Shader.max_uniforms+") supported by GPU! Try using a shorter chain.");
+        if (numAttributes > Jax.Shader.max_attributes)
+          throw new RangeError("Attributes ("+numAttributes+") exceed maximum number of attributes ("+Jax.Shader.max_attributes+") supported by GPU! Try using a shorter chain.");
+
+        master.setVertexSource(this.getVertexSource(material));
+        master.setFragmentSource(this.getFragmentSource(material));
+        
+        program = $super(context, material);
+      }
+      
+      return program;
+    },
+    
+    getFragmentSource: function(options) {
+      options = Jax.Util.normalizeOptions(options, preprocessorOptions(this));
+      
+      var source = "";
+      source += this.getExportDefinitions(options);
+
+      for (var i = 0; i < this.phases.length; i++) {
+        options.local_prefix = this.phases[i].getName()+i;
+        source += "\n/**** Shader chain index "+i+": "+this.phases[i].getName()+" ****/\n";
+        source += preprocessFunctions(this, this.phases[i].getName()+i, 'f', this.phases[i].getFragmentSource(options));
+        source += "\n\n";
+
+        preventRedefinition(this.phases[i].getInputMap(options), options);
+      }
+      
+      return source + this.getFragmentMain(options);
+    },
+    
+    getVertexSource: function(options) {
+      options = Jax.Util.normalizeOptions(options, preprocessorOptions(this));
+      
+      var source = "";
+      source += this.getExportDefinitions(options);
+
+      for (var i = 0; i < this.phases.length; i++) {
+        options.local_prefix = this.phases[i].getName()+i;
+        source += "\n/**** Shader chain index "+i+": "+this.phases[i].getName()+" ****/\n";
+        source += preprocessFunctions(this, this.phases[i].getName()+i, 'v', this.phases[i].getVertexSource(options));
+        source += "\n\n";
+        
+        preventRedefinition(this.phases[i].getInputMap(options), options);
+      }
+      
+      return source + this.getVertexMain(options);
+    },
+    
+    getVertexMain: function(options) {
+      var functionCalls = "";
+      for (var i = 0; i < this.phases.length; i++) {
+        var args = "";
+        if (this.phases[i].getVertexArgumentCount() > 0)
+          args = "gl_Position";  
+        functionCalls += "  "+sanitizeName(this.phases[i].getName())+i+"_main_v("+args+");\n";
+      }
+      
+      return "/**** Shader chain generated #main ****/\n" +
+             "void main(void) {\n" +
+               functionCalls +
+             "}\n";
+    },
+    
+    getFragmentMain: function(options) {
+      var functionCalls = "";
+      var lastTookArguments = false;
+      for (var i = 0; i < this.phases.length; i++) {
+        var args = "";
+        if (this.phases[i].getFragmentArgumentCount() > 0) {
+          lastTookArguments = true;
+          args = "ambient, diffuse, specular";
+        } else lastTookArguments = false;
+        functionCalls += "  "+sanitizeName(this.phases[i].getName())+i+"_main_f("+args+");\n";
+      }
+      
+      var colors = "#ifdef PASS_TYPE\n"
+                 + "  if (PASS_TYPE == "+Jax.Scene.ILLUMINATION_PASS+") gl_FragColor = ambient + diffuse + specular;\n"
+                 + "  else gl_FragColor = ambient;\n"
+                 + "#else\n"
+                 + "  gl_FragColor = ambient + diffuse + specular;\n"
+                 + "#endif\n";
+                 
+      return "/**** Shader chain generated #main ****/\n" +
+             "void main(void) {\n" +
+               "vec4 ambient = vec4(1.0,1.0,1.0,1.0), diffuse = vec4(1.0,1.0,1.0,1.0), specular = vec4(1.0,1.0,1.0,1.0);\n" +
+               functionCalls +
+               (lastTookArguments ? colors : "") +
+             "}\n";
+    },
+    
+    getExportDefinitions: function(options) {
+      var source = "\n/** Exported shader chain variables **/\n";
+      var skip = [];
+      for (var i = 0; i < this.phases.length; i++) {
+        source += this.phases[i].getExportDefinitions(options.export_prefix, skip);
+        for (var j in this.phases[i].options.exports)
+          skip.push(j);
+      }
+      return source;
+    },
+    
+    getGlobalDefinitions: function(options, isVertex) {
+      var source = "\n/** Shared uniforms, attributes and varyings **/\n";
+      var map = this.getInputMap(options);
+      for (var name in map) {
+        if (map[name].scope == "attribute" && !isVertex) continue;
+        source += map[name].scope+" "+map[name].type+" "+map[name].full_name+";\n";
+      }
+      return source;
+    },
+    
+    getPerShaderInputMap: function(options) {
+      options = Jax.Util.normalizeOptions(options, {local_prefix:""});
+      var map = {};
+      var tracking_map = {};
+      var name;
+      for (var i = 0; i < this.phases.length; i++) {
+        name = this.phases[i].getName();
+        var entry = (map[name] = map[name] || { uniforms: [], attributes: [], varyings: [] });
+
+        options.local_prefix = this.phases[i].getName()+i;
+        
+        var _map = this.phases[i].getInputMap(options);
+        for (name in _map) {
+          var variable = _map[name];
+          // ignore anything that's already been defined, as it's primarily required by a shader with
+          // higher priority (implied that the fact that it came first in the list of phases)
+          if (!tracking_map[variable.full_name]) {
+            if (variable.scope == 'uniform')        entry.uniforms.push(variable);
+            else if (variable.scope == 'attribute') entry.attributes.push(variable);
+            else if (variable.scope == 'varying')   entry.varyings.push(variable);
+            else throw new Error("unhandled variable scope: "+JSON.stringify(variable));
+
+            tracking_map[variable.full_name] = 1;
+          }
+        }
+      }
+      return map;
+    },
+    
+    getInputMap: function(options) {
+      options = Jax.Util.normalizeOptions(options, {local_prefix:""});
+      var map = {};
+      for (var i = 0; i < this.phases.length; i++) {
+        options.local_prefix = this.phases[i].getName()+i;
+        var _map = this.phases[i].getInputMap(options);
+        for (var name in _map) {
+          var variable = _map[name];
+          if (map[variable.full_name]) {
+            if (map[name].type      != variable.type)
+              throw new Error("Conflicting types for variable '"+name+"' ("+map[name].type+" and "+variable.type+")!");
+            if (map[name].scope     != variable.scope)
+              throw new Error("Conflicting scopes for variable '"+name+"' ("+map[name].scope+" and "+variable.scope+")!");
+          }
+          else map[variable.full_name] = variable;
+        }
+      }
+
+      return map;
+    },
+    
+    countVariables: function(scope, options) {
+      var map = this.getInputMap(options);
+      var count = 0;
+      for (var i in map) {
+        if (map[i].scope == scope) count++;
+      }
+      return count;
+    },
+    
+    countVaryings: function(options) { return this.countVariables("varying", options); },
+    
+    countAttributes: function(options) { return this.countVariables("attribute", options); },
+    
+    countUniforms: function(options) { return this.countVariables("uniform", options); },
+    
+    gatherExports: function() {
+      var result = {};
+      for (var i = 0; i < this.phases.length; i++) {
+        if (this.phases[i].options.exports) {
+          Jax.Util.merge(this.phases[i].options.exports, result);
+        }
+      }
+      return result;
+    },
+    
+    getName: function() { return this.name; }
+  });
+})();