jax 0.0.0.1

data/src/jax/events.js

@@ -0,0 +1,179 @@
+Jax.EVENT_METHODS = (function() {
+  function getCumulativeOffset(element) {
+    var valueT = 0, valueL = 0;
+    do {
+      valueT += element.offsetTop  || 0;
+      valueL += element.offsetLeft || 0;
+      element = element.offsetParent;
+    } while (element);
+
+    var result = [valueL, valueT];
+    result.left = valueL;
+    result.top = valueT;
+    return result;
+  }
+
+  function buildKeyEvent(self, evt) {
+    var keyboard = self.keyboard;
+
+    evt = evt || window.event || {};
+    // we don't really need these since controllers have this.context
+//    evt.context = self;
+//    evt.canvas = self.canvas;
+    keyboard.last = evt;
+
+    /*
+    TODO track all keypresses and whatnot via @keyboard, so all keys can be queried at any given time
+     */
+
+    return evt;
+  }
+
+  function buildMouseEvent(self, evt) {
+    var mouse = self.mouse;
+
+    evt = evt || window.event || {};
+    evt.context = self;
+    evt.canvas = self.canvas;
+    evt.offsetx = mouse.x;
+    evt.offsety = mouse.y;
+    evt.mouse = mouse;
+    
+    mouse.offsetx = evt.offsetx || 0;
+    mouse.offsety = evt.offsety || 0;
+
+    var cumulativeOffset = getCumulativeOffset(self.canvas);
+    mouse.x = evt.clientX - cumulativeOffset[0];
+    mouse.y = evt.clientY - 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;
+
+    // check for button presses
+    if (evt.type == "mousedown" || evt.type == "onmousedown") {
+      mouse.down = mouse.down || {count:0};
+      mouse.down["button"+evt.which] = {at:[mouse.x,mouse.y]};
+    } else if (evt.type == "mouseup" || evt.type == "onmouseup") {
+      if (mouse.down)
+      {
+        mouse.down.count--;
+        if (mouse.down.count <= 0) mouse.down = null;
+      }
+    }
+    
+    evt.x = mouse.x;
+    evt.y = mouse.y;
+    evt.diffx = mouse.diffx;
+    evt.diffy = mouse.diffy;
+    evt.down = mouse.down;
+
+    return evt;
+  }
+
+  function dispatchEvent(self, evt) {
+    var type = evt.type.toString();
+    if (type.indexOf("on") == 0) type = type.substring(2, type.length);
+    type = type.toLowerCase();
+    var target;
+    switch(type) {
+      case "click":     target = "mouse_clicked"; break;
+      case "mousemove":
+        if (evt.move_type == 'mousemove') target = "mouse_moved";
+        else                              target = "mouse_dragged";
+        break;
+      case "mousedown": target = "mouse_pressed"; break;
+      case "mouseout":  target = "mouse_exited";  break;
+      case "mouseover": target = "mouse_entered"; break;
+      case "mouseup":   target = "mouse_released";break;
+      case "keydown":   target = "key_pressed";   break;
+      case "keypress":  target = "key_typed";     break;
+      case "keyup":     target = "key_released";  break;
+      default: return true; // don't dispatch this event to the controller
+    }
+
+    if (self.current_controller[target]) {
+      var result = self.current_controller[target](evt);
+      if (result != undefined) return result;
+    }
+    return true;
+  }
+  
+  // Tag names which, when active, should cause key input to be IGNORED. The implication is that while
+  // one of these tags has focus, the user doesn't want to be controlling his character because s/he is
+  // trying to type something.
+  var ignoreKeyTagNames = [
+          'input', 'form', 'textarea', 'label', 'fieldset', 'legend', 'select', 'optgroup', 'option', 'button'
+  ];
+
+  return {
+    setupEventListeners: function() {
+      this.keyboard = {};
+      this.mouse = {};
+
+      var canvas = this.canvas;
+      var self = this;
+
+      var mousefunc     = function(evt) {
+        if (!self.current_controller) return;
+        evt = buildMouseEvent(self, evt);
+        return dispatchEvent(self, evt);
+      };
+      var mousemovefunc = function(evt) {
+        if (!self.current_controller) return;
+        evt = buildMouseEvent(self, evt);
+        if (self.mouse && self.mouse.down == null) // mouse is not being dragged
+          evt.move_type = "mousemove";
+        else
+          evt.move_type = "mousedrag";
+        return dispatchEvent(self, evt);
+      };
+      var keyfunc       = function(evt) {
+        if (evt.which) evt.str = String.fromCharCode(evt.which);
+        if (document.activeElement) {
+          if (ignoreKeyTagNames.indexOf(document.activeElement.tagName) != -1)
+          { // user is probably trying to type, so don't capture this input
+            return;
+          }
+        }
+        if (!self.current_controller) return;
+        evt = buildKeyEvent(self, evt);
+        return dispatchEvent(self, evt);
+      };
+
+      if (canvas.addEventListener) {
+        /* W3 */
+        canvas.addEventListener('click',     mousefunc,     false);
+        canvas.addEventListener('mousedown', mousefunc,     false);
+        canvas.addEventListener('mousemove', mousemovefunc, false);
+        canvas.addEventListener('mouseout',  mousefunc,     false);
+        canvas.addEventListener('mouseover', mousefunc,     false);
+        canvas.addEventListener('mouseup',   mousefunc,     false);
+        document.addEventListener('keydown',   keyfunc,       false);
+        document.addEventListener('keypress',  keyfunc,       false);
+        document.addEventListener('keyup',     keyfunc,       false);
+      } else {
+        /* IE */
+        canvas.attachEvent('onclick',     mousefunc    );
+        canvas.attachEvent('onmousedown', mousefunc    );
+        canvas.attachEvent('onmousemove', mousemovefunc);
+        canvas.attachEvent('onmouseout',  mousefunc    );
+        canvas.attachEvent('onmouseover', mousefunc    );
+        canvas.attachEvent('onmouseup',   mousefunc    );
+        document.attachEvent('onkeydown',   keyfunc      );
+        document.attachEvent('onkeypress',  keyfunc      );
+        document.attachEvent('onkeyup',     keyfunc      );
+      }
+    }
+  };
+})();

