jax 1.1.1 → 2.0.0

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

@@ -0,0 +1,255 @@
+/**
+ * class Jax.DataSegment
+ *
+ * Returned by the mapping functions in +Jax.DataRegion+, Jax.DataSegment wraps
+ * around the typed arrays maintained by that class. It is intended to look
+ * and feel just like the underlying object and you can use it as such.
+ *
+ * The purpose of Jax.DataSegment is to provide a handle to the data segments
+ * maintained by Jax.DataRegion, because the underlying typed arrays may be
+ * reinitialized at any time as the data region itself is adjusted.
+ *
+ * You can also create data "groups" to further organize the data.
+ * An example would be to group a Float32Array into sets of 3
+ * for use as (X, Y, Z) vertex information:
+ *
+ *     var vertexData = new Jax.DataSegment(Float32Array, [0,1,0,  -1,0,0,  1,0,0]);
+ *     var vertices = vertexData.group(3);
+ *     for (var i = 0; i < vertices.length; i++) {
+ *       var vertex = vertices[i].array;
+ *       var x = vertex[0], y = vertex[1], z = vertex[2];
+ *       // . . .
+ *     }
+ *
+ **/
+Jax.DataSegment = (function() {
+  var DataGroup = Jax.Class.create({
+    initialize: function(raw, size) {
+      this.raw = raw;
+      this.type = raw.type;
+      this.size = size;
+      this.length = 0;
+    },
+    
+    push: function(seg) { this[this.length] = seg; this.length++; return seg; },
+    pop: function() { this.length--; var ret = this[this.length]; delete this[this.length]; return ret; },
+    getRawData: function() { return this.raw; }
+  });
+  
+  function populateGroup(self, group, size) {
+    var i, j, bytes = self.type.BYTES_PER_ELEMENT, len = 0, buf;
+    for (i = 0; i < self.array.length; i += size) {
+      if (buf = group[len]) {
+        // update existing group
+        buf.setArray(new self.type(self.buffer, self.byteOffset + i*bytes, size));
+      }
+      else {
+        // create new group
+        buf = new Jax.DataSegment(self.type, self.buffer, self.byteOffset + i*bytes, size);
+        group.push(buf);
+      }
+      len++;
+    }
+    // remove any groups remaining after data truncation
+    while (group.length > len) group.pop();
+  }
+  
+  var klass = Jax.Class.create({
+    /**
+     * new Jax.DataSegment(type, buffer, byteOffset, length)
+     * - type (Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array): the typed array type
+     * - buffer (ArrayBuffer): the array buffer containing at least enough bytes to contain this data segment
+     * - byteOffset (Number): the offset into the ArrayBuffer of the first byte of this segment
+     * - length (Number): the length in elements (not bytes) of this segment
+     *
+     * This class is not intended to be instantiated directly, although there's
+     * nothing technically keeping you from doing so. It is preferred that you
+     * make use of +Jax.DataRegion+.
+     *
+     **/
+    initialize: function(type, buffer, byteOffset, length) {
+      this.type = type;
+      this.groups = [];
+      try {
+        if (arguments.length == 2)
+          if (buffer instanceof this.type) this.setArray(buffer);
+          else this.setArray(new type(buffer));
+        else if (arguments.length == 1)
+          this.setArray(type);
+        else
+          this.setArray(new type(buffer, byteOffset, length));
+      } catch(e) {
+        throw new Error("Error: "+e+" while constructing segment from "+
+                        "("+type+", "+buffer+"["+buffer.byteLength+"], "+byteOffset+", "+length+")");
+      }
+    },
+    
+    /**
+     * Jax.DataSegment#setArray(buf) -> Jax.DataSegment
+     * - buf (Array): The array whose values to assign. Can be any array or enumeration
+     *                compatible with the #set method exposed by the Typed Arrays specification.
+     *
+     * Assigns the given buffer to the +array+ property of this data segment. Note that this
+     * assumes the reference of the given buffer; that is, further changes to the buffer will
+     * be reflected directly within this data segment and any data groups attached to it.
+     *
+     * Returns this data segment.
+     **/
+    setArray: function(buf) {
+      // if (this.length)
+      //   for (var i = 0; i < this.length; i++)
+      //     delete this[i];
+      
+      /**
+       * Jax.DataSegment#array -> Array
+       * the underlying typed array which contains the segment data.
+       **/
+      this.array  = buf;
+      
+      /**
+       * Jax.DataSegment#length -> Number
+       * the length of the underlying typed array in elements. This property
+       * can only be changed via a call to +Jax.DataSegment#setArray+.
+       **/
+      this.length = buf.length;
+      
+      /**
+       * Jax.DataSegment#buffer -> ArrayBuffer
+       * the underlying raw data buffer
+       **/
+      this.buffer = buf.buffer;
+      
+      /**
+       * Jax.DataSegment#byteOffset -> Number
+       * the offset in bytes into the +buffer+ at which this data segment begins
+       **/
+      this.byteOffset = buf.byteOffset;
+      
+      /**
+       * Jax.DataSegment#byteLength -> Number
+       * the number of bytes in the +buffer+ that this data segment contains
+       **/
+      this.byteLength = buf.byteLength;
+      
+      // define index setters/getters
+      // var self = this;
+      // for (var i = 0; i < buf.length; i++) {
+      //   Object.defineProperty(self, i, (function() {
+      //     var j = i;
+      //     return {
+      //       configurable: true,
+      //       enumerable: true,
+      //       get: function()  { return self.array[j]; },
+      //       set: function(v) { return self.array[j] = v; }
+      //     }
+      //   })());
+      // }
+      
+      // update groups
+      for (var i = 0; i < this.groups.length; i++) {
+        var group = this.groups[i];
+        var size = group.size;
+        populateGroup(this, group, size);
+      }
+      
+      return this;
+    },
+    
+    /**
+     * Jax.DataSegment#group(size) -> Array<Jax.DataSegment>
+     * - size (Number): the size, in array elements, of each group
+     *
+     * Creates a new view of this array laid out in the form of a 2D array.
+     * Each top-level element of the group contains a new instance of +Jax.DataSegment+,
+     * which in turn contains an +array+ property of exactly +size+ elements.
+     *
+     * This is useful for organizing a data segment into a more convenient structure,
+     * for instance, grouping a raw set of Float values into 3-dimensional Vertices:
+     *
+     *     var segment = region.map(Float32Array, [1, 2, 3, 4, 5, 6, 7, 8, 9]);
+     *     var vertices = segment.group(3);
+     *     //=> vertices now contains 3 segments containing 3 floats each
+     *     
+     *     for (var i = 0; i < vertices.length; i++) {
+     *       var vertex = vertices[i].array;
+     *       var x = vertices[0], y = vertices[1], z = vertices[2];
+     *       // . . .
+     *     }
+     *
+     * The group still points to the same physical memory as the segment it is
+     * derived from; therefore, changes to the parent segment will be immediately
+     * reflected within the group.
+     *
+     * The number of elements in the parent segment must be divisible by +size+. Otherwise,
+     * an error is raised.
+     **/
+    group: function(size) {
+      if (this.array.length % size != 0)
+        throw new Error("Data segment size "+this.array.length+" is not divisible by group size "+size);
+      var group = new DataGroup(this, size);
+      populateGroup(this, group, size);
+      this.groups.push(group);
+      return group;
+    },
+    
+    /**
+     * Jax.DataSegment#removeGroup(group) -> Jax.DataSegment
+     * - group (Jax.DataSegment): the group to be removed
+     *
+     * See +Jax.DataSegment#group+.
+     *
+     * When a group is created, its parent segment maintains a handle to it. This way,
+     * if the underlying array belonging to the parent segment is replaced with a
+     * completely different array (a common occurrance when a Jax.DataRegion needs
+     * to reallocate a new block of memory), the parent segment can notify its groups
+     * that their arrays, in turn, must also be replaced.
+     *
+     * This has the unfortunate side effect of maintaining a reference to the group
+     * even after it has outlived its usefulness. If you are done using a group,
+     * the JavaScript garbage collector cannot recapture the group unless you first
+     * remove it from its parent data segment.
+     *
+     * After the removal, this data segment is returned.
+     **/
+    removeGroup: function(group) {
+      var index;
+      if (typeof(group) == 'number') index = group;
+      else index = this.groups.indexOf(group);
+      
+      if (index != -1)
+        this.groups.splice(index, 1);
+      return this;
+    },
+    
+    /**
+     * Jax.DataSegment#set(array[, offset]) -> void
+     * - array (Array): any enumerable or array that is compatible with the Typed Arrays specification
+     * - offset (Number): an optional offset, in elements, into this data segment to begin copying the array
+     *
+     * Copies the data from +array+ into the +array+ property of this data segment, per the
+     * Typed Arrays specification.
+     **/
+    set: function(i, v) {
+      this.array.set.apply(this.array, arguments);
+    },
+    
+    /**
+     * Jax.DataSegment#subarray(begin, end) -> Jax.DataSegment
+     * - begin (Number): the start of the subarray, inclusive
+     * - end (Number): the end of the subarray, exclusive
+     *
+     * Constructs a new data segment from a subarray of this data segment with the specified range.
+     * This is effectively similar to calling the +subarray+ method of a typed array.
+     *
+     **/
+    subarray: function(begin, end) {
+      return new Jax.DataSegment(this.type, this.array.subarray(begin, end));
+    },
+    
+    toString: function() {
+      return "{array:"+this.array.toString()+"}";
+    }
+  });
+  
+  return klass;
+})();

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

