jax 1.1.1 → 2.0.0

data/lib/assets/javascripts/jax/events.js

@@ -0,0 +1,304 @@
+/**
+ * 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);
+
+    var result = [valueL, valueT];
+    result.left = valueL;
+    result.top = valueT;
+    return result;
+  }
+
+  function buildKeyEvent(self, evt) {
+    var keyboard = self.keyboard;
+    evt = evt || window.event || {};
+    keyboard.last = evt;
+    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 = fixEvent(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.pageX - cumulativeOffset[0];
+    mouse.y = evt.pageY - cumulativeOffset[1];
+
+    if (self.canvas) {
+      if (self.canvas.offsetWidth)  mouse.x = mouse.x / self.canvas.offsetWidth  * self.canvas.width;
+      if (self.canvas.offsetHeight) mouse.y = mouse.y / self.canvas.offsetHeight * self.canvas.height;
+    }
+
+    mouse.y = self.canvas.height - mouse.y; // invert y
+
+    // calculate differences, useful for checking movement relative to last position
+    if (evt.type == 'mouseover') {
+      // don't count 'mouseover' or we'll inadvertently cancel out long movements
+      mouse.diffx = mouse.diffy = 0;
+    } else {
+      mouse.diffx = mouse.x - mouse.offsetx;
+      mouse.diffy = mouse.y - mouse.offsety;
+    }
+    
+    // check button state special cases
+    if (evt.type == "mousedown" || evt.type == "onmousedown") {
+      // begin dragging, and possibly click
+      mouse.down = mouse.down || {count:0};
+      mouse.down["button"+evt.which] = {at:[mouse.x,mouse.y],time:Jax.uptime};
+      mouse.down.count++;
+    } else if (evt.type == "click" || evt.type == "onclick") {
+      // complete click
+      evt.cancel = false;
+      if (mouse.down && mouse.down["button"+evt.which]) {
+        evt.cancel = !!Jax.click_speed && (Jax.uptime - mouse.down["button"+evt.which].time) > Jax.click_speed;
+      }
+    } else if (evt.type == "mouseup" || evt.type == "onmouseup") {
+      // stop dragging
+      if (mouse.down)
+      {
+        mouse.down.count--;
+        // mouse.down = null;
+        if (mouse.down.count < 0) mouse.down.count = 0;
+      }
+    } else if (evt.type == "mouseout" || evt.type == "onmouseout") {
+      // reset all mousedown state so when mouse re-enters we won't be dragging
+      // in practice, this behavior is accurate more often than the opposite
+      // (e.g. drag out and then back in without releasing).
+      // Requiring an extra mouse-up in this opposite instance is harmless and
+      // relatively unobtrusive.
+      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) {
+    if (evt.cancel) return;
+    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'
+  ];
+
+  function registerListener(self, type, func) {
+    if (self.canvas.addEventListener) {
+      /* W3 */
+      self.canvas.addEventListener(type, func, false);
+    } else {
+      /* IE */
+      self.canvas.attachEvent("on"+type, func);
+    }
+  }
+
+  return {
+    disposeEventListeners: function() {
+      this.unregisterMouseListeners();
+      this.unregisterKeyListeners();
+    },
+    
+    registerMouseListeners: function(receiver) {
+      // we have to watch over/out to avoid problematic 'jittering' on mousemove
+      var register = {mouseover:1,mouseout:1}, name;
+      for (name in receiver) {
+        switch(name) {
+          case 'mouse_pressed' : register['mousedown'] = 1; break;
+          case 'mouse_released': register['mouseup'] = 1; break;
+          case 'mouse_dragged' : // same as mouse_moved
+          case 'mouse_moved'   : register['mousedown'] = register['mouseup'] = register['mousemove'] = 1; break;
+          case 'mouse_clicked' : register['click'] = register['mousedown'] = 1; break;
+          case 'mouse_exited'  : register['mouseout'] = 1; break;
+          case 'mouse_entered' : register['mouseover'] = 1; break;
+        };
+      }
+      
+      for (name in register) {
+        if (name == 'mousemove')
+          registerListener(this, name, this._evt_mousemovefunc);
+        else
+          registerListener(this, name, this._evt_mousefunc);
+      }
+    },
+    
+    unregisterMouseListeners: function() {
+      if (this._evt_mousefunc)     this.canvas.removeEventListener(this._evt_mousefunc);
+      if (this._evt_mousemovefunc) this.canvas.removeEventListener(this._evt_mousemovefunc);
+    },
+    
+    registerKeyListeners: function() {
+      if (this.canvas.addEventListener) {
+        /* W3 */
+        document.addEventListener('keydown',   this._evt_keyfunc,       false);
+        document.addEventListener('keypress',  this._evt_keyfunc,       false);
+        document.addEventListener('keyup',     this._evt_keyfunc,       false);
+      } else {
+        /* IE */
+        document.attachEvent('onkeydown',   this._evt_keyfunc);
+        document.attachEvent('onkeypress',  this._evt_keyfunc);
+        document.attachEvent('onkeyup',     this._evt_keyfunc);
+      }
+    },
+    
+    unregisterKeyListeners: function() {
+      if (!this._evt_keyfunc) return;
+      
+      this.canvas.removeEventListener(this._evt_keyfunc);
+      document.removeEventListener('keydown',    this._evt_keyfunc, false);
+      document.removeEventListener('keyup',      this._evt_keyfunc, false);
+      document.removeEventListener('keypress',   this._evt_keyfunc, false);
+      document.removeEventListener('onkeydown',  this._evt_keyfunc, false);
+      document.removeEventListener('onkeyup',    this._evt_keyfunc, false);
+      document.removeEventListener('onkeypress', this._evt_keyfunc, false);
+    },
+        
+    setupEventListeners: function() {
+      this.keyboard = {};
+      this.mouse = {};
+
+      var canvas = this.canvas;
+      var self = this;
+
+      this._evt_mousefunc     = function(evt) {
+        if (!self.current_controller) return;
+        evt = buildMouseEvent(self, evt);
+        return dispatchEvent(self, evt);
+      };
+      this._evt_mousemovefunc = function(evt) {
+        if (!self.current_controller) return;
+        evt = buildMouseEvent(self, evt);
+        if (self.mouse && (!self.mouse.down || self.mouse.down.count <= 0)) // mouse is not being dragged
+          evt.move_type = "mousemove";
+        else
+          evt.move_type = "mousedrag";
+        return dispatchEvent(self, evt);
+      };
+      this._evt_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);
+      };
+
+      this.registerKeyListeners();
+      
+      // this is now done by the context
+      // this.registerMouseListeners();
+    }
+  };
+})();