data/src/jax/geometry.js

@@ -0,0 +1,3 @@
+Jax.Geometry = {};
+
+//= require "geometry/plane"

data/src/jax/geometry/plane.js

@@ -0,0 +1,59 @@
+Jax.Geometry.Plane = (function() {
+  function innerProduct(a, x, y, z) {
+    return (a[0]*x + a[1]*y + a[2]*z);
+  }
+
+  return Jax.Class.create({
+    initialize: function(points) {
+      if (points) this.set.apply(this, arguments);
+    },
+    
+    set: function(points) {
+      if (arguments.length == 3) points = [arguments[0], arguments[1], arguments[2]];
+      
+      this.normal = vec3.create();
+      var vec = vec3.create();
+      vec3.subtract(points[1], points[0], this.normal);
+      vec3.subtract(points[2], points[0], vec);
+      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]);
+    },
+    
+    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;
+    },
+    
+    distance: function(point)
+    {
+      var x, y, z;
+      if (arguments.length == 3) { x = arguments[0]; y = arguments[1]; z = arguments[2]; }
+      else { x = point[0]; y = point[1]; z = point[2]; }
+      // same as ax + by + cz + d
+      return this.d + innerProduct(this.normal, x, y, z);
+    },
+    
+    whereis: function(point)
+    {
+      if (arguments.length == 3) points = [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;
+      return Jax.Geometry.Plane.INTERSECT;
+    }
+  });
+})();
+
+Jax.Geometry.Plane.FRONT     = 1;
+Jax.Geometry.Plane.BACK      = 2;
+Jax.Geometry.Plane.INTERSECT = 3;

data/src/jax/helper.js

@@ -0,0 +1,8 @@
+Jax.Helper = {
+  instances: [],
+
+  create: function(methods) {
+    Jax.Helper.instances.push(methods);
+    return methods;
+  }
+};

data/src/jax/model.js

@@ -0,0 +1,163 @@
+/**
+ * class Jax.Model
+ * 
+ **/
+(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({
+      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();
+      },
+      
+      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.getModelViewMatrix());
+            self.mesh.render(context, options);
+          });
+        }
+      },
+      
+      getBoundingCube: function() {
+        if (!this.mesh.built) this.mesh.rebuild();
+        return this.mesh.bounds;
+      },
+      
+      getBoundingSphereRadius: function() {
+        var b = this.getBoundingCube();
+        return Math.max(b.width, Math.max(b.height, b.depth));
+      },
+      
+      dispose: function() {
+        if (this.mesh)
+          this.mesh.dispose();
+      },
+      
+      isLit: function() {
+        return this.lit;
+      },
+
+      /**
+       * Jax.Model#inspect() -> String
+       * 
+       * Returns the JSON representation of the attributes in this model.
+       * Function definitions are not included.
+       * 
+       **/
+      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 = 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;
+  };
+})();

data/src/jax/prototype/class.js

@@ -0,0 +1,78 @@
+//= require "core"
+
+Jax.Class = (function() {
+  var emptyFunction = function() { };
+
+  var IS_DONTENUM_BUGGY = (function(){
+    for (var p in { toString: 1 }) {
+      if (p === 'toString') return false;
+    }
+    return true;
+  })();
+
+  function subclass() {};
+  function create() {
+    var parent = null, properties = Jax.$A(arguments);
+    if (Object.isFunction(properties[0]))
+      parent = properties.shift();
+
+    function klass() {
+      this.initialize.apply(this, arguments);
+    }
+
+    Object.extend(klass, Jax.Class.Methods);
+    klass.superclass = parent;
+    klass.subclasses = [];
+
+    if (parent) {
+      subclass.prototype = parent.prototype;
+      klass.prototype = new subclass;
+      parent.subclasses.push(klass);
+    }
+
+    for (var i = 0, length = properties.length; i < length; i++)
+      klass.addMethods(properties[i]);
+
+    if (!klass.prototype.initialize)
+      klass.prototype.initialize = emptyFunction;
+
+    klass.prototype.constructor = klass;
+    return klass;
+  }
+
+  function addMethods(source) {
+    var ancestor   = this.superclass && this.superclass.prototype,
+        properties = Object.keys(source);
+
+    if (IS_DONTENUM_BUGGY) {
+      if (source.toString != Object.prototype.toString)
+        properties.push("toString");
+      if (source.valueOf != Object.prototype.valueOf)
+        properties.push("valueOf");
+    }
+
+    for (var i = 0, length = properties.length; i < length; i++) {
+      var property = properties[i], value = source[property];
+      if (ancestor && Object.isFunction(value) &&
+          value.argumentNames()[0] == "$super") {
+        var method = value;
+        value = (function(m) {
+          return function() { return ancestor[m].apply(this, arguments); };
+        })(property).wrap(method);
+
+        value.valueOf = method.valueOf.bind(method);
+        value.toString = method.toString.bind(method);
+      }
+      this.prototype[property] = value;
+    }
+
+    return this;
+  }
+
+  return {
+    create: create,
+    Methods: {
+      addMethods: addMethods
+    }
+  };
+})();