jax 0.0.0.9 → 0.0.0.10

data/src/jax/prototype/extensions.js

@@ -1,142 +0,0 @@
-//= require "class"
-
-(function() {
-  /*
-    Delegator is instantiated by the class method #delegate with _this_ and _arguments_ as arguments.
-    It is effectively responsible for copying a set of methods into the destination object.
-    
-    @see Jax.Class.Methods#delegate
-   */
-  var Delegator = Jax.Class.create({
-    initialize: function(target, methods) {
-      this.methods = methods;
-      this.target = target;
-    },
-    
-    into: function(destination, dest_klass) {
-      /*
-        yes, we're using eval in here. But as this method is only called during setup, it's probably OK for the most
-        part. Note the caveat that if dest_klass is omitted and the dev is using regular expressions to match method
-        names, we have no choice but to put an eval into the alias chain for this.target#initialize. Not ideal but I
-        couldn't think of a better way to make it work.
-       */
-      var methods = {};
-      var method_name;
-      var alias_chain_regexps = [];
-      
-      for (var i = 0; i < this.methods.length; i++) {
-        if (typeof(this.methods[i]) == "string") {
-          /* it's not a regexp so this case is pretty straightforward */
-          method_name = this.methods[i];
-          methods[method_name] =
-            eval("(function() { return this."+destination+"."+method_name+".apply(this."+destination+", arguments); })");
-        } else if (this.methods[i].test) {
-          var method_regexp = this.methods[i];
-          /*
-            regexp -- this is harder because we don't know what klass _destination_ points to.
-            we have two choices: require an explicit klass argument, or assume the dev is prepared
-            to pay the overhead price of testing regexps and calling #eval within #initialize.
-            
-            let's do both: if explicit klass was given, use it. Else, set up an alias chain for #initialize.
-           */
-          
-          if (dest_klass) {
-            for (method_name in dest_klass.prototype) {
-              if (method_regexp.test(method_name)) {
-                methods[method_name] =
-                        eval("(function() { return this."+destination+"."+method_name+".apply(this."+destination+", arguments); })");
-              }
-            }
-          } else {
-            alias_chain_regexps.push(method_regexp);
-          }
-        }
-      }
-
-      /* add known methods */
-      this.target.addMethods(methods);
-      
-      if (alias_chain_regexps.length > 0) {
-        if (!this.target.alias_chain_regexps)
-        {
-          /* alias chain doesn't yet exist -- create it */
-          this.target.alias_chain_regexps = {};
-          var original_initialize_method = this.target.prototype.initialize;
-          var fn = "(function(){" +
-                     "if (original_initialize_method) original_initialize_method.apply(this, arguments);" +
-                     "var i, j, method_name, destination, method_regexp, self = this;" +
-                  
-                     "destination = this."+destination+";" +
-                     "for (i = 0; i < this.klass.alias_chain_regexps['"+destination+"'].length; i++) {" +
-                       "method_regexp = this.klass.alias_chain_regexps['"+destination+"'][i];" +
-                       "for (j in destination) {" +
-                         "method_name = j;" +
-                         "if (method_regexp.test(method_name)) " +
-                           "this[method_name] = eval('(function(){return self."+destination+".'+method_name+" +
-                                                    "'.apply(self."+destination+", arguments);})');" +
-                       "}" +
-                     "}" +
-                  "})";
-          
-          this.target.prototype.initialize = eval(fn);
-        }
-        /* else, alias chain exists; we only have to add method regexps */
-        
-        this.target.alias_chain_regexps[destination] = this.target.alias_chain_regexps[destination] || [];
-        for (i = 0; i < alias_chain_regexps.length; i++) {
-          this.target.alias_chain_regexps[destination].push(alias_chain_regexps[i]);
-        }
-      }
-    }
-  });
-    
-  /*
-    Prototype doesn't seem to have a way to add instance methods to all classes (a generic base object would have
-    been nice) so we have to hack it in by aliasing ::create and then replacing it.
-  */
-  Jax.Class.InstanceMethods = {
-    isKindOf: function(klass) {
-      return(this instanceof klass);
-    }
-  };
-
-  var original_create = Jax.Class.create;
-  Jax.Class.create = function() {
-    var klass = original_create.apply(Jax.Class, arguments);
-    klass.prototype.klass = klass;
-    klass.addMethods(Jax.Class.InstanceMethods);
-    Jax.Util.addRequestedHelpers(klass);
-
-    return klass;
-  };
-  
-  /**
-   * Jax.Class.delegate() -> undefined
-   *
-   * This is a class method of all Jax classes.
-   *
-   * Delegates one or more methods into properties of the class. For instance,
-   * the following:
-   * 
-   *     MyClass.delegate("sayHello").into("person");
-   *
-   * will create a +sayHello+ method in the +MyClass+ class that internally calls
-   * 
-   *     this.person.sayHello(...)
-   *
-   * and returns the results.
-   *
-   * There are several other variants:
-   *
-   *     klass.delegate(/regular expression/).into("property_name");
-   *       // delegates any method name in +property_name+ that matches the expression
-   * 
-   *     klass.delegate("one", "two").into("property_name");
-   *       // delegates both 'one' and 'two' methods into +property_name+
-   *
-   *
-   **/
-  Jax.Class.Methods.delegate = function() {
-    return new Delegator(this, arguments);
-  };
-})();

