jax 0.0.0.1

data/src/jax/webgl/shader/delegator.js

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

data/src/jax/webgl/shader/delegator/attribute.js

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

data/src/jax/webgl/shader/delegator/uniform.js

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

data/src/jax/webgl/shader/manifest.js

@@ -0,0 +1,64 @@
+/**
+ class Jax.Shader.Manifest
+   
+ Used to track variable assignments. After all assignments have been made just prior to committing a render phase,
+ the manifest will be used to actually pass variable values into the shader. This keeps from specifying shader
+ values more than once. Manifest can also be used to cache values between render passes, because its values are
+ never reset.
+ **/
+Jax.Shader.Manifest = Jax.Class.create({
+  initialize: function(existing) {
+    this.values = {};
+    this.texture_tracker = 0;
+    this.variable_prefix = "";
+    this.existing = existing || [];
+  },
+  
+  set: function(name, value) {
+    var i;
+    if (value === undefined)
+      if (typeof(name) == "object")
+        for (i in name)
+          this.set(i, name[i]);
+      else throw new Error("Invalid argument (or the value given is undefined): "+
+              JSON.stringify(name)+"\n\n"+new Error().stack);
+    else
+      for (i = 0; i < arguments.length; i += 2) {
+        if (this.existing.indexOf(arguments[i]) != -1)
+          this.values[arguments[i]] = arguments[i+1];
+        else
+          this.values[this.variable_prefix+arguments[i]] = arguments[i+1];
+      }
+  },
+  
+  getValue: function(name) {
+    if (this.existing.indexOf(name) != -1)
+      return this.values[name];
+    else return this.values[this.variable_prefix+name];
+  },
+  
+  texture: function(name, tex, context) {
+    if (!context) throw new Error("Can't bind texture without a context");
+    if (this.texture_tracker == GL_MAX_ACTIVE_TEXTURES-1) {
+      throw new Error("Maximum number of textures ("+GL_MAX_ACTIVE_TEXTURES+") has been reached!");
+    }
+    
+    if (typeof(this.getValue(name)) != "number")
+      this.set(name, this.texture_tracker++);
+    
+    if (tex.loaded) {
+      context.glActiveTexture(GL_TEXTURES[this.getValue(name)]);
+      tex.bind(context, this.getValue(name));
+    }
+  },
+  
+  apply: function(uniforms, attributes) {
+    attributes.disableAll();
+    for (var name in this.values) {
+      if (uniforms.doesExist(name))
+        uniforms.set(name, this.values[name]);
+      else if (attributes.doesExist(name))
+        attributes.set(name, this.values[name]);
+    }
+  }
+});

data/src/jax/webgl/shader/program.js

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

data/src/jax/webgl/shader_chain.js

@@ -0,0 +1,256 @@
+//= require "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*\(/, 'void '+sanitizeName(prefix)+'_main_'+sanitizeName(suffix)+'(');
+  }
+  
+  function preprocessorOptions(self) {
+    return {
+      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);
+      this.phases.push(shader);
+      this.invalidate();
+      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";
+      }
+      
+      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 ? "gl_FragColor = ambient + diffuse + specular;\n" : "") +
+             "}\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; }
+  });
+})();