jax 1.1.1 → 2.0.0

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

@@ -0,0 +1,279 @@
+//= require "jax/webgl/scene"
+
+/**
+ * class Jax.World
+ * 
+ * A +Jax.World+ represents a scene in the graphics engine. All objects to be rendered (or at least,
+ * all objects that you do not want to manually control!) should be added to the world. Each instance
+ * of +Jax.Context+ has its own +Jax.World+, and the currently-active +Jax.World+ is delegated into
+ * controllers and views as the +this.world+ property.
+ *
+ **/
+Jax.World = (function() {
+  function getPickBuffer(self) {
+    if (self.pickBuffer) return self.pickBuffer;
+    return self.pickBuffer = new Jax.Framebuffer({
+      width:self.context.canvas.width,
+      height:self.context.canvas.height
+    });
+  }
+  
+  return Jax.Class.create({
+    initialize: function(context) {
+      this.context  = context;
+      this.lighting = new Jax.Scene.LightManager(context);
+      this.objects  = [];
+    },
+    
+    /**
+     * Jax.World#addLightSource(light) -> Jax.Scene.LightSource
+     * - light (Jax.Scene.LightSource): the instance of Jax.Scene.LightSource to add to this world.
+     *
+     * Adds the light to the world and then returns the light itself unchanged.
+     **/
+    addLightSource: function(light)   { this.lighting.add(light); },
+    
+    /**
+     * Jax.World#addObject(object) -> Jax.Model
+     * - object (Jax.Model): the instance of Jax.Model to add to this world.
+     *
+     * Adds the model to the world and then returns the model itself unchanged.
+     *
+     **/
+    addObject: function(object) {
+      this.objects.push(object);
+      if (object.isLit() || object.isShadowCaster())
+        this.lighting.addObject(object);
+      return object;
+    },
+    
+    /**
+     * Jax.World#getObject(index) -> Jax.Model
+     * - index (Number): the world index of this object
+     *
+     * Returns the object with the specified world index, or undefined.
+     **/
+    getObject: function(index) { return this.objects[index]; },
+    
+    /**
+     * Jax.World#removeObject(object_or_index) -> Jax.Model
+     * - object_or_index (Number|Jax.Model): the model instance to remove, or its world index
+     *
+     * If the model or its index cannot be found, nothing happens and the return value is undefined.
+     * Otherwise, the object is removed from this World and then returned.
+     **/
+    removeObject: function(object_or_index) {
+      if (this.objects[object_or_index]) {
+        var obj = this.objects[object_or_index];
+        this.objects.splice(object_or_index, 1);
+        this.lighting.removeObject(obj);
+        return obj;
+      }
+      else
+        for (var i = 0; i < this.objects.length; i++)
+          if (this.objects[i] == object_or_index)
+          {
+            this.objects.splice(i, 1);
+            this.lighting.removeObject(this.objects[i]);
+            return this.objects[i];
+          }
+    },
+    
+    /**
+     * Jax.World#pickRegionalIndices(x1, y1, x2, y2[, ary]) -> Array
+     * - x1 (Number): the screen X coordinate of the first corner of the 2D rectangle within which to pick
+     * - y1 (Number): the screen Y coordinate of the first corner of the 2D rectangle within which to pick
+     * - x2 (Number): the screen X coordinate of the second corner of the 2D rectangle within which to pick
+     * - y2 (Number): the screen Y coordinate of the second corner of the 2D rectangle within which to pick
+     * - ary (Array): an optional array to populate. A new one will be created if this is not specified.
+     *                (Note: the array's contents will be cleared.)
+     * 
+     * Picks all visible object indices within the specified rectangular regions and returns them as elements in
+     * an array.
+     *
+     * An object's index matches its position in the world's object list. That is, the following code is
+     * valid:
+     *
+     *     this.world.getObjects(this.world.pickRegionalIDs(0,0, 100,100));
+     *
+     **/
+    pickRegionalIndices: function(x1, y1, x2, y2, ary) {
+      var w = Math.abs(x2 - x1), h = Math.abs(y2 - y1);
+      if (ary) ary.clear();
+      else ary = new Array();
+      var world = this, pickBuffer = getPickBuffer(this), context = this.context;
+      console.log(w*h*4);
+      var data = new Uint8Array(w*h*4);
+
+      pickBuffer.bind(context, function() {
+        pickBuffer.viewport(context);
+        context.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+        context.glDisable(GL_BLEND);
+        world.render({material:"picking"});
+        // read it back in
+        context.glReadPixels(x1, y1, w, h, GL_RGBA, GL_UNSIGNED_BYTE, data);
+        if (data.data) data = data.data;
+      });
+      
+      // restore the visible viewport and blending
+      context.glViewport(0, 0, context.canvas.width, context.canvas.height);
+      context.glEnable(GL_BLEND);
+      
+      var index;
+      for (var i = 2; i < data.length; i += 4) {
+        if (data[i] > 0) { // blue key exists, we've found an object
+          index = Jax.Util.decodePickingColor(data[i-2], data[i-1], data[i], data[i+1]);
+          if (index != undefined) {
+            ary.push(index);
+          }
+        }
+      }
+      
+      return ary;
+    },
+    
+    /**
+     * Jax.World#pickRegion(x1, y1, x2, y2) -> Array
+     * - x1 (Number): the screen X coordinate of the first corner of the 2D rectangle within which to pick
+     * - y1 (Number): the screen Y coordinate of the first corner of the 2D rectangle within which to pick
+     * - x2 (Number): the screen X coordinate of the second corner of the 2D rectangle within which to pick
+     * - y2 (Number): the screen Y coordinate of the second corner of the 2D rectangle within which to pick
+     * - ary (Array): an optional array to populate. A new one will be created if this is not specified.
+     *                (Note: the array's contents will be cleared.)
+     *
+     * Picks all visible objects within the specified rectangular regions and returns them as elements in
+     * an array.
+     **/
+    pickRegion: function(x1, y1, x2, y2, ary) {
+      var result = this.pickRegionalIndices(x1, y1, x2, y2);
+      for (var i = 0; i < result.length; i++)
+        result[i] = this.getObject(i);
+      return result;
+    },
+    
+    /**
+     * Jax.World#pickIndex(x, y) -> Number | undefined
+     * - x (Number): the screen X coordinate to pick at
+     * - y (Number): the screen Y coordinate to pick at
+     *
+     * Picks the visible object at the specified position and returns its index as used by
+     * +Jax.World#getObject+. If no object is visible at the given position, the special value
+     * +undefined+ is returned.
+     **/
+    pickIndex: function(x, y) {
+      this._pick_ary = this._pick_ary || new Array();
+      var result = this.pickRegionalIndices(x, y, x+1, y+1, this._pick_ary)[0];
+      return result;
+    },
+    
+    /**
+     * Jax.World#pick(x, y) -> Jax.Model | undefined
+     * - x (Number): the screen X coordinate to pick at
+     * - y (Number): the screen Y coordinate to pick at
+     *
+     * Picks the visible object at the specified position and returns it. If no object is visible
+     * at the given position, the special value +undefined+ is returned.
+     **/
+    pick: function(x, y) {
+      var index = this.pickIndex(x, y);
+      if (index != undefined) {
+        return this.getObject(index);
+      }
+      return index;
+    },
+    
+    /**
+     * Jax.World#countObjects() -> Number
+     * Returns the number of objects currently registered with this World.
+     **/
+    countObjects: function() {
+      return this.objects.length;
+    },
+    
+    /**
+     * Jax.World#getShadowCasters() -> Array
+     *
+     * Returns an array of all known shadow-casters in this World.
+     **/
+    getShadowCasters: function() { return this.lighting.getShadowCasters(); },
+    
+    /**
+     * Jax.World#render([options]) -> Jax.World
+     *
+     * Renders this World to its Jax context. Options, if specified, are delegated
+     * to the individual models to be rendered.
+     *
+     * Prior to rendering, this function assigns the blend function to
+     * (+GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA+).
+     *
+     * This function determines whether light sources are to have an effect on the
+     * render pass. If so, the world's +Jax.LightManager+ instance is invoked to
+     * render the objects; otherwise, the objects are rendered directly with the
+     * +unlit+ option set to +true+.
+     **/
+    render: function(options) {
+      var i;
+      
+      /* this.current_pass is used by the material */
+
+      this.context.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+      var unlit = Jax.Util.normalizeOptions(options, {unlit:true});
+      
+      if (this.lighting.isEnabled() && (!unlit.material || (unlit.material.supportsLighting && unlit.material.supportsLighting()))) {
+        /* illumination pass */
+        this.context.current_pass = Jax.Scene.ILLUMINATION_PASS;
+        this.lighting.illuminate(this.context, options);
+
+        /* ambient pass - unlit objects only because lit objects get ambient+diffuse+specular in one pass */
+        this.context.current_pass = Jax.Scene.AMBIENT_PASS;
+        for (i = 0; i < this.objects.length; i++)
+          if (!this.objects[i].isLit()) {
+            unlit.model_index = i;
+            this.objects[i].render(this.context, unlit);
+          }
+      } else {
+        this.context.current_pass = Jax.Scene.AMBIENT_PASS;
+        for (i = 0; i < this.objects.length; i++) {
+          unlit.model_index = i;
+          this.objects[i].render(this.context, unlit);
+        }
+      }
+      
+      return this;
+    },
+    
+    /**
+     * Jax.World#update(timechange) -> Jax.World
+     * - timechange (Number): the number of seconds to have passed since the last
+     * call to +Jax.World#update+.
+     *
+     * Updates each object in the world, passing the +timechange+ argument into
+     * the objects' respective +update+ functions (if they have one).
+     **/
+    update: function(timechange) {
+      for (var i = this.objects.length-1; i >= 0; i--)
+        if (this.objects[i].update)
+          this.objects[i].update(timechange);
+      return this;
+    },
+    
+    /**
+     * Jax.World#dispose() -> Jax.World
+     *
+     * Disposes of this world by removing all references to its objects and
+     * reinitializing its +Jax.Scene.LightManager+ instance. Note that the
+     * individual objects are not disposed; this is left as a task for either
+     * the developer or the JavaScript garbage collector. The reason for this
+     * is because it is impossible for Jax.World to know whether the objects
+     * in question are in use by other Worlds.
+     **/
+    dispose: function() {
+      var i, o;
+      
+      for (i = this.objects.length-1; i >= 0; i--)
+        (o = this.objects.pop());// && o.dispose();
+      
+      this.lighting = new Jax.Scene.LightManager(this.context);
+    }
+  });
+})();

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