@@ -0,0 +1,99 @@
+/**
+ * Jax.Events
+ * 
+ * Generic event listener functionality which is added to a number of Jax objects
+ * by default.
+ **/
+Jax.Events = (function() {
+  return {
+    /**
+     * mixin Jax.Events.Methods
+     *
+     * Methods which can be added to potential event emitters.
+     **/
+    Methods: {
+      /**
+       * Jax.Events.Methods#getEventListeners(type) -> Array
+       * - type (String): the type of event to retrieve listeners for.
+       *
+       * Returns an array containing all event listeners associated with the specified
+       * event type.
+       **/
+      getEventListeners: function(name) {
+        this.event_listeners = this.event_listeners || {};
+        return this.event_listeners[name] = this.event_listeners[name] || {length:0};
+      },
+      
+      /**
+       * Jax.Events.Methods#addEventListener(type, callback) -> Number
+       * - type (String): the type of event to listen for.
+       * - callback (Function): the callback function to receive the event
+       *
+       * Adds the specified callback to the list of event listeners to be called
+       * when the given event type is fired.
+       *
+       * Returns the numeric array index of the listener to be added.
+       **/
+      addEventListener: function(name, callback) {
+        var ary = this.getEventListeners(name);
+        var index = ary.length++;
+        ary[index] = callback;
+        return index;
+      },
+      
+      /**
+       * Jax.Events.Methods#removeEventListener(type, index) -> Function | undefined
+       * - type (String): the type of event to remove the listener from.
+       * - index (Number): the numeric index of the callback to be removed.
+       *
+       * Removes the callback represented by the index (as returned by
+       * Jax.Events.Methods#addEventListener) from the event listener of
+       * the specified type. Other event types are unaffected, even if they
+       * contain the exact same callback function.
+       *
+       * Returns the original callback function, or undefined if it was not found.
+       **/
+      removeEventListener: function(name, index) {
+        if (!name || index == undefined) throw new Error("both event type and listener index are required");
+        var ary = this.getEventListeners(name);
+        var func = ary[index];
+        if (ary[index]) delete ary[index];
+        // ary.splice(index, 1);
+        return func;
+      },
+      
+      /**
+       * Jax.Events.Methods#fireEvent(type[, event]) -> undefined
+       * - type (String): the type of event to fire
+       * - event (Object): an optional object to be passed as an argument
+       * to the event listeners.
+       *
+       * Fires an event. All listeners monitoring the specified event type
+       * will receive the event object as an argument. If specified, the
+       * event object's +type+ property is automatically assigned to the
+       * specified type unless the object already has a +type+ property.
+       * Examples:
+       *
+       *     this.addEventListener('loaded', function(obj) { alert(obj.type); });
+       *     this.fireEvent('loaded', { });
+       *     // "loaded"
+       *
+       *     this.addEventListener('loaded', function(obj) { alert(obj.type); });
+       *     this.fireEvent('loaded', {type:'none'});
+       *     // "none"
+       *
+       * Note that the callback is fired using +call+, so the +this+ object
+       * within a callback will represent the object that fired the event.
+       *
+       **/
+      fireEvent: function(name, event_object) {
+        var listeners = this.getEventListeners(name);
+        if (event_object && event_object.type == undefined)
+          event_object.type = name;
+        for (var i in listeners)
+          if (i == 'length') continue;
+          else listeners[i].call(this, event_object);
+      }
+    }
+  };
+})();

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