data/src/jax/vendor/ejs.js

@@ -1,4 +0,0 @@
-{
-  //= require "../../../vendor/ejs/src/ejs"
-  //= require "../../../vendor/ejs/src/view"
-};

data/src/jax/vendor/glMatrix.js

@@ -1,3 +0,0 @@
-{
-  //= require "../../../vendor/glmatrix/glMatrix"
-};

data/src/jax/webgl.js

@@ -1,98 +0,0 @@
-/*
-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 "vendor/glMatrix"
-
-window['WEBGL_CONTEXT_NAME'] = "experimental-webgl";
-window['WEBGL_CONTEXT_OPTIONS'] = {stencil:true};
-window['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) {
-    document.location.pathname = "/webgl_not_supported.html";
-    throw new Error("WebGL is disabled or is not supported by this browser!");
-  }
-
-  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 */
-        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);"
-                 + "      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());"
-                 + "      alert(e+\"\\n\\n\"+e.stack);"
-                 + "      this.handleRenderError('"+method_name+"', args, e);"
-                 + "    }"
-                 + "  }"
-                 + "  return result;"
-                 + "})";
-
-        GL_METHODS[camelized_method_name] = eval("("+func+")");
-      }
-      else
-      {
-        /* define the GL enums globally so we don't need a context to reference them */
-        if (!/[a-z]/.test(method_name)) // no lowercase letters
-          window[('GL_'+method_name)] = gl[method_name];
-      }
-    }
-
-    /* define some extra globals that the above didn't generate */
-//    window['GL_MAX_VERTEX_ATTRIBS'] = gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
-    window['GL_DEPTH_COMPONENT'] = gl.DEPTH_COMPONENT || gl.DEPTH_COMPONENT16;
-    window['GL_TEXTURES'] = [];
-    for (i = 0; i < 32; i++) window['GL_TEXTURES'][i] = gl["TEXTURE"+i];
-    window['GL_MAX_ACTIVE_TEXTURES'] = gl.getParameter(gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS);
-  }
-
-  /* import other webgl files */
-  /*
-    note that because of the positioning here, all files in the webgl/ subdirectory will have access to a
-    private, temporary 'gl' context which will be unloaded after they have been loaded into memory.
-   */
-  //= require "webgl/shader_chain"
-  //= require "webgl/material"
-  //= require "webgl/mesh"
-  //= require "webgl/camera"
-  //= require "webgl/world"
-  //= require "webgl/texture"
-
-  /* clean up after ourselves */
-  if (temporaryBody)
-    body.parentNode.removeChild(body);
-  else
-    body.removeChild(canvas);
-})();

data/src/jax/webgl/camera.js