@@ -0,0 +1,109 @@
+/*
+This file will set up WebGL constants as globals prefixed with GL_, and will add
+a new global called GL_METHODS. This will later be used for method delegation
+within Jax.Context.
+ */
+
+//= require "jax/vendor/glMatrix"
+//= require_self
+/*
+  all files in the webgl/ subdirectory will have access to a temporary GL context,
+  via `Jax.getGlobal()['GL']`, which will be unloaded after they have been loaded into memory.
+ */
+//= require "jax/webgl/shader_chain"
+//= require "jax/webgl/material"
+//= require "jax/webgl/mesh"
+//= require "jax/webgl/camera"
+//= require "jax/webgl/world"
+//= require "jax/webgl/texture"
+//= require "jax/webgl/cleanup"
+
+Jax.getGlobal()['WEBGL_CONTEXT_NAME'] = "experimental-webgl";
+Jax.getGlobal()['WEBGL_CONTEXT_OPTIONS'] = {stencil:true};
+Jax.getGlobal()['GL_METHODS'] = {};
+
+(function() {
+  var canvas = document.createElement("canvas");
+  canvas.setAttribute("id", "temporary-internal-use");
+  // canvas.style.display = "block";
+
+  // var body = document.getElementsByTagName("body")[0], temporaryBody = false;
+  // if (!body)
+  // {
+  //   temporaryBody = true;
+  //   body = document.createElement("body");
+  //   document.getElementsByTagName("html")[0].appendChild(body);
+  // }
+  // body.appendChild(canvas);
+
+  try {
+    var gl = canvas.getContext(WEBGL_CONTEXT_NAME);
+  } catch(e) {
+    // these are now handled by the Context upon initialization.
+    // document.location.pathname = "/webgl_not_supported.html";
+    // throw new Error("WebGL is disabled or is not supported by this browser!");
+    gl = null;
+  }
+
+  if (gl) {
+    for (var method_name in gl)
+    {
+      if (typeof(gl[method_name]) == "function")
+      {
+        var camelized_method_name = method_name.substring(1, method_name.length);
+        camelized_method_name = "gl" + method_name.substring(0, 1).toUpperCase() + camelized_method_name;
+
+        /* we'll add a layer here to check for render errors, only in development mode */
+        /* FIXME Chrome has serious performance issues related to gl.getError(). Disabling under Chrome for now. */
+        var func = "(function "+camelized_method_name+"() {"
+                 + "  var result;"
+                 + "  if ("+(method_name == 'getError')+" || Jax.environment == Jax.PRODUCTION)"
+                 + "    result = this.gl."+method_name+".apply(this.gl, arguments);"
+                 + "  else {"
+                 + "    try { "
+                 + "      result = this.gl."+method_name+".apply(this.gl, arguments);"
+                 + "      if ("+(navigator.userAgent.toLowerCase().indexOf('chrome') == -1)+")"
+                 + "        this.checkForRenderErrors();"
+                 + "    } catch(e) { "
+                 + "      var args = [], i;"
+                 + "      for (i = 0; i < arguments.length; i++) args.push(arguments[i]);"
+                 + "      try { args = JSON.stringify(args); } catch(jsonErr) { args = args.toString(); }"
+                 + "      if (!e.stack) e = new Error(e.toString());"
+                 + "      this.handleRenderError('"+method_name+"', args, e);"
+                 + "    }"
+                 + "  }"
+                 + "  return result;"
+                 + "})";
+
+        GL_METHODS[camelized_method_name] = eval("("+func+")");
+      }
+      else
+      {
+        /* define the GL enums Jax.getGlobal()ly so we don't need a context to reference them */
+        if (!/[a-z]/.test(method_name)) // no lowercase letters
+          Jax.getGlobal()[('GL_'+method_name)] = gl[method_name];
+      }
+    }
+
+    /* define some extra Jax.getGlobal()s that the above didn't generate */
+//    Jax.getGlobal()['GL_MAX_VERTEX_ATTRIBS'] = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
+    Jax.getGlobal()['GL_DEPTH_COMPONENT'] = gl.DEPTH_COMPONENT || gl.DEPTH_COMPONENT16;
+    Jax.getGlobal()['GL_TEXTURES'] = [];
+    for (i = 0; i < 32; i++) Jax.getGlobal()['GL_TEXTURES'][i] = gl["TEXTURE"+i];
+    Jax.getGlobal()['GL_MAX_ACTIVE_TEXTURES'] = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
+  }
+
+  Jax.getGlobal()['GL'] = gl;
+
+  Jax.getGlobal()['WEBGL_CLEANUP'] = function() {
+    /* clean up after ourselves */
+    // if (temporaryBody)
+    //   body.parentNode.removeChild(body);
+    // else
+    //   body.removeChild(canvas);
+      
+    // remove the temporary GL context that will no longer be used
+    delete Jax.getGlobal()['GL'];
+    delete Jax.getGlobal()['WEBGL_CLEANUP'];
+  };
+})();