@@ -0,0 +1,316 @@
+/**
+ * class Jax.Framebuffer
+ *
+ * Used for rendering images off-screen and capturing the result.
+ **/
+Jax.Framebuffer = (function() {
+  function build(context, self) {
+    var handle = context.glCreateFramebuffer();
+    var width = self.options.width, height = self.options.height;
+
+    self.setHandle(context, handle);
+    context.glBindFramebuffer(GL_FRAMEBUFFER, handle);
+
+    // depth and stencil attachment
+    if (self.options.depth && self.options.stencil) {
+      handle.depthstencilbuffer = context.glCreateRenderbuffer();
+      context.glBindRenderbuffer(GL_RENDERBUFFER, handle.depthstencilbuffer);
+      context.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, width, height);
+      context.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, handle.depthstencilbuffer);
+      context.glBindRenderbuffer(GL_RENDERBUFFER, null);
+    }
+    
+    // depth attachment
+    if (self.options.depth && !self.options.stencil) {
+      handle.depthbuffer = context.glCreateRenderbuffer();
+      context.glBindRenderbuffer(GL_RENDERBUFFER, handle.depthbuffer);
+      context.glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);
+      context.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, handle.depthbuffer);
+      context.glBindRenderbuffer(GL_RENDERBUFFER, null);
+    }
+    
+    // stencil attachment
+    if (self.options.stencil && !self.options.depth) {
+      handle.stencilbuffer = context.glCreateRenderbuffer();
+      context.glBindRenderbuffer(GL_RENDERBUFFER, handle.stencilbuffer);
+      context.glRenderbufferStorage(GL_RENDERBUFFER, GL_STENCIL_INDEX8, width, height);
+      context.glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, handle.stencilbuffer);
+      context.glBindRenderbuffer(GL_RENDERBUFFER, null);
+    }
+    
+    // texture attachments
+    handle.textures = [];
+    var attachment = GL_COLOR_ATTACHMENT0;
+    for (var i = 0; i < self.options.colors.length; i++) {
+      var format = self.options.colors[i];
+      var texture_options = {
+        format:GL_RGBA,
+        width:width,
+        height:height,
+        min_filter:GL_LINEAR,
+        mag_filter:GL_LINEAR,
+        wrap_s:GL_CLAMP_TO_EDGE,
+        wrap_t:GL_CLAMP_TO_EDGE,
+        generate_mipmap:false
+      };
+      if (typeof(format) != "number") { texture_options = Jax.Util.normalizeOptions(format, texture_options); }
+      else { texture_options.format = format; }
+      handle.textures[i] = new Jax.Texture(texture_options);
+      
+      if (handle.textures[i].getTarget() == GL_TEXTURE_2D)
+        context.glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_2D, handle.textures[i].getHandle(context), 0);
+      else
+        context.glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+                handle.textures[i].getHandle(context), 0);
+      
+      attachment++;
+    }
+
+    checkStatus(context, self);
+  }
+  
+  function checkStatus(context, self) {
+    var status = context.glCheckFramebufferStatus(GL_FRAMEBUFFER);
+    self.unbind(context);
+    switch(status) {
+      case GL_FRAMEBUFFER_COMPLETE:
+        // success!
+        break;
+      case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+        throw new Error("Jax.Framebuffer: one or more attachments is incomplete. (GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT)");
+      case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+        throw new Error("Jax.Framebuffer: there are no images attached to the framebuffer. (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT)");
+      case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+        throw new Error("Jax.Framebuffer: all attachments must have the same dimensions. (GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS)");
+      case GL_FRAMEBUFFER_UNSUPPORTED:
+        throw new Error("Jax.Framebuffer: the requested framebuffer layout is unsupported on this hardware. (GL_FRAMEBUFFER_UNSUPPORTED)");
+      case (Jax.getGlobal()['GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER'] || 0x8cdb):
+        // a cryptic error that is not in the WebGL spec. Took me way too long to figure this out and I'm still not
+        // sure why it happens...
+        // but it seems to crop up primarily when no textures are attached.
+        // from opengl (not webgl) spec: The value of FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT must not be NONE for any
+        // color attachment point(s) named by DRAW_BUFFER.
+        throw new Error("Jax.Framebuffer: make sure the framebuffer has at least 1 texture attachment. (GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER)");
+      default:
+        var which;
+        for (which in context.gl)
+          if (context.gl[which] == status)
+            throw new Error("Jax.Framebuffer: an unknown error occurred. ("+status+" - "+which+")");
+        throw new Error("Jax.Framebuffer: an unknown error occurred. ("+status+")");
+    }
+  }
+  
+  return Jax.Class.create({
+    /**
+     * new Jax.Framebuffer([options])
+     * - options (Object): a generic object containing the following optional properties:
+     * 
+     *   * colors: an array of color formats such as GL_RGBA, GL_RGB, etc. The _colors_ array may
+     *             be empty if no color attachments are needed. Defaults to [GL_RGBA] unless _color_
+     *             is specified.
+     *             
+     *             Alternatively, an options object can be used. This object will be passed into
+     *             Jax.Texture().
+     *             
+     *   * color: optionally, in place of a colors array, a single color format as above. If both
+     *            _color_ and _colors_ are specified, _color_ is simply added to the _colors_ array.
+     *   * depth: true if a depth attachment is required, false otherwise. Defaults to false.
+     *   * stencil: true if a stencil attachment is required, false otherwise. Defaults to false.
+     *   * width: the width of the render and color buffers. All render and color buffers for a given
+     *            framebuffer must have the same width. Defaults to 512.
+     *   * height: the height of the render and color buffers. All render and color buffers for a given
+     *             framebuffer must have the same height. Defaults to 512.
+     *     
+     **/
+    initialize: function(options) {
+      var defaults = {
+        depth: false,
+        stencil: false,
+        width:512,
+        height:512
+      };
+      if (!(options && (options.color || options.colors))) defaults.colors = [GL_RGBA];
+      
+      this.handles = {};
+      this.options = options = Jax.Util.normalizeOptions(options, defaults);
+      if (options.color != undefined) {
+        if (options.colors != undefined) options.colors.push(options.color);
+        else options.colors = [options.color];
+        delete options.color;
+      }
+    },
+
+    /**
+     * Jax.Framebuffer#cubeFace(context, texIndex, faceEnum[, callback]) -> Jax.Framebuffer
+     * - context (Jax.Context): a Jax context
+     * - texIndex (number): the index of the cube map texture
+     * - faceEnum (enum): the cube map face to bind
+     * - callback (function): an optional callback. If given, the framebuffer will be automatically unbound
+     *                        after the callback returns. Otherwise, the framebuffer will remain bound.
+     *                        
+     * For cube map framebuffers only, this will bind the specified cube map face to its color buffer position.
+     * The faceEnum can be any of the following face enums:
+     * 
+     *     0: GL_TEXTURE_CUBE_MAP_POSITIVE_X
+     *     1: GL_TEXTURE_CUBE_MAP_NEGATIVE_X
+     *     2: GL_TEXTURE_CUBE_MAP_POSITIVE_Y
+     *     3: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
+     *     4: GL_TEXTURE_CUBE_MAP_POSITIVE_Z
+     *     5: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
+     * 
+     * Example:
+     * 
+     *     fb.bindCubeFace(context, 0, GL_TEXTURE_CUBE_MAP_POSITIVE_X, function() {
+     *       // render to +X cube face
+     *     });
+     *     fb.bindCubeFace(context, 0, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, function() {
+     *       // render to -Z cube face
+     *     });
+     **/
+    bindCubeFace: function(context, texIndex, faceEnum, callback) {
+      if (!this.getHandle(context)) build(context, this);
+      var texture = this.getHandle(context).textures[texIndex];
+      if (texture.options.target != GL_TEXTURE_CUBE_MAP)
+        throw new Error("Texture at index "+texIndex+" is not a cube map!");
+      
+      this.bind(context);
+      context.glFramebufferTexture2D(GL_FRAMEBUFFER, window['GL_COLOR_ATTACHMENT'+texIndex],
+              faceEnum, texture.getHandle(context), 0);
+      
+      if (callback) {
+        callback();
+        this.unbind(context);
+      }
+      
+      return this;
+    },
+    
+    /**
+     * Jax.Framebuffer#bind(context[, callback]) -> Jax.Framebuffer
+     * - context (Jax.Context): the context to bind this framebuffer to
+     * - callback (Function): an optional callback. If given, the framebuffer will
+     *                        be automatically unbound after the function returns.
+     *
+     * If a callback is not specified, the framebuffer will be bound and then returned.
+     * Otherwise, the framebuffer will be bound; the callback will be called; then the
+     * framebuffer will be automatically unbound prior to returning the framebuffer
+     * itself.
+     *
+     **/
+    bind: function(context, callback) {
+      if (!this.getHandle(context)) build(context, this);
+      context.glBindFramebuffer(GL_FRAMEBUFFER, this.getHandle(context));
+      
+      if (callback) {
+        callback.call(this);
+        this.unbind(context);
+      }
+      
+      return this;
+    },
+    
+    /**
+     * Jax.Framebuffer#unbind(context) -> Jax.Framebuffer
+     * - context (Jax.Context): the context to bind this framebuffer to
+     *
+     * Unbinds this framebuffer from the specified context. Note that this is
+     * unnecessary if Jax.Framebuffer#bind() was called with a callback.
+     **/
+    unbind: function(context) {            
+      context.glBindFramebuffer(GL_FRAMEBUFFER, null);
+      return this;
+    },
+    
+    /**
+     * Jax.Framebuffer#viewport(context) -> Jax.Framebuffer
+     * - context (Jax.Context): the context to set the viewport for
+     *
+     * Sets the viewport up for this framebuffer within the specified context
+     * according to the +width+ and +height+ options given for this framebuffer.
+     *
+     **/
+    viewport: function(context) {
+      context.glViewport(0,0,this.options.width,this.options.height);
+      return this;
+    },
+    
+    /**
+     * Jax.Framebuffer#getTexture(context[, index]) -> Jax.Texture
+     * - context (Jax.Context): the context to retrieve the texture for
+     * - index (Number): the numeric index of the texture to retrieve.
+     *                   Defaults to 0.
+     *
+     * Returns the specified instance of Jax.Texture associated with this
+     * framebuffer and the specified context. If index is not given, the
+     * first texture available is returned.
+     **/
+    getTexture: function(context, index) {
+      return this.getHandle(context) && this.getHandle(context).textures[index];
+    },
+    
+    /**
+     * Jax.Framebuffer#getTextureHandle(context[, index]) -> WebGLTexture
+     * - context (Jax.Context): the context to retrieve the texture handle for
+     * - index (Number): the numeric index of the texture handle to retrieve.
+     *                   Defaults to 0.
+     *
+     * Returns the WebGL texture handle associated with this
+     * framebuffer and the specified context. If index is not given, the
+     * first texture available is returned.
+     *
+     * This is equivalent to:
+     * 
+     *     framebuffer.getTexture(context, index).getHandle(context);
+     *
+     **/
+    getTextureHandle: function(context, index) {
+      return this.getTexture(context, index).getHandle(context);
+    },
+    
+    /** deprecated
+     * Jax.Framebuffer#getTextureBuffer(context, index) -> Jax.Texture
+     *
+     * This method is deprecated. See Jax.Framebuffer#getTexture instead.
+     **/
+    getTextureBuffer: function(context, index) {
+      alert("Jax.Framebuffer#getTextureBuffer(context, index) is deprecated.\n"+
+            "Please use Jax.Framebuffer#getTexture(context, index) instead.\n\n"+
+            "Stack trace:\n\n"+
+            (new Error().stack || "(unavailable)"));
+      return this.getTexture(context, index);
+    },
+    
+    /** deprecated
+     * Jax.Framebuffer#getTextureBufferHandle(context, index) -> WebGLTexture
+     *
+     * This method is deprecated. See Jax.Framebuffer#getTextureHandle instead.
+     **/
+    getTextureBufferHandle: function(context, index) {
+      alert("Jax.Framebuffer#getTextureBufferHandle(context, index) is deprecated.\n"+
+            "Please use Jax.Framebuffer#getTextureHandle(context, index) instead.\n\n"+
+            "Stack trace:\n\n"+
+            (new Error().stack || "(unavailable)"));
+      return this.getTextureHandle(context, index);
+    },
+    
+    /**
+     * Jax.Framebuffer#getHandle(context) -> WebGLFramebuffer | undefined
+     * - context (Jax.Context): the context the requested framebuffer handle is associated with
+     * 
+     * Returns the WebGLFramebuffer handle associated with the specified context.
+     **/
+    getHandle: function(context) { return this.handles[context.id]; },
+    
+    /**
+     * Jax.Framebuffer#getHandle(context, handle) -> Jax.Framebuffer
+     * - context (Jax.Context): the context the requested framebuffer handle is associated with
+     * - handle (WebGLFramebuffer): the WebGL framebuffer handle to use for the specified context
+     * 
+     * Assigns the specified handle to be used for the given context. This is a permanent
+     * assignment unless this method is called again.
+     *
+     * Returns this instance of Jax.Framebuffer.
+     **/
+    setHandle: function(context, handle) { this.handles[context.id] = handle; return this; }
+  });
+})();

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

@@ -0,0 +1,6 @@
+//= require_self
+//= require "jax/webgl/core/data_region"
+//= require "jax/webgl/core/buffer"
+//= require "jax/webgl/core/framebuffer"
+
+Jax.Core = {};