jax 0.0.0.5 → 0.0.0.6

data/src/jax/core/math.js

@@ -1,5 +1,8 @@
-// If an epsilon isn't defined, define it. This is used for fuzzy equality with floats,
-// because of floating point imprecision.
+/**
+ * Math.EPSILON = 0.00001
+ * This is a very small number, used for testing fuzzy equality with floats due to
+ * floating point imprecision.
+ **/
 Math.EPSILON = Math.EPSILON || 0.00001;
 
 /**
@@ -15,14 +18,26 @@ Math.radToDeg = Math.radToDeg || function(rad) {
   return rad * 180.0 / Math.PI;
 };
 
-/**
+/** alias of: Math.radToDeg
  * Math.radToDeg(rad) -> Number
+ * Helper to convert radians to degrees.
+ **/
+Math.rad2deg = Math.rad2deg || Math.radToDeg;
+
+/**
+ * Math.degToRad(deg) -> Number
  * Helper to convert degrees to radians.
  **/
 Math.degToRad = Math.degToRad || function(deg) {
   return deg * Math.PI / 180.0;
 };
 
+/** alias of: Math.degToRad
+ * Math.deg2rad(deg) -> Number
+ * Helper to convert degrees to radians.
+ **/
+Math.deg2rad = Math.deg2rad || Math.degToRad;
+
 /**
  * Math.equalish(a, b) -> Boolean
  * Arguments can be either scalar or vector, but must be of the same type.

data/src/jax/core/matrix_stack.js

@@ -2,7 +2,8 @@
 //= require "../prototype/class"
 
 /**
- * Jax.IDENTITY_MATRIX
+ * Jax.IDENTITY_MATRIX = mat4.identity(mat4.create())
+ *
  * A cache of the identity matrix so that we're not constantly allocating identities.
  **/
 Jax.IDENTITY_MATRIX = mat4.identity(mat4.create());
@@ -18,7 +19,7 @@ Jax.IDENTITY_MATRIX = mat4.identity(mat4.create());
  * itself is returned instead of a copy of the instance. That gives you the power to make changes
  * directly to the matrix, instead of doing them via the stack. For instance, instead of calling
  * Jax.MatrixStack#loadMatrix(), you could just as easily call mat4#set() using one of the
- * matrices here as an argument. However, in doing so you will lose the auto-updating of other
+ * matrices here as an argument. *However*, in doing so you will lose the auto-updating of other
  * matrices, so you must be very careful about how you modify matrices.
  *
  * For example, it would be very easy to use mat4.multiply() to change the model matrix. In doing
@@ -307,4 +308,4 @@ Jax.MatrixStack = (function() {
       this.loadProjectionMatrix(Jax.IDENTITY_MATRIX); // there's no known data about the viewport at this time.
     }
   });
-})();
+})();

data/src/jax/core/util.js