data/lib/assets/javascripts/jax.js

@@ -0,0 +1,136 @@
+//= require "jax/core/base"
+//= require "jax/compatibility"
+//= require "jax/core"
+//= require "jax/anim_frame"
+//= require "jax/prototype/extensions"
+//= require "jax/mvc/model"
+//= require "jax/mvc/controller"
+//= require "jax/mvc/view_manager"
+//= require "jax/mvc/route_set"
+//= require "jax/mvc/view"
+//= require "jax/context"
+//= require "jax/noise"
+//= require "jax/builtin/all.js"
+
+Jax.shaders = {};
+Jax._shader_data = {};
+
+Jax.import_shader_code = function(shader_name, shader_type) {
+  var constant_name = "__import_"+shader_name+"_"+shader_type+"__";
+  return "#ifndef "+constant_name+"\n" +
+         "#define "+constant_name+" 1\n" +
+           Jax.shader_data(shader_name)[shader_type] +
+         "#endif\n"
+};
+
+// Finds or creates the named shader descriptor in +Jax.shaders+. This is used by
+// `Jax::Shader` in Ruby.
+Jax.shader_data = function(name) {
+  Jax._shader_data[name] = Jax._shader_data[name] || {"name":name};
+  return Jax._shader_data[name];
+};
+
+/**
+ * Jax.views -> Jax.ViewManager
+ **/
+Jax.views = new Jax.ViewManager();
+
+/**
+ * Jax.routes -> Jax.RouteSet
+ **/
+Jax.routes = new Jax.RouteSet();
+
+/**
+ * Jax.loaded -> Boolean
+ * True after Jax has been loaded.
+ **/
+Jax.loaded = true;
+
+/**
+ * Jax.render_speed -> Number
+ * Target number of milliseconds to wait between frames.
+ * This is not a guaranteed number in JavaScript, just a target. Most notably,
+ * system performance issues can drive the framerate down regardless of the
+ * target refresh rate.
+ *
+ * Defaults to 16, for a target rate of 60 frames per second.
+ **/
+Jax.render_speed = 16;
+
+/**
+ * Jax.update_speed -> Number
+ * Target number of milliseconds to wait between updates.
+ * This is not a guaranteed number in JavaScript, just a target. Most notably,
+ * system performance issues can drive the framerate down regardless of the
+ * target refresh rate.
+ *
+ * Defaults to 33, for a target rate of 30 updates per second.
+ **/
+Jax.update_speed = 33;
+
+
+/**
+ * Jax.max_lights -> Number
+ *
+ * If set, Jax will raise an error whenever more than this number of light sources
+ * are activated at one time.
+ *
+ * By default, there is no limit to the number of lights Jax can support. (This
+ * property is undefined by default.)
+ **/
+Jax.max_lights = undefined;
+
+/**
+ * Jax.uptime -> Number
+ *
+ * The amount of time the Jax subsystem has been running, in seconds. This is updated
+ * whether any contexts are active or not. It is used for tracking update intervals
+ * and framerates, so that individual Jax contexts are not constantly spawning new
+ * Date() instances (which then have to be garbage collected).
+ **/
+Jax.uptime = 0.0;
+Jax.uptime_tracker = new Date();
+
+/**
+ * Jax.shutdown() -> undefined
+ *
+ * Causes all Jax contexts to be disposed.
+ **/
+Jax.shutdown = function() {
+  if (Jax.uptime_interval) clearInterval(Jax.uptime_interval);
+  Jax.uptime_interval = null;
+  Jax.SHUTDOWN_IN_PROGRESS = true;
+};
+
+/**
+ * Jax.restart() -> undefined
+ *
+ * Restarts the Jax subsystem after a prior call to Jax.shutdown().
+ **/
+Jax.restart = function() {
+  Jax.SHUTDOWN_IN_PROGRESS = false;
+  /* TODO: verify : is setInterval better for updates, or should be we using requestAnimFrame? */
+  if (!Jax.uptime_interval)
+    Jax.uptime_interval = setInterval(function() { Jax.uptime = (new Date() - Jax.uptime_tracker) / 1000; }, 33);
+};
+
+// start 'er up!
+Jax.restart();
+
+/*
+  FIXME Resource manager looks for an object in the global namespace, so using Jax.Scene.LightSource
+  instead of just LightSource results in a broken resource load.
+ */
+var LightSource = Jax.Scene.LightSource;
+var Material = Jax.Material;
+
+
+/* Export globals into 'exports' for CommonJS */
+if (typeof(exports) != "undefined") {
+  exports.Jax = Jax;
+  exports.mat4 = mat4;
+  exports.mat3 = mat3;
+  exports.vec3 = vec3;
+  exports.glMatrixArrayType = glMatrixArrayType;
+  exports.quat4 = quat4;
+}

