jax 0.0.0.9 → 0.0.0.10

data/src/jax/webgl/mesh.js

@@ -1,427 +0,0 @@
-//= require "core"
-
-/**
- * class Jax.Mesh
- * 
- * Example:
- * 
- *     var mesh = new Jax.Mesh({
- *       init: function(vertices, colors, textureCoords, normals, indices) {
- *          // all of the arguments are arrays. If you don't intend to use one,
- *          // simply don't populate it with data. For instance, if your mesh
- *          // does not use vertex indices, don't add any data to the indices
- *          // array.
- *          
- *          // Colors will default to white if they are not populated.
- *          
- *          // A simple, red, opaque quad:
- *          vertices.push(-1, -1, 0); colors.push(1, 0, 0, 1);
- *          vertices.push(-1,  1, 0); colors.push(1, 0, 0, 1);
- *          vertices.push( 1,  1, 0); colors.push(1, 0, 0, 1);
- *          vertices.push( 1, -1, 0); colors.push(1, 0, 0, 1);
- *       }
- *     });
- *     
- * You can also subclass Mesh directly:
- * 
- *     var Quad = Jax.Class.create(Jax.Mesh, {
- *       init: function(vertices, colors, textureCoords, normals, indices) {
- *          // ...
- *       }
- *     });
- **/
-Jax.Mesh = (function() {
-  function setColorCoords(self, count, color, coords) {
-    var i, j;
-    var num_colors = color.length;
-    if (num_colors > 4) throw new Error("Color should have at most 4 components");
-    for (i = 0; i < count*4; i += 4)
-    {
-      for (j = 0; j < num_colors; j++)
-        coords[i+j] = color[j];
-      for (j = num_colors; j < 4; j++) {
-        coords[i+j] = 1;
-      }
-    }
-  }
-  
-  function makeTangentBuffer(self) {
-    var normals = self.getNormalBuffer();
-    var vertices = self.getVertexBuffer();
-    var texcoords = self.getTextureCoordsBuffer();
-    var indices = self.getIndexBuffer();
-    if (!normals || !vertices || !texcoords) return null;
-
-    var tangentBuffer = self.buffers.tangent_buffer;
-    normals = normals.js;
-    vertices = vertices.js;
-    texcoords = texcoords.js;
-    if (indices) indices = indices.js;
-    
-    var tangents = tangentBuffer ? tangentBuffer.js : [];
-    var tan1 = [], tan2 = [], a;
-    var v1 = vec3.create(), v2 = vec3.create(), v3 = vec3.create();
-    var w1 = [], w2 = [], w3 = [];
-    var vertcount;
-    var x1, x2, y1, y2, z1, z2, s1, s2, t1, t2, r;
-    var dif = [];
-    var sdir = vec3.create(), tdir = vec3.create();
-    
-    function setv(v, a) { v[0] = vertices[a*3];  v[1] = vertices[a*3+1];  v[2] = vertices[a*3+2]; }
-    function setw(w, a) { w[0] = texcoords[a*2]; w[1] = texcoords[a*2+1]; }
-    function sett1(a) { tan1[a] = tan1[a] || vec3.create(); vec3.add(tan1[a], sdir, tan1[a]); }
-    function sett2(a) { tan2[a] = tan2[a] || vec3.create(); vec3.add(tan2[a], tdir, tan2[a]); }
-    function findTangentVector(a1, a2, a3) {
-      if (indices) { a1 = indices[a1]; a2 = indices[a2]; a3 = indices[a3]; }
-      
-      setv(v1, a1); setv(v2, a2); setv(v3, a3);
-      setw(w1, a1); setw(w2, a2); setw(w3, a3);
-      x1 = v2[0] - v1[0]; x2 = v3[0] - v1[0];
-      y1 = v2[1] - v1[1]; y2 = v3[1] - v1[1];
-      z1 = v2[2] - v1[2]; z2 = v3[2] - v1[2];
-      s1 = w2[0] - w1[0]; s2 = w3[0] - w1[0];
-      t1 = w2[1] - w1[1]; t2 = w3[1] - w1[1];
-      r = 1.0 / (s1 * t2 - s2 * t1);
-      
-      sdir[0] = (t2 * x1 - t1 * x2) * r; sdir[1] = (t2 * y1 - t1 * y2) * r; sdir[2] = (t2 * z1 - t1 * z2) * r;
-      tdir[0] = (s1 * x2 - s2 * x1) * r; tdir[1] = (s1 * y2 - s2 * y1) * r; tdir[2] = (s1 * z2 - s2 * z1) * r;
-      if (isNaN(sdir[0]) || isNaN(sdir[1]) || isNaN(sdir[2]) ||
-          isNaN(tdir[0]) || isNaN(tdir[1]) || isNaN(tdir[2]) )
-      {
-        // this only seems to happen when dealing with degenerate triangles
-        // ...which seems to be fairly common. So, let's see what happens if
-        // we just set the offending vectors to zero.
-        sdir[0] = sdir[1] = sdir[2] = tdir[0] = tdir[1] = tdir[2] = 0;
-      }
-      sett1(a1); sett1(a2); sett1(a3);
-      sett2(a1); sett2(a2); sett2(a3);
-    }
-    
-    vertcount = indices ? indices.length : normals.length / 3;
-    /* we need to pass the vertices into findTangentVector differently depending on draw mode */
-    switch(self.draw_mode) {
-      case GL_TRIANGLE_STRIP:
-        for (a = 2; a < vertcount; a += 2) {
-          findTangentVector(a-2, a-1, a);
-          findTangentVector(a, a-1, a+1);
-        }
-        break;
-      case GL_TRIANGLES:
-        for (a = 0; a < vertcount; a += 3)
-          findTangentVector(a, a+1, a+2);
-        break;
-      case GL_TRIANGLE_FAN:
-        for (a = 2; a < vertcount; a++)
-          findTangentVector(0, a-1, a);
-        break;
-      default:
-        throw new Error("Cannot calculate tangent space for draw mode: "+Jax.Util.enumName(self.draw_mode));
-    }
-
-    var normal = vec3.create();
-
-    // remove any tangents left over from earlier builds (this should be pretty rare)
-    while (tangents.length > vertcount) tangents.pop();
-
-    var b;
-    for (b = 0; b < vertcount; b++) {
-      
-      if (indices) a = indices[b];
-      else a = b;
-      
-      // Gram-Schmidt orthogonalize: (t - n * dot(n, t)).normalize()
-      normal[0] = normals[a*3]; normal[1] = normals[a*3+1]; normal[2] = normals[a*3+2];
-      vec3.scale(normal, vec3.dot(normal, tan1[a]), dif);
-      vec3.subtract(tan1[a], dif, dif);
-      vec3.normalize(dif);
-          
-      tangents[a*4] = dif[0];
-      tangents[a*4+1] = dif[1];
-      tangents[a*4+2] = dif[2];
-      // calc handedness
-      tangents[a*4+3] = (vec3.dot(vec3.cross(normal, tan1[a]), tan2[a])) < 0.0 ? -1.0 : 1.0;
-    }
-    
-    if (tangentBuffer)
-      self.buffers.tangent_buffer.refresh();
-    else
-      self.buffers.tangent_buffer = new Jax.NormalBuffer(tangents);
-    return self.buffers.tangent_buffer;
-  }
-  
-  function findMaterial(name_or_instance) {
-    if (typeof(name_or_instance) == "string")
-      return Jax.Material.find(name_or_instance);
-    else if (name_or_instance.isKindOf && name_or_instance.isKindOf(Jax.Material))
-      return name_or_instance;
-    
-    throw new Error("Material must be an instance of Jax.Material, or "+
-                    "a string representing a material in the Jax material registry");
-  }
-  
-  function calculateBounds(self, vertices) {
-    self.bounds = {left:null,right:null,top:null,bottom:null,front:null,back:null,width:null,height:null,depth:null};
-    var i, v;
-    
-    for (i = 0; i < vertices.length; i++)
-    {
-      // x, i % 3 == 0
-      v = vertices[i];
-      if (self.bounds.left  == null || v < self.bounds.left)   self.bounds.left   = v;
-      if (self.bounds.right == null || v > self.bounds.right)  self.bounds.right  = v;
-      
-      // y, i % 3 == 1
-      v = vertices[++i];
-      if (self.bounds.bottom== null || v < self.bounds.bottom) self.bounds.bottom = v;
-      if (self.bounds.top   == null || v > self.bounds.top)    self.bounds.top    = v;
-      
-      // z, i % 3 == 2
-      v = vertices[++i];
-      if (self.bounds.front == null || v < self.bounds.front)  self.bounds.front  = v;
-      if (self.bounds.back  == null || v > self.bounds.back)   self.bounds.back   = v;
-    }
-    
-    self.bounds.width = self.bounds.right - self.bounds.left;
-    self.bounds.height= self.bounds.top   - self.bounds.bottom;
-    self.bounds.depth = self.bounds.front - self.bounds.back;
-  }
-  
-  function ensureBuilt(self) {
-    if (!self.isValid()) self.rebuild();
-  }
-  
-  return Jax.Class.create({
-    initialize: function(options) {
-      this.buffers = {};
-
-      /**
-       * Jax.Mesh#material -> String | Jax.Material
-       * This property represents the material that will be used to render this mesh. If
-       * it is a string, Jax will find the material with this name in the material registry
-       * using:
-       * 
-       *     Jax.Material.find(...).
-       *     
-       * If not specified, Jax.Mesh#default_material will be used instead.
-       **/
-
-      /**
-       * Jax.Mesh#default_material -> String | Jax.Material
-       * This property represents the material that will be used to render this mesh if #material
-       * isn't given a value and the render options don't override the material. If
-       * it is a string, Jax will find the material with this name in the material registry
-       * using:
-       * 
-       *     Jax.Material.find(...).
-       *     
-       * This property can also be specified as a render option in order to specify a default
-       * for a particular pass.
-       **/
-      this.default_material = "default";
-
-      for (var i in options)
-        this[i] = options[i];
-
-      if (!this.draw_mode)
-        this.draw_mode = GL_TRIANGLES;
-    },
-    
-    /**
-     * Jax.Mesh#setColor(red, green, blue, alpha) -> Jax.Mesh
-     * Sets the color of this mesh. This will set the color at each vertex, regardless
-     * of the original color of that vertex. The result will be that the entire mesh
-     * takes on the specified color (not just a particular vertex).
-     **/
-    setColor: function(red, green, blue, alpha) {
-      var buf = this.getColorBuffer();
-      for (var i = 0; i < buf.js.length; i += 4) {
-        buf.js[i] = red;
-        buf.js[i+1] = green;
-        buf.js[i+2] = blue;
-        buf.js[i+3] = alpha;
-      }
-      buf.refresh();
-      return this;
-    },
-
-    /**
-     * Jax.Mesh#dispose() -> undefined
-     * Frees the various buffers used by this mesh.
-     **/
-    dispose: function() {
-      while (this.faces && this.faces.length) this.faces.pop();
-      while (this.edges && this.edges.length) this.edges.pop();
-      for (var i in this.buffers) {
-        this.buffers[i].dispose();
-        delete this.buffers[i];
-      }
-      this.built = false;
-    },
-
-    /**
-     * Jax.Mesh#getFaceVertices(face) -> Array
-     * - face (Jax.Core.Face): the face whose vertices you wish to retrieve
-     * 
-     * Returns the current vertex data for the specified face.
-     **/
-    getFaceVertices: function(face) {
-      return [
-                [this.getVertexBuffer().js[face.vertexIndices[0]*3+0],
-                 this.getVertexBuffer().js[face.vertexIndices[0]*3+1],
-                 this.getVertexBuffer().js[face.vertexIndices[0]*3+2]
-                ],
-                [this.getVertexBuffer().js[face.vertexIndices[1]*3+0],
-                 this.getVertexBuffer().js[face.vertexIndices[1]*3+1],
-                 this.getVertexBuffer().js[face.vertexIndices[1]*3+2]
-                ],
-                [this.getVertexBuffer().js[face.vertexIndices[2]*3+0],
-                 this.getVertexBuffer().js[face.vertexIndices[2]*3+1],
-                 this.getVertexBuffer().js[face.vertexIndices[2]*3+2]
-                ]
-             ];
-    },
-    
-    /**
-     * Jax.Mesh#getEdgeVertices(edge) -> Array
-     * - edge (Jax.Core.Edge): the edge whose vertices you wish to retrieve
-     * 
-     * Returns the current vertex data for the specified edge.
-     **/
-    getEdgeVertices: function(edge) {
-      return [
-                [this.getVertexBuffer().js[edge.vertexIndices[0]*3+0],
-                 this.getVertexBuffer().js[edge.vertexIndices[0]*3+1],
-                 this.getVertexBuffer().js[edge.vertexIndices[0]*3+2]
-                ],
-                [this.getVertexBuffer().js[edge.vertexIndices[1]*3+0],
-                 this.getVertexBuffer().js[edge.vertexIndices[1]*3+1],
-                 this.getVertexBuffer().js[edge.vertexIndices[1]*3+2]
-                ]
-             ];
-    },
-
-    /**
-     * Jax.Mesh#render(context[, options]) -> undefined
-     * - context (Jax.Context): the Jax context to render this object to
-     * - options (Object): a set of custom render options to override the defaults for this Mesh.
-     * 
-     * Options include:
-     *   * *draw_mode* : a GL rendering enum, such as GL_TRIANGLES or GL_LINE_STRIP.
-     *   * *material* : an instance of Jax.Material, or the name of a registered Jax material, to override
-     *     the material associated with this mesh.
-     **/
-    render: function(context, options) {
-      if (!this.isValid()) this.rebuild();
-      options = this.getNormalizedRenderOptions(options);
-      options.material.render(context, this, options);
-    },
-    
-    getNormalizedRenderOptions: function(options) {
-      var result = Jax.Util.normalizeOptions(options, {
-        material: this.material,
-        default_material: this.default_material,
-        draw_mode: this.draw_mode || GL_TRIANGLES
-      });
-    
-      if (!result.material) result.material = result.default_material;
-
-      result.material = findMaterial(result.material);
-
-      return result;
-    },
-
-    /**
-     * Jax.Mesh#getVertexBuffer() -> Jax.VertexBuffer
-     **/
-    getVertexBuffer: function() { ensureBuilt(this); return this.buffers.vertex_buffer; },
-    /**
-     * Jax.Mesh#getColorBuffer() -> Jax.ColorBuffer
-     **/
-    getColorBuffer:  function() { ensureBuilt(this); return this.buffers.color_buffer;  },
-    /**
-     * Jax.Mesh#getIndexBuffer() -> Jax.ElementArrayBuffer
-     **/
-    getIndexBuffer:  function() { ensureBuilt(this); return this.buffers.index_buffer;  },
-    /**
-     * Jax.Mesh#getNormalBuffer() -> Jax.NormalBuffer
-     **/
-    getNormalBuffer: function() { ensureBuilt(this); return this.buffers.normal_buffer; },
-    /**
-     * Jax.Mesh#getTextureCoordsBuffer() -> Jax.TextureCoordsBuffer
-     **/
-    getTextureCoordsBuffer: function() { ensureBuilt(this); return this.buffers.texture_coords; },
-    /**
-     * Jax.Mesh#getTangentBuffer() -> Jax.NormalBuffer
-     * Returns tangent normals for each normal in this Mesh. Used for normal / bump mapping.
-     **/
-    getTangentBuffer: function() {
-      if (this.buffers.tangent_buffer) return this.buffers.tangent_buffer;
-      return makeTangentBuffer(this);
-    },
-
-    /**
-     * Jax.Mesh#rebuildTangentBuffer() -> Jax.NormalBuffer
-     * Forces an immediate rebuild of the tangent buffer for this Mesh. Use this if you've changed
-     * the vertex, normal or texture information to update the tangent vectors. If this step is
-     * skipped, you'll notice strange artifacts when using bump mapping (because the tangents will
-     * be pointing in the wrong direction).
-     **/
-    rebuildTangentBuffer: function() {
-      return makeTangentBuffer(this);
-    },
-
-    /**
-     * Jax.Mesh#isValid() -> Boolean
-     * 
-     * Returns true if this mesh is valid. If the mesh is invalid, it will be rebuilt during the next call to
-     * Jax.Mesh#render().
-     **/
-    isValid: function() { return !!this.built; },
-
-    /**
-     * Jax.Mesh#rebuild() -> undefined
-     * 
-     * Forces Jax to rebuild this mesh immediately. This will dispose of any WebGL buffers
-     * and reinitialize them with a new call to this mesh's data init method. Note that this
-     * is a very expensive operation and is *usually not* what you want.
-     * 
-     * If, for instance, you want to update the mesh with new vertex positions (say, for animation)
-     * then you'd be much better off doing something like this:
-     * 
-     *     var vbuf = mesh.getVertexBuffer();
-     *     vbuf.js.clear();
-     *     for (var i = 0; i < newVertexData.length; i++)
-     *       vbuf.push(newVertexData[i]);
-     *     vbuf.refresh();
-     * 
-     **/
-    rebuild: function() {
-      this.dispose();
-
-      var vertices = [], colors = [], textureCoords = [], normals = [], indices = [];
-      if (this.init)
-        this.init(vertices, colors, textureCoords, normals, indices);
-      
-      if (this.color)
-        setColorCoords(this, vertices.length / 3, this.color, colors);
-      
-      if (colors.length == 0) // still no colors?? default to white
-        setColorCoords(this, vertices.length / 3, [1,1,1,1], colors);
-      
-      if (vertices.length > 0)
-      {
-        this.buffers.vertex_buffer = new Jax.VertexBuffer(vertices);
-        calculateBounds(this, vertices);
-      }
-      
-      if (colors.length > 0) this.buffers.color_buffer = new Jax.ColorBuffer(colors);
-      if (indices.length> 0) this.buffers.index_buffer = new Jax.ElementArrayBuffer(indices);
-      if (normals.length> 0) this.buffers.normal_buffer= new Jax.NormalBuffer(normals);
-      if (textureCoords.length > 0) this.buffers.texture_coords = new Jax.TextureCoordsBuffer(textureCoords);
-      
-      this.built = true;
-
-      if (this.after_initialize) this.after_initialize();
-    }
-  });
-})();