@@ -1,526 +0,0 @@
-//= require "core/events"
-//= require "scene"
-
-/**
- * class Jax.Camera
- **/
-Jax.Camera = (function() {
-  // used in tandem with _tmp[], see below
-  var POSITION = 0, VIEW = 1, RIGHT = 2, UP = 3, FORWARD = 4, SIDE = 5;
-  
-  /*
-    handles storing data in the private _vecbuf, which is used solely to prevent
-    unnecessary allocation of temporary vectors. Note that _vecbuf is used for many
-    operations and data persistence not guaranteed (read: improbable).
-   */
-  function store(self, buftype) {
-    if (arguments.length == 2) {
-      // no x,y,z given -- find it
-      return storeVecBuf(self, buftype);
-    }
-    var buf = self._tmp[buftype];
-    buf[0] = arguments[2];
-    buf[1] = arguments[3];
-    buf[2] = arguments[4];
-    return buf;
-  }
-  
-  function storeVecBuf(self, buftype) {
-    var world = self.matrices.mv;
-    
-    var position = (self._tmp[POSITION]);
-    var result   = (self._tmp[buftype]);
-    
-    // position is 0,0,0 in eye space. Convert that to world space.
-    position[0] = position[1] = position[2] = 0;
-    mat4.multiplyVec3(world, position, position);
-
-    switch(buftype) {
-      case POSITION:
-        // we already have the position
-        return position;
-        break;
-      case VIEW:
-        // relative view vector is [0,0,-1] -- convert that to world coords
-        result[0] = result[1] = 0; result[2] = -1;
-        mat4.multiplyVec3(world, result, result);
-        vec3.direction(result, position, result);
-        break;
-      case RIGHT:
-        // relative right vector is [1,0,0] -- convert that to world coords
-        result[0] = 1; result[1] = result[2] = 0;
-        mat4.multiplyVec3(world, result, result);
-        vec3.direction(result, position, result);
-        break;
-      case UP:
-        // relative up vector is [0,1,0] -- convert that to world coords
-        result[1] = 1; result[0] = result[2] = 0;
-        mat4.multiplyVec3(world, result, result);
-        vec3.direction(result, position, result);
-        break;
-      default:
-        throw new Error("Unexpected buftype: "+buftype);
-    }
-    return result;
-  }
-  
-  function matrixUpdated(self) {
-    // Callback fires whenever one of the camera's matrices has changed.
-    // We need to use this to update other variables like normal matrix, frustum, etc,
-    // but we don't actually update them here because the user may be making several
-    // changes to the camera in sequence (and those updates would be useless).
-    // Instead we'll mark them as out-of-date and let their respective getters do the
-    // work.
-    // update the normal matrix
-    self.normal_matrix_up_to_date = false;
-    self.frustum_up_to_date       = false;
-  }
-  
-  return Jax.Class.create({
-    initialize: function() {
-      /**
-       * Jax.Camera#projection -> Object
-       * This property is undefined until either #ortho() or #perspective() is called. After a projection matrix
-       * has been initialized, this object will contain various metadata about the projection matrix, such as
-       * the width and height of the viewport.
-       * 
-       * For orthogonal projection matrices, it contains the following information:
-       *     width, height, depth
-       *     left, right
-       *     top, bottom
-       *     near, far
-       *     
-       * For perspective projection matrices, it contains the following information:
-       *     width, height
-       *     near, far
-       *     fov (in degrees)
-       *     
-       * Note that this information is here for reference only; modifying it will in no way modify the projection
-       * matrix itself. (For that, you need to make another call to #ortho() or #perspective().) Therefore,
-       * changing this object's properties is not recommended because doing so would no longer accurately reflect
-       * the parameters of the real projection matrix.
-       * 
-       * Subsequent calls to #perspective() or #ortho() will cause this object to be regenerated. Because of this,
-       * it is not recommended to store any persistent data in this object.
-       **/
-      
-      /* used for temporary storage, just to avoid repeatedly allocating temporary vectors */
-      this._tmp = [ vec3.create(), vec3.create(), vec3.create(), vec3.create(), vec3.create(), vec3.create() ];
-      
-      this.matrices = { mv: mat4.identity(mat4.create()), p : mat4.identity(mat4.create()), n : mat3.create() };
-      this.frustum = new Jax.Scene.Frustum(this.matrices.mv, this.matrices.p);
-      
-      this.addEventListener('matrixUpdated', function() { matrixUpdated(this); });
-      this.reset();
-    },
-
-    /**
-     * Jax.Camera#getFrustum() -> Jax.Scene.Frustum
-     * Returns the frustum for the camera. If the frustum is out of date, it will
-     * be refreshed.
-     **/
-    getFrustum: function() {
-      if (!this.frustum_up_to_date) this.frustum.update();
-      this.frustum_up_to_date = true;
-      return this.frustum;
-    },
-
-    /**
-     * Jax.Camera#getPosition() -> vec3
-     * Returns the current world space position of this camera.
-     **/
-    getPosition:   function() { return vec3.create(storeVecBuf(this, POSITION)); },
-
-    /**
-     * Jax.Camera#getViewVector() -> vec3
-     * Returns the view vector relative to this camera.
-     **/
-    getViewVector: function() { return vec3.create(storeVecBuf(this, VIEW)); },
-    
-    /**
-     * Jax.Camera#getUpVector() -> vec3
-     * Returns the up vector relative to this camera.
-     **/
-    getUpVector:   function() { return vec3.create(storeVecBuf(this, UP)); },
-    
-    /**
-     * Jax.Camera#getRightVector() -> vec3
-     * Returns the right vector relative to this camera.
-     **/
-    getRightVector:function() { return vec3.create(storeVecBuf(this, RIGHT)); },
-
-    /**
-     * Jax.Camera#ortho(options) -> undefined
-     * - options (Object): the set of parameters used to calculate the projection matrix
-     * 
-     * Sets up an orthographic projection matrix. Objects will not appear to shrink as they grow
-     * more distant from the camera in this mode. This mode is frequently used by high-precision
-     * tools such as modeling programs, and is commonly found in games when rendering UIs,
-     * crosshairs and the like.
-     * 
-     * * _top_ - the topmost coordinate visible on the scren. Defaults to 1.
-     * * _left_ - the leftmost coordinate visible on the screen. Defaults to -1.
-     * * _right_ - the rightmost coordinate visible on the screen. Defaults to 1.
-     * * _bottom_ - the bottommost coordinate visible on the screen. Defaults to -1.
-     * * _near_ - the nearest coordinate visible. Defaults to 0.01.
-     * * _far_ the furthest coordinate visible. Defaults to 2000.
-     *   
-     **/
-    ortho: function(options) {
-      if (typeof(options.left)   == "undefined") options.left   = -1;
-      if (typeof(options.right)  == "undefined") options.right  =  1;
-      if (typeof(options.top)    == "undefined") options.top    =  1;
-      if (typeof(options.bottom) == "undefined") options.bottom = -1;
-      if (typeof(options.far)    == "undefined") options.far    = 2000;
-      options.near = options.near || 0.01;
-      
-      mat4.ortho(options.left, options.right, options.bottom, options.top, options.near, options.far, this.matrices.p);
-      this.projection = {
-        width: options.right - options.left,
-        height: options.top - options.bottom,
-        depth: options.near - options.far,
-        left: options.left,
-        right: options.right,
-        near: options.near,
-        far: options.far,
-        top: options.top,
-        bottom: options.bottom
-      };
-      this.fireEvent('matrixUpdated');
-    },
-
-    /**
-     * Jax.Camera#setPosition(positionVector) -> undefined
-     * - positionVector (vec3): a vector representing the new position of the camera in world coordinates.
-     * Jax.Camera#setPosition(x, y, z) -> undefined
-     * - x (Number): the new X coordinate in world coordinates
-     * - y (Number): the new Y coordinate in world coordinates
-     * - z (Number): the new Z coordinate in world coordinates
-     * 
-     * Sets the position of this camera.
-     **/
-    setPosition: function() {
-      var vec = vec3.create();
-      switch(arguments.length) {
-        case 1: vec3.set(arguments[0], vec); break;
-        case 3: vec3.set(arguments,    vec); break;
-        default: throw new Error("Invalid arguments for Camera#setPosition");
-      }
-      
-      this.orient(this.getViewVector(), this.getUpVector(), vec);
-
-      return this;
-    },
-
-    /**
-     * Jax.Camera#setDirection(vector) -> Jax.Camera
-     * - vector (vec3): the new direction that the camera will be pointing,
-     *                  in world space
-     **/
-    setDirection: function(vector) {
-      return this.orient(vector);
-    },
-
-    /**
-     * Jax.Camera#orient(viewVector, upVector[, positionVector]) -> Jax.Camera
-     * - viewVector (vec3): the new direction that the camera will be pointing
-     * - upVector (vec3): the new "up" direction perpendicular to the view
-     * - positionVector (vec3): optionally, a new position for the camera
-     * Jax.Camera#orient(vx, vy, vz, ux, uy, uz[, px, py, pz]) -> Jax.Camera
-     * 
-     * Reorients this camera to be looking in the specified direction.
-     * Optionally, repositions this camera.
-     **/
-    orient: function(view, up) {
-      var pos;
-      
-      switch(arguments.length) {
-        case 1:
-          view = store(this,     VIEW, view[0], view[1], view[2]);
-          up   = store(this,       UP);
-          pos  = store(this, POSITION);
-          break;
-        case 2:
-          view = store(this,     VIEW, view[0], view[1], view[2]);
-          up   = store(this,       UP,   up[0],   up[1],   up[2]);
-          pos  = store(this, POSITION);
-          break;
-        case 3:
-          if (typeof(arguments[0]) == "number") {
-            view = store(this,     VIEW,    arguments[0],    arguments[1],    arguments[2]);
-            up   = store(this,       UP);
-            pos  = store(this, POSITION);
-          } else {
-            view = store(this,     VIEW,         view[0],         view[1],         view[2]);
-            up   = store(this,       UP,           up[0],           up[1],           up[2]);
-            pos  = store(this, POSITION, arguments[2][0], arguments[2][1], arguments[2][2]);
-          }
-          break;
-        case 6:
-          view = store(this,     VIEW, arguments[0], arguments[1], arguments[2]);
-          up   = store(this,       UP, arguments[3], arguments[4], arguments[5]);
-          pos  = store(this, POSITION);
-          break;
-        case 9:
-          view = store(this,     VIEW, arguments[0], arguments[1], arguments[2]);
-          up   = store(this,       UP, arguments[3], arguments[4], arguments[5]);
-          pos  = store(this, POSITION, arguments[6], arguments[7], arguments[8]);
-          break;
-        default:
-          throw new Error("Unexpected arguments for Camera#orient");
-      }
-      
-      vec3.add(pos,view,view);
-      this.lookAt(view, up, pos);
-      return this;
-    },
-    
-    lookAt: function(point, up, pos) {
-      up  = up  || store(this, UP);
-      pos = pos || store(this, POSITION);
-      
-      /*
-        I can't seem to get mat4.lookAt() to work as expected. I suspect that the forward vector is not
-        calculated properly, as it seems to reverse the operands. Dunno if this is a bug or a misunderstanding
-        in expectations, but either way I've decided not to use it, and adapted this code from:
-          GLH at http://www.opengl.org/wiki/GluLookAt_code 
-       */
-      var forward = this._tmp[FORWARD], side = this._tmp[SIDE];
-      var matrix2 = this.matrices.mv;
-      
-      vec3.subtract(point, pos, forward);
-
-      // check whether up is parallel with view. If so, we can't possibly use up so
-      // we must recalculate up from the current side. We don't simply throw an error
-      // because the user may not be at fault. (Example: this.orient([0,-1,0]) infers
-      // the current up, which defaults to [0,1,0].)
-      var dot = vec3.dot(forward, up);
-      if (!isNaN(dot) && Math.abs(dot) > (1 - Math.EPSILON))
-        vec3.cross(store(this, RIGHT), forward, up);
-
-      vec3.normalize(forward);
-      // side = forward x up
-      vec3.cross(forward, up, side);
-      vec3.normalize(side);
-      // recompute up as: up = side x forward
-      vec3.cross(side, forward, up);
-      matrix2[0] = side[0];
-      matrix2[4] = side[1];
-      matrix2[8] = side[2];
-      matrix2[12]= 0;
-      matrix2[1] = up[0];
-      matrix2[5] = up[1];
-      matrix2[9] = up[2];
-      matrix2[13]= 0;
-      matrix2[2] = -forward[0];
-      matrix2[6] = -forward[1];
-      matrix2[10]= -forward[2];
-      matrix2[14]= 0.0;
-      matrix2[3] = matrix2[7] = matrix2[11] = 0;
-      matrix2[15] = 1;
-      mat4.translate(matrix2, vec3.negate(pos));
-      mat4.inverse(matrix2);
-      
-      this.fireEvent('matrixUpdated');
-    },
-
-    /**
-     * Jax.Camera#perspective(options) -> undefined
-     * - options (Object): a generic object whose properties will be used to set up the
-     *                     projection matrix.
-     * 
-     * Sets up a traditional perspective view for this camera. Objects will appear to be
-     * smaller as they get further away from the camera.
-     * 
-     * Options include:
-     *   * _width_ - the width of the camera, in pixels. Required.
-     *   * _height_ - the height of the camera, in pixels. Required.
-     *   * _fov_ - the angle of the field of view, in degrees. Default: 45
-     *   * _near_ - the distance of the near plane from the camera's actual position. Objects
-     *     closer to the camera than this will not be seen, even if they are technically in
-     *     front of the camera itself. Default: 0.01
-     *   * _far_ - the distance of the far plane from the camera's actual position. Objects
-     *     further away from the camera than this won't be seen. Default: 2000
-     **/
-    perspective: function(options) {
-      options = options || {};
-      if (!options.width) throw new Error("Expected a screen width in Jax.Camera#perspective");
-      if (!options.height)throw new Error("Expected a screen height in Jax.Camera#perspective");
-      options.fov  = options.fov  || 45;
-      options.near = options.near || 0.01;
-      options.far  = options.far  || 2000;
-      
-      var aspect_ratio = options.width / options.height;
-      mat4.perspective(options.fov, aspect_ratio, options.near, options.far, this.matrices.p);
-      this.projection = {
-        width: options.width, height: options.height,
-        near: options.near,   far: options.far,
-        fov: options.fov
-      };
-      this.fireEvent('matrixUpdated');
-    },
-
-    /**
-     * Jax.Camera#getTransformationMatrix() -> mat4
-     * 
-     * Returns the transformation matrix. This matrix represents the camera's position and
-     * orientation in the world.
-     **/
-    getTransformationMatrix: function() { return this.matrices.mv; },
-
-    /**
-     * Jax.Camera#getProjectionMatrix() -> mat4
-     * 
-     * Returns the projection matrix. This matrix represents the projection of the world
-     * onto a screen.
-     **/
-    getProjectionMatrix: function() { return this.matrices.p; },
-
-    /**
-     * Jax.Camera#getNormalMatrix() -> mat3
-     * 
-     * Returns the normal matrix, which is defined as the transpose of the inverse of the
-     * transformation matrix.
-     * 
-     * This matrix is commonly used in lighting calculations.
-     **/
-    getNormalMatrix: function() {
-      if (!this.normal_matrix_up_to_date) {
-        mat4.toInverseMat3(this.getTransformationMatrix(), this.matrices.n);
-        mat3.transpose(this.matrices.n);
-      }
-      this.normal_matrix_up_to_date = true;
-      return this.matrices.n;
-    },
-
-    /**
-     * Jax.Camera#unproject(x, y[, z]) -> [[nearx, neary, nearz], [farx, fary, farz]]
-     * - x (Number): X coordinate in pixels
-     * - y (Number): Y coordinate in pixels
-     * 
-     * Calculates a line segment in world space of the given pixel location. One end of the
-     * line segment represents the nearest world space point to which the pixel corresponds,
-     * while the other end of the line segment represents the farthest visible point, depending
-     * on the near and far planes of the projection matrix.
-     * 
-     * You can also find a point at an arbitrary distance by passing a third argument representing
-     * the distance, Z, to travel from the near plane towards the far plane. Z should be a number
-     * between 0 and 1 (so think of it as a percentage). In this form, only one set of coordinates
-     * is returned: the actual world space position of the specified coordinate.
-     * 
-     * This function was adapted from gluUnproject(), found at
-     * http://www.opengl.org/wiki/GluProject_and_gluUnProject_code
-     **/
-    unproject: function(winx, winy, winz) {
-      // winz is either 0 (near plane), 1 (far plane) or somewhere in between.
-      // if it's not given a value we'll produce coords for both.
-      if (typeof(winz) == "number") {
-        winx = parseFloat(winx);
-        winy = parseFloat(winy);
-        winz = parseFloat(winz);
-      
-        var inf = [];
-        var mm = this.matrices.mv, pm = this.matrices.p;
-        var viewport = [0, 0, pm.width, pm.height];
-    
-        //Calculation for inverting a matrix, compute projection x modelview; then compute the inverse
-        var m = mat4.set(mm, mat4.create());
-        
-        mat4.inverse(m, m); // WHY do I have to do this? --see Jax.Context#reloadMatrices
-        mat4.multiply(pm, m, m);
-        mat4.inverse(m, m);
-    
-        // Transformation of normalized coordinates between -1 and 1
-        inf[0]=(winx-viewport[0])/viewport[2]*2.0-1.0;
-        inf[1]=(winy-viewport[1])/viewport[3]*2.0-1.0;
-        inf[2]=2.0*winz-1.0;
-        inf[3]=1.0;
-    
-        //Objects coordinates
-        var out = vec3.create();
-        mat4.multiplyVec4(m, inf, out);
-        if(out[3]==0.0)
-           return null;
-    
-        out[3]=1.0/out[3];
-        return [out[0]*out[3], out[1]*out[3], out[2]*out[3]];
-      }
-      else
-        return [this.unproject(winx, winy, 0), this.unproject(winx, winy, 1)];
-    },
-
-    /**
-     * Jax.Camera#rotate(amount, x, y, z) -> rotated camera
-     * - amount (Number): amount to rotate, in radians
-     * - x (Number): X coordinate of the axis around which to rotate
-     * - y (Number): Y coordinate of the axis around which to rotate
-     * - z (Number): Z coordinate of the axis around which to rotate
-     * Jax.Camera.rotate(amount, vector) -> rotated camera
-     * - amount (Number): amount to rotate, in radians
-     * - vector (vec3): vector form of the axis around which to rotate
-     * 
-     * Rotates the camera by the specified amount around some axis.
-     **/
-    rotate: function() {
-      var amount = arguments[0];
-      var vec;
-      switch(arguments.length) {
-        case 2: vec = arguments[1]; break;
-        case 4: vec = this._tmp[0]; vec[0] = arguments[1]; vec[1] = arguments[2]; vec[2] = arguments[3];  break;
-        default: throw new Error("Invalid arguments");
-      }
-      
-      if      (vec[1] == 0 && vec[2] == 0) mat4.rotateX(this.matrices.mv, amount*vec[0], this.matrices.mv);
-      else if (vec[0] == 0 && vec[2] == 0) mat4.rotateY(this.matrices.mv, amount*vec[1], this.matrices.mv);
-      else if (vec[0] == 0 && vec[1] == 0) mat4.rotateZ(this.matrices.mv, amount*vec[2], this.matrices.mv);
-      else                                 mat4.rotate (this.matrices.mv, amount,   vec, this.matrices.mv);
-      
-      this.fireEvent('matrixUpdated');
-      return this;
-    },
-
-    /**
-     * Jax.Camera#strafe(distance) -> the translated camera
-     * - distance (Number): the distance to move. If positive, the camera will move "right";
-     *                      if negative, the camera will move "left".
-     * 
-     * Causes the camera to strafe, or move "sideways" along the right vector.
-     **/
-    strafe: function(distance) {
-      this._tmp[FORWARD][0] = 1;
-      this._tmp[FORWARD][1] = 0;
-      this._tmp[FORWARD][2] = 0;
-      this.move(distance, this._tmp[FORWARD]);
-      return this;
-    },
-
-    /**
-     * Jax.Camera#move(distance[, direction]) -> the translated camera
-     * - distance (Number): the distance to move. If positive, the camera will move "forward"
-     *                      along the direction vector; if negative, it will move "backward".
-     * - direction (vec3): the vector to move along. If not specified, this will default to
-     *                     the camera's view vector. That is, it will default to the direction
-     *                     the camera is pointing.
-     **/
-    move: function(distance, direction) {
-      if (!direction) {
-        direction = this._tmp[FORWARD];
-        direction[0] = 0;
-        direction[1] = 0;
-        direction[2] = -1;
-      }
-      mat4.translate(this.matrices.mv, vec3.scale(direction, distance), this.matrices.mv);
-      this.fireEvent('matrixUpdated');
-      return this;
-    },
-
-    /**
-     * Jax.Camera#reset() -> the reset camera
-     * Resets this camera by moving it back to the origin and pointing it along the negative
-     * Z axis with the up vector along the positive Y axis.
-     **/
-    reset: function() { this.lookAt([0,0,-1], [0,1,0], [0,0,0]); }
-  });
-})();
-
-Jax.Camera.addMethods(Jax.Events.Methods);