@@ -3,6 +3,21 @@
  * Contains general-purpose utility and helper functions
  **/
 Jax.Util = {
+  /**
+   * Jax.Util.decodePickingColor(red, green, blue, alpha) -> Number
+   * 
+   * Performs the reverse of the 'picking' shader by restoring a number
+   * that was previously encoded into the four color channels.
+   **/
+  decodePickingColor: function(red, green, blue, alpha) {
+    /* blue is a key. It is always max. So if it's 1, we're dealing with floats; else, bytes. */
+    if (blue == 1.0) {
+      red *= 255;
+      green *= 255;
+    }
+    return red * 256 + green;
+  },
+
   /**
    * Jax.Util.vectorize(object) -> vec3
    * - object (Object): any Object

data/src/jax/events.js

@@ -1,9 +1,15 @@
+/**
+ * Jax.EVENT_METHODS -> Object
+ * Contains event handling methods which are added to +Jax.Context+.
+ **/
 Jax.EVENT_METHODS = (function() {
   function getCumulativeOffset(element) {
     var valueT = 0, valueL = 0;
     do {
       valueT += element.offsetTop  || 0;
       valueL += element.offsetLeft || 0;
+      valueT += Jax.Compatibility.offsetTop;
+      valueL += Jax.Compatibility.offsetLeft;
       element = element.offsetParent;
     } while (element);
 
@@ -28,11 +34,69 @@ Jax.EVENT_METHODS = (function() {
 
     return evt;
   }
+  
+  function fixEvent(event) {
+    // this borrowed from jQuery
+    // store a copy of the original event object
+		// and "clone" to set read-only properties
+		var originalEvent = event;
+		event = {type:originalEvent.type};
+		var props = "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" ");
+
+		for ( var i = props.length, prop; i; ) {
+			prop = props[ --i ];
+			event[ prop ] = originalEvent[ prop ];
+		}
+
+		// Fix target property, if necessary
+		if ( !event.target ) {
+			// Fixes #1925 where srcElement might not be defined either
+			event.target = event.srcElement || document;
+		}
+
+		// check if target is a textnode (safari)
+		if ( event.target.nodeType === 3 ) {
+			event.target = event.target.parentNode;
+		}
+
+		// Add relatedTarget, if necessary
+		if ( !event.relatedTarget && event.fromElement ) {
+			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
+		}
+
+		// Calculate pageX/Y if missing and clientX/Y available
+		if ( event.pageX == null && event.clientX != null ) {
+			var eventDocument = event.target.ownerDocument || document,
+				doc = eventDocument.documentElement,
+				body = eventDocument.body;
+
+			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
+			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
+		}
+
+		// Add which for key events
+		if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
+			event.which = event.charCode != null ? event.charCode : event.keyCode;
+		}
+
+		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
+		if ( !event.metaKey && event.ctrlKey ) {
+			event.metaKey = event.ctrlKey;
+		}
+
+		// Add which for click: 1 === left; 2 === middle; 3 === right
+		// Note: button is not normalized, so don't use it
+		if ( !event.which && event.button !== undefined ) {
+			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
+		}
+
+		return event;
+  }
 
   function buildMouseEvent(self, evt) {
     var mouse = self.mouse;
 
-    evt = evt || window.event || {};
+    evt = fixEvent(evt || window.event);
     evt.context = self;
     evt.canvas = self.canvas;
     evt.offsetx = mouse.x;
@@ -43,19 +107,10 @@ Jax.EVENT_METHODS = (function() {
     mouse.offsety = evt.offsety || 0;
 
     var cumulativeOffset = getCumulativeOffset(self.canvas);
-    mouse.x = evt.clientX - cumulativeOffset[0];
-    mouse.y = evt.clientY - cumulativeOffset[1];
+    mouse.x = evt.pageX - cumulativeOffset[0];
+    mouse.y = evt.pageY - cumulativeOffset[1];
     mouse.y = self.canvas.height - mouse.y; // invert y
 
-    // add scroll offsets
-    if (window.pageXOffset) {
-      mouse.x += window.pageXOffset;
-      mouse.y += window.pageYOffset;
-    } else {
-      mouse.x += document.body.scrollLeft;
-      mouse.y += document.body.scrollTop;
-    }
-
     // calculate differences, useful for checking movement relative to last position
     mouse.diffx = mouse.x - mouse.offsetx;
     mouse.diffy = mouse.y - mouse.offsety;

data/src/jax/geometry.js

@@ -1,3 +1,7 @@
+/**
+ * Jax.Geometry
+ * Namespace containing geometric classes and functions
+ **/
 Jax.Geometry = {};
 
-//= require "geometry/plane"
+//= require "geometry/plane"

data/src/jax/geometry/plane.js

@@ -1,3 +1,15 @@
+/**
+ * class Jax.Geometry.Plane
+ *
+ * Represents a plane in 3 dimensions.
+ *
+ * Examples:
+ *
+ *     new Jax.Geometry.Plane([0,0,0], [0,1,0], [1,0,0]);
+ *     new Jax.Geometry.Plane([[0,0,0], [0,1,0], [1,0,0]]);
+ *     new Jax.Geometry.Plane();
+ *
+ **/
 Jax.Geometry.Plane = (function() {
   function innerProduct(a, x, y, z) {
     return (a[0]*x + a[1]*y + a[2]*z);
@@ -8,6 +20,18 @@ Jax.Geometry.Plane = (function() {
       if (points) this.set.apply(this, arguments);
     },
     
+    /**
+     * Jax.Geometry.Plane#set(points) -> Jax.Geometry.Plane
+     * - points (Array): an array of 3 vectors.
+     * Jax.Geometry.Plane#set(point0, point1, point2) -> Jax.Geometry.Plane
+     * - point0 (vec3): the first of 3 vectors.
+     * - point1 (vec3): the second of 3 vectors.
+     * - point2 (vec3): the third of 3 vectors.
+     * 
+     * Sets this plane's coefficients based off of a set of three 3D points.
+     *
+     * This plane is returned.
+     **/
     set: function(points) {
       if (arguments.length == 3) points = [arguments[0], arguments[1], arguments[2]];
       
@@ -18,22 +42,35 @@ Jax.Geometry.Plane = (function() {
       vec3.cross(this.normal, vec, this.normal);
       vec3.normalize(this.normal);
       
-//      vec3.subtract(points[1], points[0], this.normal);
-//      vec3.cross(this.normal, vec3.subtract(points[2], points[0], vec3.create()));
-//      vec3.normalize(this.normal);
-//      this.normal = (points[1].minus(points[0])).cross(points[2].minus(points[0])).normalize();
       this.point = points[1];
       this.d = -innerProduct(this.normal, this.point[0], this.point[1], this.point[2]);
+      
+      return this;
     },
     
+    /**
+     * Jax.Geometry.Plane#setCoefficients(a, b, c, d) -> Jax.Geometry.Plane
+     *
+     * Sets the four coefficients A, B, C, D for this plane.
+     *
+     * Returns this plane.
+     **/
     setCoefficients: function(a, b, c, d) {
       var len = Math.sqrt(a*a+b*b+c*c);
       this.normal[0] = a/len;
       this.normal[1] = b/len;
       this.normal[2] = c/len;
       this.d = d/len;
+      return this;
     },
     
+    /**
+     * Jax.Geometry.Plane#distance(point) -> Number
+     * - point (vec3): A 3D vector. Can be any type with values for indices [0..2] (e.g. an Array).
+     *
+     * Given a 3D point, returns the distance from this plane to the point. The point is expected
+     * to lie in the same 3D space as this plane.
+     **/
     distance: function(point)
     {
       var x, y, z;
@@ -43,9 +80,26 @@ Jax.Geometry.Plane = (function() {
       return this.d + innerProduct(this.normal, x, y, z);
     },
     
+    /**
+     * Jax.Geometry.Plane#whereis(point) -> Number
+     * - point (vec3): A 3D vector. Can be any type with values for indices [0..2] (e.g. an Array).
+     *
+     * Given a point in 3D space, returns one of the following values based on the position
+     * of the point relative to this plane:
+     *
+     *     Jax.Geometry.Plane.FRONT
+     *     Jax.Geometry.Plane.BACK
+     *     Jax.Geometry.Plane.INTERSECT
+     *
+     * FRONT represents a point lying somewhere in the direction of the plane's normal.
+     * BACK represents the opposite, and INTERSECT represents a point lying directly
+     * parallel to this plane.
+     *
+     * The point is expected to lie in the same 3D space as this plane.
+     **/
     whereis: function(point)
     {
-      if (arguments.length == 3) points = [arguments[0], arguments[1], arguments[2]];
+      if (arguments.length == 3) point = [arguments[0], arguments[1], arguments[2]];
       var d = this.distance(point);
       if (d > 0) return Jax.Geometry.Plane.FRONT;
       if (d < 0) return Jax.Geometry.Plane.BACK;

data/src/jax/{controller.js → mvc/controller.js}

@@ -1,5 +1,6 @@
 /**
  * class Jax.Controller
+ * 
  * Controllers are a major component of the Jax framework, because they are in
  * charge of receiving input from the user, setting up a scene, tearing it down,
  * and deciding when is the right time to transition to a different controller.
@@ -48,6 +49,7 @@
  * explicitly trigger other actions by calling them directly. They differ from their
  * corresponding views (see Jax.View) in this way, as a view is rendered many times
  * -- up to a target rate of 60 passes per second.
+ *
  **/
 (function() {
   var protected_instance_method_names = [
@@ -69,6 +71,15 @@
     }
     
     return Jax.Class.create({
+      /**
+       * Jax.Controller#fireAction(action_name) -> Jax.Controller
+       *
+       * Erases the results of the last action, then calls the specified action. If it doesn't exist,
+       * an error is raised. Finally, unless the action redirects to a different action or renders
+       * a different action directly, the specified action becomes the focus of the current view.
+       *
+       * Returns this controller.
+       **/
       fireAction: function(action_name) {
         this.eraseResult();
         this.action_name = action_name;
@@ -79,16 +90,38 @@
         
         if (!this.rendered_or_redirected)
           setViewKey(this);
+        return this;
       },
       
+      /**
+       * Jax.Controller#eraseResults() -> Jax.Controller
+       *
+       * Erases the results of the most recent render action. That is, whether or not it rendered
+       * a different action or caused a redirect to a different action or controller is reset, and
+       * the current view is set to +null+, indicating that no view will be rendered.
+       *
+       * Returns this controller.
+       **/
       eraseResult: function() {
         this.rendered_or_redirected = false;
         this.view_key = null;
+        return this;
       }
     });
   })();
 
   var controller_class_methods = {
+    /**
+     * Jax.Controller.invoke(action_name, context) -> Jax.Controller
+     * - action_name (String): The name of the action to fire after initialization
+     * - context (Jax.Context): The context to attach to the instantiated controller
+     *
+     * Creates a new instance of the specified controller, sets up its references to
+     * +this.context+, +this.world+, and so on; and finally, fires the action given by
+     * +action_name+.
+     *
+     * Returns the newly-constructed controller.
+     **/
     invoke: function(action_name, context) {
       var instance = new this();
       instance.context = context;
@@ -138,6 +171,11 @@
     if (inner) klass = Jax.Class.create(superclass,     inner);
     else       klass = Jax.Class.create(Jax.Controller, superclass);
     
+    /**
+     * Jax.Controller.getControllerName() -> String
+     *
+     * Returns the name of the controller in question, as it is represented in +Jax.routes+.
+     **/
     Object.extend(klass, controller_class_methods);
     Object.extend(klass, { getControllerName: function() { return controller_name; } });
     klass.addMethods({getControllerName: function() { return controller_name; } });

data/src/jax/mvc/helper.js

@@ -0,0 +1,35 @@
+/**
+ * class Jax.Helper
+ *
+ * Jax Helpers are glorified mixins. They contain a set of methods which can then be
+ * included into any Jax class.
+ *
+ * Defining a helper is easy, and looks a bit like this:
+ *
+ *     var HelloHelper = Jax.Helper.create({
+ *       sayHi: function(name) { alert("Hello, "+name+"!"); }
+ *     });
+ *
+ * Once defined, using helpers is particularly simple. In any Jax class, simply define
+ * a +helpers+ function that returns an array of helpers:
+ *
+ *     var Liaison = Jax.Class.create({
+ *       helpers: function() { return [HelloHelper]; }
+ *     });
+ *
+ * Now the +Liaison+ class will include the +sayHi+ method which can be called just like
+ * any other method:
+ *
+ *     var l = new Liaison();
+ *     l.sayHi("World");
+ *     //=> Hello, World!
+ *
+ **/
+Jax.Helper = {
+  instances: [],
+
+  create: function(methods) {
+    Jax.Helper.instances.push(methods);
+    return methods;
+  }
+};

data/src/jax/mvc/model.js

@@ -0,0 +1,301 @@
+/**
+ * class Jax.Model
+ * 
+ * Models encapsulate virtually all business logic. If a Monster knows how to attack, the logic
+ * that makes it do so is held within the +Monster+ model. If the terrain has trees and other
+ * vegetation, the +Terrain+ model is responsible for setting that up.
+ *
+ * While controllers generally have only high-level code such as initial scene set-up and
+ * processing of user input, models handle nearly everything else.
+ *
+ * Models also contain the actual game data. Jax further splits models into two components: the
+ * Model itself and its Resources.
+ *
+ * Define a model like so:
+ *
+ *     var Monster = Jax.Model.create({
+ *       after_initialize: function() {
+ *         // code to be run automatically after a monster is instantiated
+ *       },
+ * 
+ *       update: function(time) {
+ *         // code to be run automatically every few milliseconds
+ *       },
+ *
+ *       dealDamageTo: function(otherModel) {
+ *         // custom method, called only when you invoke it
+ *         otherModel.takeDamage(this.attack_damage);
+ *       }
+ *     });
+ *
+ * Once defined, you can add data easily:
+ *
+ *     Monster.addResources({"ogre": {
+ *       hit_points: 100,
+ *       attack_damage: 75
+ *     }});
+ *
+ * You can instantiate a model whose resources already exist like so:
+ *
+ *     var ogre = Monster.find("ogre");
+ *
+ * Note that subsequent calls to +Model.find+ will return unique objects. For instance, the
+ * following code will add 3 separate "ogres" to the world:
+ *
+ *     world.addObject(Monster.find("ogre"));
+ *     world.addObject(Monster.find("ogre"));
+ *     world.addObject(Monster.find("ogre"));
+ * 
+ **/
+(function() {
+  function initProperties(self, data) {
+    // to make sure sub-properties of data are standalone objects, so that the original data can't be tainted
+    data = Jax.Util.normalizeOptions(data, {});
+    
+    var attribute;
+        
+    if (data) {
+      for (attribute in data) {
+        switch(attribute) {
+          case 'position':    self.camera.setPosition(Jax.Util.vectorize(data[attribute])); break;
+          case 'direction':   self.camera.orient(Jax.Util.vectorize(data[attribute])); break;
+          case 'mesh':
+            if (data[attribute].isKindOf(Jax.Mesh)) self.mesh = data[attribute];
+            else throw new Error("Unexpected value for mesh:\n\n"+JSON.stringify(data[attribute]));
+            break;
+          default:
+            self[attribute] = data[attribute];
+        }
+      }
+    }
+  }
+  
+  Jax.Model = (function() {
+    return Jax.Class.create({
+      /**
+       * new Jax.Model(data)
+       * - data: a set of attributes to be assigned to this instance of the model.
+       *
+       * Anything can be in the data, or you may supply no data at all to instantiate
+       * a model with its default attributes.
+       *
+       * The following attributes have special meanings:
+       *
+       * * +position+ : sets the position of this model in world coordinates.
+       * * +direction+ : sets the direction this model is facing, in world coordinates.
+       * * +mesh+: an instance of +Jax.Mesh+
+       * * +shadow_caster+ : true or false; specifies whether this model can cast shadows.
+       * * +lit+ : true or false; specifies whether this model is affected by nearby lights.
+       *
+       **/
+      initialize: function(data) {
+        this.camera = new Jax.Camera();
+        
+        initProperties(this, Jax.Model.default_properties);
+        if (this._klass && this._klass.resources)
+          initProperties(this, this._klass.resources['default']);
+        initProperties(this, data);
+        
+        if (this.after_initialize) this.after_initialize();
+      },
+      
+      /**
+       * Jax.Model#isShadowCaster() -> Boolean
+       *
+       * Returns true if this model casts shadows upon other models in the scene. Note that
+       * even if true, shadows will only be cast upon models which utilize +Jax.Material+s that support
+       * both the +Lighting+ and +ShadowMap+ effects.
+       *
+       **/
+      isShadowCaster: function() { return this.shadow_caster; },
+
+      /**
+       * Jax.Model#render(context) -> undefined
+       * 
+       * Renders this model with the given context. If the model doesn't have a mesh,
+       * nothing is rendered.
+       **/
+      render: function(context, options) {
+        if (this.mesh)
+        {
+          var self = this;
+          context.pushMatrix(function() {
+            context.multModelMatrix(self.camera.getTransformationMatrix());
+            self.mesh.render(context, options);
+          });
+        }
+      },
+      
+      /**
+       * Jax.Model#getBoundingCube() -> Object
+       *
+       * Returns an object describing the cubic dimensions of this model.
+       * 
+       * Example:
+       *
+       *     var bounds = new Jax.Model({mesh:new Jax.Mesh.Cube()}).getBoundingCube();
+       *     // 'bounds' contains the following:
+       *     {
+       *       left: -0.5,
+       *       right: 0.5,
+       *       bottom: -0.5,
+       *       top: 0.5,
+       *       front: 0.5,
+       *       back: -0.5,
+       *       width: 1.0,
+       *       height: 1.0,
+       *       depth: 1.0
+       *     }
+       * 
+       **/
+      getBoundingCube: function() {
+        if (!this.mesh.built) this.mesh.rebuild();
+        return this.mesh.bounds;
+      },
+      
+      /**
+       * Jax.Model#getBoundingSphereRadius() -> Number
+       *
+       * A sphere can be defined with two values: a position and a radius. A model's
+       * position is always known via its camera (see +Jax.Model#camera+).
+       *
+       * This method returns the radius of its bounding sphere. A bounding sphere is
+       * guaranteed to contain the furthest-away point from the model's position. It is less
+       * accurate than +Jax.Model#getBoundingCube+, but using it is much faster.
+       *
+       **/
+      getBoundingSphereRadius: function() {
+        var b = this.getBoundingCube();
+        return Math.max(b.width, Math.max(b.height, b.depth));
+      },
+      
+      /**
+       * Jax.Model#dispose() -> undefined
+       *
+       * Disposes of this model and its mesh.
+       *
+       * Note that both models and meshes _can_ be reused after disposal; they'll just
+       * be silently re-initialized. This means it is safe to dispose of models while
+       * they are still being used (although this is slow and not recommended if at all
+       * avoidable).
+       **/
+      dispose: function() {
+        if (this.mesh)
+          this.mesh.dispose();
+      },
+      
+      /**
+       * Jax.Model#isLit() -> Boolean
+       *
+       * Returns true if this model can be lit by other light sources. Note that even
+       * if this is true, the +Jax.Material+ used by its +Jax.Mesh+ must support the
+       * +Lighting+ effect in order to actually perform the lighting effect.
+       *
+       **/
+      isLit: function() {
+        return this.lit;
+      },
+
+      /**
+       * Jax.Model#inspect() -> String
+       * 
+       * Returns the JSON representation of the attributes in this model.
+       * Unlike JSON.stringify(), this method will omit function definitions so
+       * that only actual data elements are returned in the resulting JSON string.
+       * 
+       **/
+      inspect: function() {
+        result = {};
+        for (var i in this)
+          if (!Object.isFunction(this[i]) && i != "_klass")
+            result[i] = this[i];
+        return JSON.stringify(result);
+      }
+    });
+  })();
+  
+  var model_class_methods = {
+    /**
+     * Jax.Model.find(id) -> Jax.Model
+     * - id (String): the unique identifier of the model to be found
+     * 
+     * Finds the resource with the specified name, instantiates its model and returns it.
+     * 
+     * Note that this is a class method of the model in question, and not of Jax.Model itself.
+     * 
+     * For example, this would be correct:
+     * 
+     *     Character.find('bad_guy')
+     *     
+     * while this would be *incorrect*:
+     * 
+     *     Jax.Model.find('bad_guy')
+     *     
+     **/
+    find: function(id) {
+      for (var resource_id in this.resources) {
+        if (id == resource_id)
+          return new this(this.resources[id]);
+      }
+      throw new Error("Resource '"+id+"' not found!");
+    },
+
+    /**
+     * Jax.Model.addResources(resources) -> undefined
+     * - resources (Object): the resources to be added
+     * 
+     * Adds the resources to the specified model. These resources can then be found using
+     * Jax.Model.find(id).
+     * 
+     * Note that this is a class method of the model in question, and not of Jax.Model itself.
+     * 
+     * For example, this would be correct:
+     * 
+     *     Character.addResources({'bad_guy': {...}})
+     *     
+     * while this would be *incorrect*:
+     * 
+     *     Jax.Model.addResources({'bad_guy': {...}})
+     *     
+     **/
+    addResources: function(resources) {
+      this.resources = this.resources || {};
+      for (var id in resources)
+        if (this.resources[id]) throw new Error("Duplicate resource ID: "+id);
+        else this.resources[id] = resources[id];
+    }
+  };
+  
+  Jax.Model.default_properties = {
+    lit: true,
+    shadow_caster: true
+  };
+  
+  /**
+   * Jax.Model.create(inner) -> klass<Jax.Model>
+   * - inner (Object) - a set of methods the class will contain.
+   * Jax.Model.create(superclass, inner) -> klass<Jax.Model>
+   * - superclass (Jax.Model) - an optional superclass. Defaults to +Jax.Model+.
+   * - inner (Object) - a set of methods the class will contain.
+   * 
+   * Creates a new Jax class inheriting from Jax.Model. If a superclass is given,
+   * the model will inherit from the given superclass instead. The superclass is,
+   * in turn, expected to be a subclass of Jax.Model.
+   *
+   * Examples:
+   *
+   *     var Person = Jax.Class.create({ ... });
+   *     var Colin = Jax.Class.create(Person, { ... });
+   *
+   **/
+  Jax.Model.create = function(superclass, inner) {
+    var klass;
+    if (inner) klass = Jax.Class.create(superclass, inner);
+    else       klass = Jax.Class.create(Jax.Model, superclass);
+    
+    klass.addMethods({_klass:klass});
+
+    Object.extend(klass, model_class_methods);
+    return klass;
+  };
+})();