30 files changed, 1609 insertions, 1778 deletions

diff --git a/js/helper-classes/3D/math-utils.js b/js/helper-classes/3D/math-utils.js
index 71ed62a0..3d24f76e 100644
--- a/js/helper-classes/3D/math-utils.js
+++ b/js/helper-classes/3D/math-utils.js
@@ -802,19 +802,21 @@ var MathUtilsClass = exports.MathUtilsClass = Object.create(Object.prototype, {
     getAxisAngleBetween3DVectors: {
         value: function (vec1, vec2, axis) {
             //compute magnitudes of the vectors
-            var mag1 = VecUtils.vecMag(3, vec1);
-            var mag2 = VecUtils.vecMag(3, vec2);
-
-            if (mag1 < this.EPSILON || mag2 < this.EPSILON) {
-                return 0; //if angle 0 is returned nothing from this function should be used
-            }
+            var v1n = VecUtils.vecNormalize(3, vec1, 1.0);
+            var v2n = VecUtils.vecNormalize(3, vec2, 1.0);
             //angle between the vectors (acos for now...)
-            var angle = Math.acos(VecUtils.vecDot(3, vec1, vec2) / (mag1 * mag2));
+            var angle = Math.acos(VecUtils.vecDot(3, v1n, v2n));
             if (Math.abs(angle) < this.EPSILON) {
                 return 0;
             }
+            //TODO testing...remove this block
+            console.log("getAxisAngleBetween3DVectors Angle: "+angle);
+            if (isNaN(angle)){
+                console.log("getAxisAngleBetween3DVectors Angle is NaN");
+            }
+            //TODO end testing block
             //optionally, if axis is provided, create the axis of rotation as well
-            var rotAxis = VecUtils.vecCross(3, vec1, vec2);
+            var rotAxis = VecUtils.vecCross(3, v1n, v2n);
             rotAxis = VecUtils.vecNormalize(3, rotAxis, 1);
             axis[0] = rotAxis[0];
             axis[1] = rotAxis[1];
diff --git a/js/helper-classes/RDGE/GLAnchorPoint.js b/js/helper-classes/RDGE/GLAnchorPoint.js
index 496b6f60..716f59d4 100644
--- a/js/helper-classes/RDGE/GLAnchorPoint.js
+++ b/js/helper-classes/RDGE/GLAnchorPoint.js
@@ -26,125 +26,136 @@ function GLAnchorPoint() {
     this._nextX = 0.0;
     this._nextY = 0.0;
     this._nextZ = 0.0;
-
+}
     // *********** setters ************
-    this.setPos = function (x, y, z) { this._x = x; this._y = y; this._z = z; }
-    this.setPrevPos = function (x, y, z) { this._prevX = x; this._prevY = y; this._prevZ = z; }
-    this.setNextPos = function (x, y, z) { this._nextX = x; this._nextY = y; this._nextZ = z; }
-
-    this.setPrevFromNext = function () {
-        //set the previous control point by reflecting the next control point
-        var dispX = this._nextX - this._x;
-        var dispY = this._nextY - this._y;
-        var dispZ = this._nextZ - this._z;
-
-        this._prevX = this._x - dispX;
-        this._prevY = this._y - dispY;
-        this._prevZ = this._z - dispZ;
-    }
-    this.setNextFromPrev = function () {
-        //set the previous control point by reflecting the next control point
-        var dispX = this._prevX - this._x;
-        var dispY = this._prevY - this._y;
-        var dispZ = this._prevZ - this._z;
-
-        this._nextX = this._x - dispX;
-        this._nextY = this._y - dispY;
-        this._nextZ = this._z - dispZ;
-    }
+GLAnchorPoint.prototype.setPos = function (x, y, z) { this._x = x; this._y = y; this._z = z; }
+GLAnchorPoint.prototype.setPrevPos = function (x, y, z) { this._prevX = x; this._prevY = y; this._prevZ = z; }
+GLAnchorPoint.prototype.setNextPos = function (x, y, z) { this._nextX = x; this._nextY = y; this._nextZ = z; }
 
-    //translate the next point from the translation that was applied to the prev. point
-    this.translateNextFromPrev = function (tx, ty, tz) {
-        // *** compute the rotation of the prev vector ***
-        var oldP = Vector.create([this._prevX + tx - this._x, this._prevY + ty - this._y, this._prevZ + tz - this._z]);
-        var newP = Vector.create([this._prevX - this._x, this._prevY - this._y, this._prevZ - this._z]);
-        //compute angle between the two vectors
-        var axis = Vector.create([0, 0, 0]);
-        var angle = MathUtils.getAxisAngleBetween3DVectors(oldP, newP, axis);
-        if (angle === 0)
-            return;
-
-        // *** compute the vector from anchor to next
-        var oldN = Vector.create([this._nextX - this._x, this._nextY - this._y, this._nextZ - this._z]);
-        var rotMat = Matrix.Rotation(-angle, axis);
-        var newN = MathUtils.transformVector(oldN, rotMat);
-
-        //TEMP for some situations the axis angle computation returns NaNs
-        if (isNaN(newN[0]) || isNaN(newN[1]) || isNaN(newN[2])) {
-            return;
-        }
-        //end TEMP
-        this._nextX = this._x + newN[0];
-        this._nextY = this._y + newN[1];
-        this._nextZ = this._z + newN[2];
-    }
-    //translate the next point from the translation that was applied to the prev. point
-    this.translatePrevFromNext = function (tx, ty, tz) {
-        // *** compute the rotation of the next vector ***
-        var oldN = Vector.create([this._nextX + tx - this._x, this._nextY + ty - this._y, this._nextZ + tz - this._z]);
-        var newN = Vector.create([this._nextX - this._x, this._nextY - this._y, this._nextZ - this._z]);
-        //compute angle between the two vectors
-        var axis = Vector.create([0, 0, 0]);
-        var angle = MathUtils.getAxisAngleBetween3DVectors(oldN, newN, axis);
-        if (angle === 0)
-            return;
-
-        // *** compute the vector from anchor to prev
-        var oldP = Vector.create([this._prevX - this._x, this._prevY - this._y, this._prevZ - this._z]);
-        var rotMat = Matrix.Rotation(-angle, axis);
-        var newP = MathUtils.transformVector(oldP, rotMat);
-
-        //TEMP for some situations the axis angle computation returns NaNs
-        if (isNaN(newP[0]) || isNaN(newP[1]) || isNaN(newP[2])) {
-            return;
-        }
-        //end TEMP
-        this._prevX = this._x + newP[0];
-        this._prevY = this._y + newP[1];
-        this._prevZ = this._z + newP[2];
-    }
+GLAnchorPoint.prototype.setPrevFromNext = function () {
+    //set the previous control point by reflecting the next control point
+    var dispX = this._nextX - this._x;
+    var dispY = this._nextY - this._y;
+    var dispZ = this._nextZ - this._z;
 
+    this._prevX = this._x - dispX;
+    this._prevY = this._y - dispY;
+    this._prevZ = this._z - dispZ;
+}
+GLAnchorPoint.prototype.setNextFromPrev = function () {
+    //set the previous control point by reflecting the next control point
+    var dispX = this._prevX - this._x;
+    var dispY = this._prevY - this._y;
+    var dispZ = this._prevZ - this._z;
 
-    // ******* modifiers *******
-    this.translatePrev = function (x, y, z) {
-        this._prevX += x; this._prevY += y; this._prevZ += z; 
-    }
-    this.translateNext = function (x, y, z) {
-        this._nextX += x; this._nextY += y; this._nextZ += z;
-    }
-    this.translate = function (x, y, z) {
-        this._x += x; this._y += y; this._z += z;
-    }
-    this.translateAll = function (x, y, z) {
-        this.translate(x, y, z);
-        this.translatePrev(x, y, z);
-        this.translateNext(x, y, z);
-    }
-    
+    this._nextX = this._x - dispX;
+    this._nextY = this._y - dispY;
+    this._nextZ = this._z - dispZ;
+}
+
+//translate the next point from the translation that was applied to the prev. point
+GLAnchorPoint.prototype.translateNextFromPrev = function (tx, ty, tz) {
+    //do nothing if the total translation is zero
+    var totalTransSq = (tx*tx) + (ty*ty) + (tz*tz);
+    if (totalTransSq < 0.0000001)
+        return;
     
-    // ********* getters **********
-    this.getPosX = function () { return this._x; }
-    this.getPosY = function () { return this._y; }
-    this.getPosZ = function () { return this._z; }
-    this.getPrevX = function () { return this._prevX; }
-    this.getPrevY = function () { return this._prevY; }
-    this.getPrevZ = function () { return this._prevZ; }
-    this.getNextX = function () { return this._nextX; }
+    // *** compute the rotation of the prev vector ***
+    var oldP = Vector.create([this._prevX + tx - this._x, this._prevY + ty - this._y, this._prevZ + tz - this._z]);
+    var newP = Vector.create([this._prevX - this._x, this._prevY - this._y, this._prevZ - this._z]);
+    //compute angle between the two vectors
+    var axis = Vector.create([0, 0, 0]);
+    var angle = MathUtils.getAxisAngleBetween3DVectors(oldP, newP, axis);
+    if (angle === 0)
+        return;