data/src/jax/webgl/scene.js

@@ -1,11 +0,0 @@
-Jax.Scene = {};
-
-/* used by some shaders to determine what kind of shading is to be done.
- * This is stored in context.world.current_pass.
- */
-Jax.Scene.ILLUMINATION_PASS = 1;
-Jax.Scene.AMBIENT_PASS = 2;
-Jax.Scene.SHADOWMAP_PASS = 3;
-
-//= require "scene/frustum"
-//= require "scene/light_manager"

data/src/jax/webgl/scene/frustum.js

@@ -1,260 +0,0 @@
-//= require "../../geometry"
-
-Jax.Scene.Frustum = (function() {
-  var RIGHT = 0, LEFT = 1, BOTTOM = 2, TOP = 3, FAR = 4, NEAR = 5;
-  var OUTSIDE = Jax.Geometry.Plane.BACK, INTERSECT = Jax.Geometry.Plane.INTERSECT, INSIDE = Jax.Geometry.Plane.FRONT;
-
-  function extents(self)
-  {
-    /* TODO see how this can be combined with Camera#unproject */
-    function extent(x, y, z)
-    {
-      var inf = [];
-      var mm = self.mv, pm = self.p;
-
-      //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]=x;//*2.0-1.0;    /* x*2-1 translates x from 0..1 to -1..1 */
-      inf[1]=y;//*2.0-1.0;
-      inf[2]=z;//*2.0-1.0;
-      inf[3]=1.0;
-      
-      //Objects coordinates
-      var out = mat4.multiplyVec4(m, inf);
-      if(out[3]==0.0)
-         return [0,0,0];//null;
-
-      out[3]=1.0/out[3];
-      return [out[0]*out[3], out[1]*out[3], out[2]*out[3]];
-    }
-  
-    var ntl = extent(-1,1,-1), ntr = extent(1,1,-1), nbl = extent(-1,-1,-1), nbr = extent(1,-1,-1),
-        ftl = extent(-1,1,1), ftr = extent(1,1,1), fbl = extent(-1,-1,1), fbr = extent(1,-1,1);
-  
-    return {ntl:ntl, ntr:ntr, nbl:nbl, nbr:nbr, ftl:ftl, ftr:ftr, fbl:fbl, fbr:fbr};
-  }
-
-  function varcube(self, position, w, h, d)
-  {
-    if (!self.mv || !self.p) return INSIDE;
-    var p, c, c2 = 0, plane;
-  
-    w = w / 2.0;
-    h = h / 2.0;
-    d = d / 2.0;
-  
-    var xp = position[0]+w, xm=position[0]-w, yp=position[1]+h, ym=position[1]-h, zp=position[2]+d, zm=position[2]-d;
-  
-    for (p in self.planes)
-    {
-      plane = self.planes[p];
-      c = 0;
-      if (plane.distance(xp, yp, zp) > 0) c++;
-      if (plane.distance(xm, yp, zp) > 0) c++;
-      if (plane.distance(xp, ym, zp) > 0) c++;
-      if (plane.distance(xm, ym, zp) > 0) c++;
-      if (plane.distance(xp, yp, zm) > 0) c++;
-      if (plane.distance(xm, yp, zm) > 0) c++;
-      if (plane.distance(xp, ym, zm) > 0) c++;
-      if (plane.distance(xm, ym, zm) > 0) c++;
-      if (c == 0) return OUTSIDE;
-      if (c == 8) c2++;
-    }
-    
-    return (c2 == 6) ? INSIDE : INTERSECT;
-  }
-
-  function extractFrustum(self)
-  {
-    var frustum = self.planes;
-    var e = extents(self);
-  
-    frustum[TOP].set(e.ntr, e.ntl, e.ftl);
-    frustum[BOTTOM].set(e.nbl,e.nbr,e.fbr);
-    frustum[LEFT].set(e.ntl,e.nbl,e.fbl);
-    frustum[RIGHT].set(e.nbr,e.ntr,e.fbr);
-    frustum[NEAR].set(e.ntl,e.ntr,e.nbr);
-    frustum[FAR].set(e.ftr,e.ftl,e.fbl);
-  }
-
-  var klass = Jax.Class.create({
-    initialize: function(modelview, projection) {
-      this.listeners = {update:[]};
-      this.callbacks = this.listeners;
-      this.planes = {};
-      for (var i = 0; i < 6; i++) this.planes[i] = new Jax.Geometry.Plane();
-      this.setMatrices(modelview, projection);
-    },
-  
-    update: function() { if (this.mv && this.p) { extractFrustum(this); this.fireListeners('update'); } },
-    setModelviewMatrix: function(mv) { this.setMatrices(mv, this.p); },
-    setProjectionMatrix: function(p) { this.setMatrices(this.mv, p); },
-  
-    setMatrices: function(mv, p) {
-      this.mv = mv;
-      this.p  = p;
-      this.update();
-    },
-  
-    point: function(point) {
-      if (!this.mv || !this.p) return INSIDE;
-      if (arguments.length == 3) point = [arguments[0], arguments[1], arguments[2]];
-
-      for(var i=0; i < 6; i++)
-      {
-        if (this.planes[i].distance(point) < 0)
-          return OUTSIDE;
-      }
-      return INSIDE;
-    },
-  
-    sphere: function(center, radius)
-    {
-      if (!this.mv || !this.p) return INSIDE;
-      if (arguments.length == 4) { center = [arguments[0], arguments[1], arguments[2]]; radius = arguments[3]; }
-
-      var result = INSIDE, distance;
-      for (var i = 0; i < 6; i++)
-      {
-        distance = this.planes[i].distance(center);
-        if (distance < -radius) return OUTSIDE;
-        else if (distance < radius) result = INTERSECT;
-      }
-      return result;
-    },
-  
-    /* Arguments can either be an array of indices, or a position array [x,y,z] followed by width, height and depth.
-        Examples:
-          var cube = new Cube(...);
-          frustum.cube(cube.getCorners());
-          frustub.cube(cube.orientation.getPosition(), 1);
-          frustub.cube(cube.orientation.getPosition(), 1, 2, 3);
-     */
-    cube: function(corners)
-    {
-      if (arguments.length == 2) { return varcube(this, arguments[0], arguments[1], arguments[1], arguments[1]); }
-      if (arguments.length == 4) { return varcube(this, arguments[0], arguments[1], arguments[2], arguments[3]); }
-    
-      if (!this.mv || !this.p) return INSIDE;
-      if (arguments.length > 1) { corners = arguments; }
-      var p, c, c2 = 0, i, num_corners = corners.length, plane;
-      for (p in this.planes)
-      {
-        plane = this.planes[p];
-        c = 0;
-        for (i = 0; i < num_corners; i++)
-          if (plane.distance(corners[i]) > 0)
-            c++;
-        if (c == 0) return OUTSIDE;
-        if (c == num_corners) c2++;
-      }
-    
-      return (c2 == 6) ? INSIDE : INTERSECT;
-    },
-  
-    addUpdateListener: function(callback) { this.listeners.update.push(callback); },
-    sphereVisible: function(center, radius) { return this.sphere.apply(this, arguments) != OUTSIDE; },
-    pointVisible:  function(center)         { return this.point.apply(this, arguments)  != OUTSIDE; },
-    cubeVisible:   function(corners)        { return this.cube.apply(this, arguments)   != OUTSIDE; },
-  
-    fireListeners: function(name) {
-      for (var i = 0; i < this.listeners[name].length; i++)
-        this.listeners[name][i]();
-    },
-
-    isValid: function() { return this.p && this.mv; },
-  
-    getRenderable: function()
-    {
-      if (this.renderable) return this.renderable;
-    
-      var renderable = this.renderable = new Jax.Model({mesh: new Jax.Mesh()});
-      renderable.upToDate = false;
-      var frustum = this;
-    
-      function addVertices(e, vertices)
-      {
-        // near quad
-        vertices.push(e.ntl[0], e.ntl[1], e.ntl[2]);
-        vertices.push(e.ntr[0], e.ntr[1], e.ntr[2]);
-      
-        vertices.push(e.ntr[0], e.ntr[1], e.ntr[2]);
-        vertices.push(e.nbr[0], e.nbr[1], e.nbr[2]);
-    
-        vertices.push(e.nbr[0], e.nbr[1], e.nbr[2]);
-        vertices.push(e.nbl[0], e.nbl[1], e.nbl[2]);
-
-        vertices.push(e.nbl[0], e.nbl[1], e.nbl[2]);
-        vertices.push(e.ntl[0], e.ntl[1], e.ntl[2]);
-
-        // far quad
-        vertices.push(e.ftl[0], e.ftl[1], e.ftl[2]);
-        vertices.push(e.ftr[0], e.ftr[1], e.ftr[2]);
-      
-        vertices.push(e.ftr[0], e.ftr[1], e.ftr[2]);
-        vertices.push(e.fbr[0], e.fbr[1], e.fbr[2]);
-    
-        vertices.push(e.fbr[0], e.fbr[1], e.fbr[2]);
-        vertices.push(e.fbl[0], e.fbl[1], e.fbl[2]);
-
-        vertices.push(e.fbl[0], e.fbl[1], e.fbl[2]);
-        vertices.push(e.ftl[0], e.ftl[1], e.ftl[2]);
-
-        // left side
-        vertices.push(e.ntl[0], e.ntl[1], e.ntl[2]);
-        vertices.push(e.ftl[0], e.ftl[1], e.ftl[2]);
-      
-        vertices.push(e.nbl[0], e.nbl[1], e.nbl[2]);
-        vertices.push(e.fbl[0], e.fbl[1], e.fbl[2]);
-      
-        // right side
-        vertices.push(e.ntr[0], e.ntr[1], e.ntr[2]);
-        vertices.push(e.ftr[0], e.ftr[1], e.ftr[2]);
-      
-        vertices.push(e.nbr[0], e.nbr[1], e.nbr[2]);
-        vertices.push(e.fbr[0], e.fbr[1], e.fbr[2]);
-      }
-    
-      renderable.mesh.init = function(vertices, colors) {
-        this.draw_mode = GL_LINES;
-      
-        for (var i = 0; i < 24; i++)
-        {
-          vertices.push(0,0,0);
-          colors.push(1,1,0,1);
-        }
-      };
-    
-      renderable.update = null;
-    
-      frustum.addUpdateListener(function() {
-        if (!frustum.isValid()) { return; }
-      
-        renderable.upToDate = true;
-        var buf = renderable.mesh.getVertexBuffer();
-        if (!buf) return;
-        var vertices = buf.js;
-        vertices.clear();
-        var e = extents(frustum);//{ntl:ntl, ntr:ntr, nbl:nbl, nbr:nbr, ftl:ftl, ftr:ftr, fbl:fbl, fbr:fbr};
-      
-        addVertices(e, vertices);
-      
-        buf.refresh();
-      });
-    
-      return renderable;
-    }
-  });
-
-  klass.INSIDE = INSIDE;
-  klass.OUTSIDE = OUTSIDE;
-  klass.INTERSECT = INTERSECT;
-
-  return klass;
-})();