data/{builtin/app/shaders/basic/vertex.ejs → lib/assets/javascripts/shaders/basic/vertex.glsl}

@@ -6,7 +6,7 @@ void main(void) {
   vBaseColor = VERTEX_COLOR;
   vNormal = nMatrix * VERTEX_NORMAL;
   vTexCoords = VERTEX_TEXCOORDS;
-                          
+
   vSurfacePos = (mvMatrix * VERTEX_POSITION).xyz;
 
   gl_Position = pMatrix * mvMatrix * VERTEX_POSITION;

data/{builtin/app/shaders/depthmap/fragment.ejs → lib/assets/javascripts/shaders/depthmap/fragment.glsl}

@@ -1,4 +1,4 @@
-//= require "functions/depth_map"
+//= require "shaders/functions/depth_map"
 
 void main(void) {
   vec4 pos = gl_FragCoord;

data/{builtin/app → lib/assets/javascripts}/shaders/fog/material.js

@@ -22,13 +22,11 @@ Jax.Material.Fog = Jax.Class.create(Jax.Material, {
     $super(options);
   },
   
-  setUniforms: function($super, context, mesh, options, uniforms) {
-    $super(context, mesh, options, uniforms);
-    
-    uniforms.set('End', this.end);
-    uniforms.set('Scale', 1.0 / (this.end - this.start));
-    uniforms.set('Algorithm', this.algorithm);
-    uniforms.set('Density', this.density);
-    uniforms.set('FogColor', this.color);
+  setVariables: function(context, mesh, options, vars) {
+    vars.set('End', this.end);
+    vars.set('Scale', 1.0 / (this.end - this.start));
+    vars.set('Algorithm', this.algorithm);
+    vars.set('Density', this.density);
+    vars.set('FogColor', this.color);
   }
 });

data/lib/assets/javascripts/shaders/lighting/common.glsl

@@ -0,0 +1,5 @@
+//= require "shaders/functions/lights"
+
+shared uniform bool LIGHTING_ENABLED;
+
+shared varying vec3 vLightDir;

data/{builtin/app → lib/assets/javascripts}/shaders/lighting/material.js

@@ -3,11 +3,9 @@ Jax.Material.Lighting = Jax.Class.create(Jax.Material, {
     $super(Jax.Util.normalizeOptions(options, {shader: "lighting"}));
   },
   
-  setUniforms: function($super, context, mesh, options, uniforms) {
-    $super(context, mesh, options, uniforms);
-    
+  setVariables: function(context, mesh, options, vars) {
     var light = context.world.lighting.getLight();
-    uniforms.set({
+    vars.set({
       LIGHTING_ENABLED: context.world.lighting.isEnabled() && !(options.unlit),
       LIGHT_POSITION: light.getPosition(),
       LIGHT_DIRECTION: light.getDirection(),

data/{builtin/app/shaders/normal_map/common.ejs → lib/assets/javascripts/shaders/normal_map/common.glsl}

@@ -1,4 +1,4 @@
-//= require "functions/lights"
+//= require "shaders/functions/lights"
 
 uniform sampler2D NormalMap;
 

data/lib/assets/javascripts/shaders/normal_map/material.js

@@ -0,0 +1,11 @@
+Jax.Material.NormalMap = Jax.Class.create(Jax.Material, {
+  initialize: function($super, map) {
+    this.map = Jax.Material.Texture.normalizeTexture(map);
+    $super({shader:"normal_map"});
+  },
+  
+  setVariables: function(context, mesh, options, vars) {
+    vars.texture('NormalMap', this.map, context);
+    vars.set('VERTEX_TANGENT', mesh.getTangentBuffer());
+  }
+});

data/{builtin/app → lib/assets/javascripts}/shaders/paraboloid/material.js

@@ -3,10 +3,8 @@ Jax.Material.Paraboloid = Jax.Class.create(Jax.Material, {
     $super(Jax.Util.normalizeOptions(options, {shader:"paraboloid"}));
   },
   
-  setUniforms: function($super, context, mesh, options, uniforms) {
-    $super(context, mesh, options, uniforms);
-
-    uniforms.set({
+  setVariables: function(context, mesh, options, vars) {
+    vars.set({
       DP_SHADOW_NEAR: 0.1, //c.world.lighting.getLight().getDPShadowNear() || 0.1;}},
       DP_SHADOW_FAR:  500,//c.world.lighting.getLight().getDPShadowFar() || 500;}},
       DP_DIRECTION: options && options.direction || 1