jax 1.1.1 → 2.0.0

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

@@ -0,0 +1,697 @@
+//= require "jax/webgl/core/events"
+//= require "jax/webgl/scene"
+
+/**
+ * class Jax.Camera
+ * includes Jax.Events.Methods
+ *
+ * Every object in Jax has a Camera associated with it, and is usually referred to simply
+ * as +camera+. Manipulating an object's camera is to manipulate the orientation of the
+ * object itself within the world.
+ *
+ * You can add event listeners to Jax.Camera to monitor its matrices for changes. Whenever
+ * a matrix changes, the object's orientation has been modified, so this is a good way to
+ * keep track of changes to an object's orientation. Add listeners like so:
+ *
+ *     obj = new Jax.Model( ... );
+ *     obj.camera.addEventListener('matrixUpdated', function() {
+ *       // the object's orientation has changed
+ *     });
+ *
+ * Note that no arguments are passed into the event listener in this case.
+ *
+ * See Jax.Events for more information about event listeners.
+ *
+ **/
+Jax.Camera = (function() {
+  var LOCAL_VIEW = [0,0,-1], LOCAL_UP = [0,1,0], LOCAL_RIGHT = [1,0,0];
+  
+  // 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 tmpRotQuat(self) {
+    return self._rotquat = self._rotquat || quat4.create();
+  }
+  
+  function storeVecBuf(self, buftype) {
+    var world = self.rotation;
+    
+    var position = (self._tmp[POSITION]);
+    var result   = (self._tmp[buftype]);
+    
+    vec3.set(self.position, position);
+
+    switch(buftype) {
+      case POSITION:
+        // we already have the position
+        return position;
+        break;
+      case VIEW:
+        quat4.multiplyVec3(world, LOCAL_VIEW, result);
+        break;
+      case RIGHT:
+        quat4.multiplyVec3(world, LOCAL_RIGHT, result);
+        break;
+      case UP:
+        quat4.multiplyVec3(world, LOCAL_UP, 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.stale = true;
+    self.frustum_up_to_date = false;
+  }
+  
+  function calculateMatrices(self) {
+    self.stale = false;
+
+    var pos = storeVecBuf(self, POSITION);
+    quat4.toMat4(self.rotation, self.matrices.mv);
+    mat4.translate(self.matrices.mv, vec3.negate(pos), self.matrices.mv);
+    mat4.inverse(self.matrices.mv);
+    
+    mat4.toInverseMat3(self.matrices.mv, self.matrices.n);
+    mat3.transpose(self.matrices.n);
+    
+    self.fireEvent('matrixUpdated');
+  }
+  
+  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.rotation = quat4.create([0,0,0,1]);
+      this.position = vec3.create([0,0,0]);
+      
+      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('updated', function() { matrixUpdated(this); });
+      this.reset();
+      this.setFixedYawAxis(true, vec3.UNIT_Y);
+    },
+    
+    /**
+     * Jax.Camera#setFixedYawAxis(useFixedYaw[, axis = vec3(0,1,0)]) -> Jax.Camera
+     * - useFixedYaw (Boolean): set to true if you wish to fix the yaw axis, false otherwise
+     * - axis (vec3): optional vec3 to use as the yaw axis.
+     *
+     * Due to the nature of 3D rotation, rotated objects are subject to a phenomenon known as
+     * camera drift (also called Z drift or "roll" drift). This occurs when a series of
+     * rotations cause the object's up vector to become rotated, affecting a "tilt" around
+     * the object's local Z axis.
+     *
+     * Since this is not generally the expected outcome, Jax.Camera will by default set a
+     * fixed yaw axis, which prevents drift. You can disable it or change the axis around
+     * which yaw will be constrained by calling this function.
+     **/
+    setFixedYawAxis: function(useFixedYaw, axis) {
+      this.fixed_yaw = useFixedYaw;
+      if (axis) this.fixed_yaw_axis = vec3.create(axis);
+    },
+
+    /**
+     * 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(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 200.
+     *   
+     **/
+    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    = 200;
+      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() {
+      switch(arguments.length) {
+        case 1: vec3.set(arguments[0], this.position); break;
+        case 3: vec3.set(arguments,    this.position); break;
+        default: throw new Error("Invalid arguments for Camera#setPosition");
+      }
+      
+      this.fireEvent('updated');
+
+      return this;
+    },
+
+    /**
+     * Jax.Camera#setDirection(vector) -> Jax.Camera
+     * Jax.Camera#setDirection(x,y,z) -> Jax.Camera
+     * - vector (vec3): the new direction that the camera will be pointing, relative to the camera
+     * - x (Number): the X component of the direction to point in, relative to the camera
+     * - y (Number): the Y component of the direction to point in, relative to the camera
+     * - z (Number): the Z component of the direction to point in, relative to the camera
+     *
+     **/
+    setDirection: function(vector) {
+      var vec;
+      if (arguments.length == 3) vec = arguments;
+      else vec = vec3.create(vector);
+      vec3.scale(vec, -1);
+      vec3.normalize(vec);
+      
+      if (this.fixed_yaw) {
+        var right = vec3.normalize(vec3.cross(this.fixed_yaw_axis, vec, vec3.create()));
+        var up = vec3.normalize(vec3.cross(vec, right, vec3.create()));
+        quat4.fromAxes(vec, right, up, this.rotation);
+      } else {
+        var rotquat = vec3.toQuatRotation(storeVecBuf(this, VIEW), vec, tmpRotQuat(this));
+        quat4.multiply(rotquat, this.rotation, this.rotation);
+      }
+      
+      quat4.normalize(this.rotation);
+      this.fireEvent('updated');
+      return this;
+    },
+    
+    /**
+     * 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. Note that this
+     * axis is relative to the camera; see +Jax.Camera#rotateWorld+ if you need to
+     * rotate around an axis in world space.
+     **/
+    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");
+      }
+      
+      return this.rotateWorld(amount, quat4.multiplyVec3(this.rotation, vec, this._tmp[0]));
+      
+      // var axis = storeVecBuf(this, RIGHT);
+      // this.rotateWorld(amount, axis);
+      // 
+      // var rotquat = quat4.fromAngleAxis(amount, vec, tmpRotQuat(this));
+      // quat4.normalize(rotquat);
+      // quat4.multiply(rotquat, this.rotation, this.rotation);
+      // 
+      // this.fireEvent('updated');
+      // return this;
+    },
+
+    /**
+     * Jax.Camera#rotateWorld(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. Note that this
+     * axis is in world space; see +Jax.Camera#rotate+ if you need to
+     * rotate around an axis relative to the camera's current orientation.
+     **/
+    rotateWorld: 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");
+      }
+      
+      var rotquat = quat4.fromAngleAxis(amount, vec, tmpRotQuat(this));
+      quat4.normalize(rotquat);
+      quat4.multiply(rotquat, this.rotation, this.rotation);
+      
+      this.fireEvent('updated');
+      return this;
+    },
+    
+    /**
+     * Jax.Camera#pitch(amount) -> Jax.Camera
+     * - amount (Number): rotation amount in radians
+     *
+     * Rotates around the camera's local X axis, resulting in a relative rotation up (positive) or down (negative).
+     **/
+    pitch: function(amount) {
+      var axis = storeVecBuf(this, RIGHT);
+      this.rotateWorld(amount, axis);
+    },
+
+    /**
+     * Jax.Camera#yaw(amount) -> Jax.Camera
+     * - amount (Number): rotation amount in radians
+     *
+     * Rotates around the camera's local Y axis, resulting in a relative rotation right (positive) or
+     * left (negative).
+     *
+     * If this camera uses a fixed yaw axis (true by default), that world-space axis is used instead of the
+     * camera's local Y axis.
+     *
+     * See also Jax.Camera#setFixedYawAxis
+     **/
+    yaw: function(amount) {
+      var axis;
+      if (this.fixed_yaw) axis = this.fixed_yaw_axis;
+      else                axis = storeVecBuf(this, UP);
+      this.rotateWorld(amount, axis);
+    },
+
+    /**
+     * Jax.Camera#roll(amount) -> Jax.Camera
+     * - amount (Number): rotation amount in radians
+     *
+     * Rotates around the camera's local Z axis, resulting in a relative tilting counter-clockwise (positive)
+     * or clockwise (negative).
+     **/
+    roll: function(amount) {
+      var axis = storeVecBuf(this, VIEW);
+      this.rotateWorld(amount, axis);
+    },
+
+    /**
+     * Jax.Camera#reorient(view[, position]) -> Jax.Camera
+     * - view (vec3): the new direction, relative to the camera, that the camera will be pointing
+     * - position (vec3): an optional new position for the camera, in world space.
+     *
+     * Reorients this camera to look in the given direction and optionally to be
+     * repositioned according to the given position vector.
+     *
+     * Returns this camera after modification..
+     **/
+    reorient: function(view, pos) {
+      if (pos) this.setPosition(pos);
+      this.setDirection(view);
+      return this;
+    },
+    
+    /**
+     * 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.
+     *
+     * **Deprecated.** Please use Jax.Camera#setDirection instead.
+     **/
+    orient: function(view, up) {
+      var pos = null;
+      
+      if (Jax.environment != Jax.PRODUCTION)
+        alert("Jax.Camera#orient is deprecated. Please use Jax.Camera#reorient instead.\n\n"+new Error().stack);
+      
+      switch(arguments.length) {
+        case 1:
+          view = store(this,     VIEW, view[0], view[1], view[2]);
+          up   = null;
+          break;
+        case 2:
+          view = store(this,     VIEW, view[0], view[1], view[2]);
+          up   = store(this,       UP,   up[0],   up[1],   up[2]);
+          break;
+        case 3:
+          if (typeof(arguments[0]) == "number") {
+            view = store(this,     VIEW,    arguments[0],    arguments[1],    arguments[2]);
+            up = null;
+          } 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]);
+          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");
+      }
+
+      if (pos) this.setPosition(pos);
+      this.setDirection(view);
+
+      return this;
+    },
+    
+    /**
+     * Jax.Camera#lookAt(point[, pos]) -> Jax.Camera
+     * - point (vec3): the point, in world space, to look at
+     * - pos (vec3): an optional point to reposition this camera at, in world space,
+     *               replacing its current position
+     *
+     **/
+    lookAt: function(point, pos) {
+      if (arguments.length > 2)
+        alert("Jax.Camera#lookAt with more than 2 arguments is deprecated. Please use only two arguments: the point to look at (a vec3) and an optional point to reposition the camera to (a vec3).\n\n"+new Error().stack);
+        
+      if (pos) this.setPosition(pos);
+      else pos = store(this, POSITION);
+      
+      var forward = this._tmp[FORWARD];
+      this.setDirection(vec3.subtract(point, pos, forward));
+    },
+
+    /**
+     * 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: 200
+     **/
+    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  || 200;
+      
+      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.
+     *
+     * If the matrix is outdated due to changes to the camera,
+     * it is automatically updated and then a 'matrixUpdated' event is fired.
+     **/
+    getTransformationMatrix: function() {
+      if (this.stale) calculateMatrices(this);
+      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.
+     *
+     * If the matrix is outdated due to changes to the camera,
+     * it is automatically updated and then a 'matrixUpdated' event is fired.
+     **/
+    getNormalMatrix: function() {
+      if (this.stale) calculateMatrices(this);
+      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.getTransformationMatrix(), 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#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.move(distance, storeVecBuf(this, RIGHT));
+      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 = storeVecBuf(this, VIEW);
+      vec3.add(vec3.scale(direction, distance, this._tmp[FORWARD]), this.position, this.position);
+      this.fireEvent('updated');
+      return this;
+    },
+    
+    /**
+     * Jax.Camera#projectMovement(forward[, strafe[, dest]]) -> vec3
+     * - forward (Number): the amount of forward movement. Use a negative number for going
+     *                     backwards.
+     * - strafe (Number): the amount of horizontal movement. Use a negative number for going
+     *                    left.
+     * - dest (vec3): an optional receiving vec3 to store the projected result. If omitted, a
+     *                new vec3 will be created.
+     *
+     * Projects the given movement amounts along this camera's view and right vectors, returning
+     * the result without actually modifying this Camera.
+     **/
+    projectMovement: function(forward, strafe, dest) {
+      if (!strafe) strafe = 0;
+      if (!dest) dest = vec3.create();
+      
+      var view = vec3.scale(storeVecBuf(this, VIEW), forward);
+      var right = vec3.scale(storeVecBuf(this, RIGHT), strafe);
+      vec3.set(this.position, dest);
+      vec3.add(view, dest, dest);
+      vec3.add(right, dest, dest);
+      
+      return dest;
+    },
+
+    /**
+     * 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.position[0] = this.position[1] = this.position[2] = 0;
+      this.rotation[0] = this.rotation[1] = this.rotation[2] = 0;
+      this.rotation[3] = 1;
+      this.fireEvent('updated');
+    }
+  });
+})();
+
+/** alias of: Jax.Camera#setDirection
+ * Jax.Camera#setViewVector(vector) -> Jax.Camera
+ **/
+Jax.Camera.prototype.setViewVector = Jax.Camera.prototype.setDirection;
+
+Jax.Camera.addMethods(Jax.Events.Methods);

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

@@ -0,0 +1 @@
+if (Jax.getGlobal()['WEBGL_CLEANUP']) Jax.getGlobal()['WEBGL_CLEANUP']();