data/lib/assets/javascripts/jax/geometry/line.js

@@ -0,0 +1,185 @@
+/**
+ * class Jax.Geometry.Line
+ *
+ **/
+Jax.Geometry.Line = (function() {
+  var Line = Jax.Class.create({
+    /**
+     * new Jax.Geometry.Line([a[, b]])
+     * - a (vec3): point A (optional)
+     * - b (vec3): point B (optional)
+     *
+     * Creates a new line. If point A and B are given, they are
+     * passed into #set to initialize the line. If they are not
+     * given, all values default to 0.
+     **/
+    initialize: function(a, b) {
+      /**
+       * Jax.Geometry.Line#a -> vec3
+       *
+       * the starting point of this line
+       **/
+
+      this.a = vec3.create();
+
+      /**
+       * Jax.Geometry.Line#b -> vec3
+       *
+       * the ending point of this line
+       **/
+      this.b = vec3.create();
+
+      /**
+       * Jax.Geometry.Line#normal -> vec3
+       *
+       * the normal for this line, pointing from A towards B.
+       **/
+      this.normal = vec3.create();
+
+      /**
+       * Jax.Geometry.Line#length -> Number
+       *
+       * the length of this line
+       **/
+      this.length = 0;
+      
+      if (arguments.length) this.set(a, b);
+    },
+    
+    /**
+     * Jax.Geometry.Line#set(a, b) -> Jax.Geometry.Line
+     * - a (vec3): point A
+     * - b (vec3): point B
+     *
+     * Sets this line to span from point A to point B.
+     * Also recalculates the length and normal for this line.
+     **/
+    set: function(a, b) {
+      vec3.set(a, this.a);
+      vec3.set(b, this.b);
+      
+      vec3.subtract(b, a, this.normal);
+      this.length = vec3.length(this.normal);
+      vec3.normalize(this.normal);
+      
+      return this;
+    },
+    
+    /**
+     * Jax.Geometry.Line#intersectLineSegment(line[, dest]) -> Boolean
+     * - line (Jax.Geometry.Line): the line to test for intersection
+     * - dest (Jax.Geometry.Line): an optional receiving line
+     *
+     * Tests the two lines for intersection. If +dest+ is given, the overlap is stored
+     * within it. (If the lines intersect at a single point, but do not overlap, then
+     * only the A point in +dest+ will be set.) If +dest+ is
+     * omitted, this information is ignored.
+     *
+     * If the lines do not interesct, Jax.Geometry.DISJOINT (which is equal to 0) is returned.
+     * If they intersect in a single unique point, Jax.Geometry.INTERSECT is returned.
+     * If they intersect in a sub-segment, Jax.Geometry.COINCIDE is returned.
+     **/
+    intersectLineSegment: function(line, dest) {
+      var u = vec3.subtract(this.b, this.a, vec3.create());
+      var v = vec3.subtract(line.b, line.a, vec3.create());
+      var w = vec3.subtract(this.a, line.a, vec3.create());
+      var D = (u[0] * v[1] - u[1] * v[0]);
+      if (Math.abs(D) < Math.EPSILON) { // S1 and S2 are parallel
+        if ((u[0] * w[1] - u[1] * w[0]) != 0 || (v[0] * w[1] - v[1] * w[0]) != 0) {
+          return Jax.Geometry.DISJOINT; // they are NOT colinear
+        }
+        // they are colinear or degenerate
+        // check if they are degenerate points
+        var du = vec3.dot(u, u);
+        var dv = vec3.dot(v, v);
+        if (du == 0 && dv == 0) { // both segments are points
+          if (!Math.equalish(this.a, line.a)) // they are distinct points
+            return Jax.Geometry.DISJOINT;
+          // they are the same point
+          if (dest) vec3.set(line.a, dest.a);
+          // vec3.set(line.a, dest.b);
+          return Jax.Geometry.INTERSECT;
+        }
+        if (du == 0) { // +this+ is a single point
+          if (!line.contains(this.a)) // but is not in S2
+            return Jax.Geometry.DISJOINT;
+          if (dest) vec3.set(this.a, dest.a);
+          // vec3.set(this.b, dest.b);
+          return Jax.Geometry.INTERSECT;
+        }
+        if (dv == 0) { // +line+ is a single point
+          if (!this.contains(line.a)) // but is not in this line
+            return Jax.Geometry.DISJOINT;
+          if (dest) vec3.set(line.a, dest.a);
+          // vec3.set(line.b, dest.b);
+          return Jax.Geometry.INTERSECT;
+        }
+        // they are colinear segments - get overlap (or not)
+        var t0, t1; // endpoints of +this+ in eqn for +line+
+        var w2 = vec3.subtract(this.a, line.a, vec3.create());
+        if (v[0] != 0) {
+          t0 = w[0] / v[0];
+          t1 = w2[0] / v[0];
+        } else {
+          t0 = w[1] / v[1];
+          t1 = w2[1] / v[1];
+        }
+        if (t0 > t1) { // must have t0 smaller than t1
+          var t = t0; t0 = t1; t1 = t;
+        }
+        if (t0 > 1 || t1 < 0) // NO overlap
+          return Jax.Geometry.DISJOINT;
+        t0 = t0 < 0 ? 0 : t0; // clamp to min 0
+        t1 = t1 > 1 ? 1 : t1; // clamp to max 1
+        if (t0 == t1) {
+          // intersect is a point
+          if (line) {
+            vec3.add(line.a, vec3.scale(v, t0, dest.a), dest.a);
+            return Jax.Geometry.INTERSECT;
+          }
+        }
+          
+        // they overlap in a valid subsegment
+        if (dest) {
+          vec3.add(line.a, vec3.scale(v, t0, dest.a), dest);
+          vec3.add(line.b, vec3.scale(v, t1, dest.b), dest);
+        }
+        return Jax.Geometry.COINCIDENT;
+      }
+      
+      // the segments are askew and may intersect in a point
+      // get the intersect parameter for +this+
+      var sI = (v[0] * w[1] - v[1] * w[0]) / D;
+      if (sI < 0 || sI > 1) // no intersect with +this+
+        return Jax.Geometry.DISJOINT;
+      // get the intersect parameter for +line+
+      var tI = (u[0] * w[1] - u[1] * w[0]) / D;
+      if (tI < 0 || tI > 1) // no intersect with +line+
+        return Jax.Geometry.DISJOINT;
+        
+      if (dest) vec3.add(this.a, vec3.scale(u, sI, dest), dest);
+      return Jax.Geometry.INTERSECT;
+    },
+    
+    toString: function() {
+      return "[Line a:"+this.a+", b:"+this.b+"]";
+    }
+  });
+  
+  // array-style accessors
+  Object.defineProperty(Line.prototype, 0, {
+    get: function() { return this.a; },
+    set: function(v) { return this.a = v; },
+    enumerable: false,
+    configurable: false
+  });
+  
+  Object.defineProperty(Line.prototype, 1, {
+    get: function() { return this.b; },
+    set: function(v) { return this.b = v; },
+    enumerable: false,
+    configurable: false
+  });
+  
+  return Line;
+})();