diff --git a/cmake/externals/polyvox/CMakeLists.txt b/cmake/externals/polyvox/CMakeLists.txt
index cfaf7ed293..4563bf5918 100644
--- a/cmake/externals/polyvox/CMakeLists.txt
+++ b/cmake/externals/polyvox/CMakeLists.txt
@@ -3,8 +3,8 @@ set(EXTERNAL_NAME polyvox)
 include(ExternalProject)
 ExternalProject_Add(
   ${EXTERNAL_NAME}
-  URL http://hifi-public.s3.amazonaws.com/dependencies/polyvox.zip
-  URL_MD5 904b840328278c9b36fa7a14be730c34
+  URL http://hifi-public.s3.amazonaws.com/dependencies/polyvox-master-2015-7-15.zip
+  URL_MD5 9ec6323b87e849ae36e562ae1c7494a9
   CMAKE_ARGS -DENABLE_EXAMPLES=OFF -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
   BINARY_DIR ${EXTERNAL_PROJECT_PREFIX}/build
   LOG_DOWNLOAD 1
@@ -24,7 +24,16 @@ if (APPLE)
     ${EXTERNAL_NAME}
     change-install-name
     COMMENT "Calling install_name_tool on libraries to fix install name for dylib linking"
-    COMMAND ${CMAKE_COMMAND} -DINSTALL_NAME_LIBRARY_DIR=${INSTALL_NAME_LIBRARY_DIR} -P ${EXTERNAL_PROJECT_DIR}/OSXInstallNameChange.cmake
+    COMMAND ${CMAKE_COMMAND} -DINSTALL_NAME_LIBRARY_DIR=${INSTALL_NAME_LIBRARY_DIR}/Debug -P ${EXTERNAL_PROJECT_DIR}/OSXInstallNameChange.cmake
+    DEPENDEES install
+    WORKING_DIRECTORY <SOURCE_DIR>
+    LOG 1
+  )
+  ExternalProject_Add_Step(
+    ${EXTERNAL_NAME}
+    change-install-name
+    COMMENT "Calling install_name_tool on libraries to fix install name for dylib linking"
+    COMMAND ${CMAKE_COMMAND} -DINSTALL_NAME_LIBRARY_DIR=${INSTALL_NAME_LIBRARY_DIR}/Release -P ${EXTERNAL_PROJECT_DIR}/OSXInstallNameChange.cmake
     DEPENDEES install
     WORKING_DIRECTORY <SOURCE_DIR>
     LOG 1
@@ -48,12 +57,15 @@ endif ()
 
 
 if (WIN32)
-  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY ${INSTALL_DIR}/PolyVoxCore/lib/PolyVoxCore.lib CACHE FILEPATH "polyvox core library")
+  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY_DEBUG ${INSTALL_DIR}/PolyVoxCore/lib/Debug/PolyVoxCore.lib CACHE FILEPATH "polyvox core library")
+  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY_RELEASE ${INSTALL_DIR}/PolyVoxCore/lib/Release/PolyVoxCore.lib CACHE FILEPATH "polyvox core library")
 #  set(${EXTERNAL_NAME_UPPER}_UTIL_LIBRARY ${INSTALL_DIR}/PolyVoxUtil/lib/PolyVoxUtil.lib CACHE FILEPATH "polyvox util library")
 elseif (APPLE)
-set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY ${INSTALL_DIR}/lib/libPolyVoxCore.dylib CACHE FILEPATH "polyvox core library")
+  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY_DEBUG ${INSTALL_DIR}/lib/Debug/libPolyVoxCore.dylib CACHE FILEPATH "polyvox core library")
+  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY_RELEASE ${INSTALL_DIR}/lib/Release/libPolyVoxCore.dylib CACHE FILEPATH "polyvox core library")
 #  set(${EXTERNAL_NAME_UPPER}_UTIL_LIBRARY ${INSTALL_DIR}/lib/libPolyVoxUtil.dylib CACHE FILEPATH "polyvox util library")
 else ()
-  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY ${INSTALL_DIR}/lib/libPolyVoxCore.so CACHE FILEPATH "polyvox core library")
+  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY_DEBUG ${INSTALL_DIR}/lib/Debug/libPolyVoxCore.so CACHE FILEPATH "polyvox core library")
+  set(${EXTERNAL_NAME_UPPER}_CORE_LIBRARY_RELEASE ${INSTALL_DIR}/lib/Release/libPolyVoxCore.so CACHE FILEPATH "polyvox core library")
 #  set(${EXTERNAL_NAME_UPPER}_UTIL_LIBRARY ${INSTALL_DIR}/lib/libPolyVoxUtil.so CACHE FILEPATH "polyvox util library")
 endif ()
diff --git a/cmake/modules/FindPolyVox.cmake b/cmake/modules/FindPolyVox.cmake
index 60a639e87c..08e9f1c6a2 100644
--- a/cmake/modules/FindPolyVox.cmake
+++ b/cmake/modules/FindPolyVox.cmake
@@ -24,9 +24,12 @@ hifi_library_search_hints("polyvox")
 find_path(POLYVOX_CORE_INCLUDE_DIRS PolyVoxCore/SimpleVolume.h PATH_SUFFIXES include include/PolyVoxCore HINTS ${POLYVOX_SEARCH_DIRS})
 # find_path(POLYVOX_UTIL_INCLUDE_DIRS PolyVoxUtil/Serialization.h PATH_SUFFIXES include include/PolyVoxUtil HINTS ${POLYVOX_SEARCH_DIRS})
 
-find_library(POLYVOX_CORE_LIBRARY NAMES PolyVoxCore PATH_SUFFIXES lib HINTS ${POLYVOX_SEARCH_DIRS})
+find_library(POLYVOX_CORE_LIBRARY_DEBUG NAMES PolyVoxCore PATH_SUFFIXES lib/Debug HINTS ${POLYVOX_SEARCH_DIRS})
+find_library(POLYVOX_CORE_LIBRARY_RELEASE NAMES PolyVoxCore PATH_SUFFIXES lib/Release lib HINTS ${POLYVOX_SEARCH_DIRS})
 # find_library(POLYVOX_UTIL_LIBRARY NAMES PolyVoxUtil PATH_SUFFIXES lib HINTS ${POLYVOX_SEARCH_DIRS})
 
+include(SelectLibraryConfigurations)
+select_library_configurations(POLYVOX_CORE)
 
 # if (WIN32)
 #   find_path(POLYVOX_DLL_PATH polyvox.dll PATH_SUFFIXES bin HINTS ${POLYVOX_SEARCH_DIRS}) 
diff --git a/examples/edit.js b/examples/edit.js
index 23cc942192..dfbace7be6 100644
--- a/examples/edit.js
+++ b/examples/edit.js
@@ -656,7 +656,9 @@ function mouseMove(event) {
 
 function handleIdleMouse() {
     idleMouseTimerId = null;
-    highlightEntityUnderCursor(lastMousePosition, true);
+    if (isActive) {
+        highlightEntityUnderCursor(lastMousePosition, true);
+    }
 }
 
 function highlightEntityUnderCursor(position, accurateRay) {
diff --git a/examples/entityScripts/chessPiece.js b/examples/entityScripts/chessPiece.js
index b6dfca9efd..24ba7b33e8 100644
--- a/examples/entityScripts/chessPiece.js
+++ b/examples/entityScripts/chessPiece.js
@@ -130,10 +130,10 @@
         var others = Entities.findEntities(this.properties.position, this.properties.dimensions.y);
         
         for (var i = 0; i < others.length; i++) {
-            var piece = others[i];
+            var pieceID = others[i];
   
-            if (piece.id != this.entityID) {
-                var properties = Entities.getEntityProperties(piece);
+            if (pieceID != this.entityID) {
+                var properties = Entities.getEntityProperties(pieceID);
          
                 var isWhite = properties.modelURL.search("White") !== -1;
                 var type = (properties.modelURL.search("King") !== -1) ?  4 :
@@ -147,7 +147,7 @@
                 if (myPos.i === piecePos.i && myPos.j === piecePos.j && type !== -2) {
                     var position = this.getAbsolutePosition((isWhite) ? { i: type, j: -1 } : { i: 7 - type, j: 8 },
                     properties.dimensions.y / 2.0);
-                    Entities.editEntity(piece, {
+                    Entities.editEntity(pieceID, {
                         position: position
                     });
                     break;
diff --git a/examples/grab.js b/examples/grab.js
index 13c91bebb8..05bcf128e2 100644
--- a/examples/grab.js
+++ b/examples/grab.js
@@ -10,97 +10,13 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-var MOVE_TIMESCALE = 0.1;
-var INV_MOVE_TIMESCALE = 1.0 / MOVE_TIMESCALE;
 var MAX_SOLID_ANGLE = 0.01; // objects that appear smaller than this can't be grabbed
-var CLOSE_ENOUGH = 0.001;
-var ZERO_VEC3 = { x: 0, y: 0, z: 0 };
-var ANGULAR_DAMPING_RATE = 0.40;
-
-// NOTE: to improve readability global variable names start with 'g'
-var gIsGrabbing = false;
-var gGrabbedEntity = null;
-var gActionID = null;
-var gEntityProperties;
-var gStartPosition;
-var gStartRotation;
-var gCurrentPosition;
-var gOriginalGravity = ZERO_VEC3;
-var gPlaneNormal = ZERO_VEC3;
-
-// gMaxGrabDistance is a function of the size of the object.
-var gMaxGrabDistance;
-
-// gGrabMode defines the degrees of freedom of the grab target positions
-// relative to gGrabStartPosition options include:
-//     xzPlane  (default)
-//     verticalCylinder  (SHIFT)
-//     rotate  (CONTROL)
-// Modes to eventually support?:
-//     xyPlane
-//     yzPlane
-//     polar
-//     elevationAzimuth
-var gGrabMode = "xzplane";
-
-// gGrabOffset allows the user to grab an object off-center.  It points from the object's center
-// to the point where the ray intersects the grab plane (at the moment the grab is initiated).
-// Future target positions of the ray intersection are on the same plane, and the offset is subtracted
-// to compute the target position of the object's center.
-var gGrabOffset = { x: 0, y: 0, z: 0 };
-
-var gTargetPosition;
-var gTargetRotation;
-var gLiftKey = false; // SHIFT
-var gRotateKey = false; // CONTROL
-
-var gInitialMouse = { x: 0, y: 0 };
-var gPreviousMouse = { x: 0, y: 0 };
-var gMouseCursorLocation = { x: 0, y: 0 };
-var gMouseAtRotateStart = { x: 0, y: 0 };
-
-var gBeaconHeight = 0.10;
-
-// var gAngularVelocity = ZERO_VEC3;
-
-// TODO: play sounds again when we aren't leaking AudioInjector threads
-// var grabSound = SoundCache.getSound("https://hifi-public.s3.amazonaws.com/eric/sounds/CloseClamp.wav");
-// var releaseSound = SoundCache.getSound("https://hifi-public.s3.amazonaws.com/eric/sounds/ReleaseClamp.wav");
-// var VOLUME = 0.0;
-
-var gBeaconHeight = 0.10;
-var BEACON_COLOR = {
-    red: 200,
-    green: 200,
-    blue: 200
-};
-var BEACON_WIDTH = 2;
+var ZERO_VEC3 = {x: 0, y: 0, z: 0};
+var IDENTITY_QUAT = {x: 0, y: 0, z: 0, w: 0};
 
 
-var gBeacon = Overlays.addOverlay("line3d", {
-    color: BEACON_COLOR,
-    alpha: 1,
-    visible: false,
-    lineWidth: BEACON_WIDTH
-});
-
-function updateDropLine(position) {
-    Overlays.editOverlay(gBeacon, {
-        visible: true,
-        start: {
-            x: position.x,
-            y: position.y + gBeaconHeight,
-            z: position.z
-        },
-        end: {
-            x: position.x,
-            y: position.y - gBeaconHeight,
-            z: position.z
-        }
-    });
-}
-
-function mouseIntersectionWithPlane(pointOnPlane, planeNormal, event) {
+// helper function
+function mouseIntersectionWithPlane(pointOnPlane, planeNormal, event, maxDistance) {
     var cameraPosition = Camera.getPosition();
     var localPointOnPlane = Vec3.subtract(pointOnPlane, cameraPosition);
     var distanceFromPlane = Vec3.dot(localPointOnPlane, planeNormal);
@@ -117,7 +33,7 @@ function mouseIntersectionWithPlane(pointOnPlane, planeNormal, event) {
     var useMaxForwardGrab = false;
     if (Math.abs(dirDotNorm) > MIN_RAY_PLANE_DOT) {
         var distanceToIntersection = distanceFromPlane / dirDotNorm;
-        if (distanceToIntersection > 0 && distanceToIntersection < gMaxGrabDistance) {
+        if (distanceToIntersection > 0 && distanceToIntersection < maxDistance) {
             // ray points into the plane
             localIntersection = Vec3.multiply(pickRay.direction, distanceFromPlane / dirDotNorm);
         } else {
@@ -134,52 +50,160 @@ function mouseIntersectionWithPlane(pointOnPlane, planeNormal, event) {
         // we re-route the intersection to be in front at max distance.
         var rayDirection = Vec3.subtract(pickRay.direction, Vec3.multiply(planeNormal, dirDotNorm));
         rayDirection = Vec3.normalize(rayDirection);
-        localIntersection = Vec3.multiply(rayDirection, gMaxGrabDistance);
+        localIntersection = Vec3.multiply(rayDirection, maxDistance);
         localIntersection = Vec3.sum(localIntersection, Vec3.multiply(planeNormal, distanceFromPlane));
     }
     var worldIntersection = Vec3.sum(cameraPosition, localIntersection);
     return worldIntersection;
 }
 
-function computeNewGrabPlane() {
-    if (!gIsGrabbing) {
+// Mouse class stores mouse click and drag info
+Mouse = function() {
+    this.current = {x: 0, y: 0 };
+    this.previous = {x: 0, y: 0 };
+    this.rotateStart = {x: 0, y: 0 };
+    this.cursorRestore = {x: 0, y: 0};
+}
+
+Mouse.prototype.startDrag = function(position) {
+    this.current = {x: position.x, y: position.y};
+    this.startRotateDrag();
+}
+
+Mouse.prototype.updateDrag = function(position) {
+    this.current = {x: position.x, y: position.y };
+}
+
+Mouse.prototype.startRotateDrag = function() {
+    this.previous = {x: this.current.x, y: this.current.y};
+    this.rotateStart = {x: this.current.x, y: this.current.y};
+    this.cursorRestore = { x: Window.getCursorPositionX(), y: Window.getCursorPositionY() };
+}
+
+Mouse.prototype.getDrag = function() {
+    var delta = {x: this.current.x - this.previous.x, y: this.current.y - this.previous.y};
+    this.previous = {x: this.current.x, y: this.current.y};
+    return delta;
+}
+
+Mouse.prototype.restoreRotateCursor = function() {
+    Window.setCursorPosition(this.cursorRestore.x, this.cursorRestore.y);
+    this.current = {x: this.rotateStart.x, y: this.rotateStart.y};
+}
+
+var mouse = new Mouse();
+
+
+// Beacon class stores info for drawing a line at object's target position
+Beacon = function() {
+    this.height = 0.10;
+    this.overlayID = Overlays.addOverlay("line3d", {
+        color: {red: 200, green: 200, blue: 200},
+        alpha: 1,
+        visible: false,
+        lineWidth: 2 
+    });
+}
+
+Beacon.prototype.enable = function() {
+    Overlays.editOverlay(this.overlayID, { visible: true });
+}
+
+Beacon.prototype.disable = function() {
+    Overlays.editOverlay(this.overlayID, { visible: false });
+}
+
+Beacon.prototype.updatePosition = function(position) {
+    Overlays.editOverlay(this.overlayID, {
+        visible: true,
+        start: {
+            x: position.x,
+            y: position.y + this.height,
+            z: position.z
+        },
+        end: {
+            x: position.x,
+            y: position.y - this.height,
+            z: position.z
+        }
+    });
+}
+
+var beacon = new Beacon();
+
+
+// TODO: play sounds again when we aren't leaking AudioInjector threads
+// var grabSound = SoundCache.getSound("https://hifi-public.s3.amazonaws.com/eric/sounds/CloseClamp.wav");
+// var releaseSound = SoundCache.getSound("https://hifi-public.s3.amazonaws.com/eric/sounds/ReleaseClamp.wav");
+// var VOLUME = 0.0;
+
+
+// Grabber class stores and computes info for grab behavior
+Grabber = function() {
+    this.isGrabbing = false;
+    this.entityID = null;
+    this.actionID = null;
+    this.startPosition = ZERO_VEC3;
+    this.lastRotation = IDENTITY_QUAT;
+    this.currentPosition = ZERO_VEC3;
+    this.planeNormal = ZERO_VEC3;
+
+    this.originalGravity = ZERO_VEC3;
+    // maxDistance is a function of the size of the object.
+    this.maxDistance;
+
+    // mode defines the degrees of freedom of the grab target positions
+    // relative to startPosition options include:
+    //     xzPlane  (default)
+    //     verticalCylinder  (SHIFT)
+    //     rotate  (CONTROL)
+    this.mode = "xzplane";
+    
+    // offset allows the user to grab an object off-center.  It points from the object's center
+    // to the point where the ray intersects the grab plane (at the moment the grab is initiated).
+    // Future target positions of the ray intersection are on the same plane, and the offset is subtracted
+    // to compute the target position of the object's center.
+    this.offset = {x: 0, y: 0, z: 0 };
+    
+    this.targetPosition;
+    this.targetRotation;
+
+    this.liftKey = false; // SHIFT
+    this.rotateKey = false; // CONTROL
+}
+
+Grabber.prototype.computeNewGrabPlane = function() {
+    if (!this.isGrabbing) {
         return;
     }
 
-    var maybeResetMousePosition = false;
-    if (gGrabMode !== "rotate") {
-        gMouseAtRotateStart = gMouseCursorLocation;
+    var modeWasRotate = (this.mode == "rotate");
+    this.mode = "xzPlane";
+    this.planeNormal = {x: 0, y: 1, z: 0 };
+    if (this.rotateKey) {
+        this.mode = "rotate";
+        mouse.startRotateDrag();
     } else {
-        maybeResetMousePosition = true;
-    }
-    gGrabMode = "xzPlane";
-    gPlaneNormal = { x: 0, y: 1, z: 0 };
-    if (gLiftKey) {
-        if (!gRotateKey) {
-            gGrabMode = "verticalCylinder";
-            // a new planeNormal will be computed each move
+        if (modeWasRotate) {
+            // we reset the mouse screen position whenever we stop rotating
+            mouse.restoreRotateCursor();
         }
-    } else if (gRotateKey) {
-        gGrabMode = "rotate";
-    }
+        if (this.liftKey) {
+            this.mode = "verticalCylinder";
+            // NOTE: during verticalCylinder mode a new planeNormal will be computed each move
+        }
+    } 
 
-    gPointOnPlane = Vec3.sum(gCurrentPosition, gGrabOffset);
-    var xzOffset = Vec3.subtract(gPointOnPlane, Camera.getPosition());
+    this.pointOnPlane = Vec3.sum(this.currentPosition, this.offset);
+    var xzOffset = Vec3.subtract(this.pointOnPlane, Camera.getPosition());
     xzOffset.y = 0;
-    gXzDistanceToGrab = Vec3.length(xzOffset);
-
-    if (gGrabMode !== "rotate" && maybeResetMousePosition) {
-        // we reset the mouse position whenever we stop rotating
-        Window.setCursorPosition(gMouseAtRotateStart.x, gMouseAtRotateStart.y);
-    }
+    this.xzDistanceToGrab = Vec3.length(xzOffset);
 }
 
-function mousePressEvent(event) {
+Grabber.prototype.pressEvent = function(event) {
     if (!event.isLeftButton) {
         return;
     }
-    gInitialMouse = {x: event.x, y: event.y };
-    gPreviousMouse = {x: event.x, y: event.y };
 
     var pickRay = Camera.computePickRay(event.x, event.y);
     var pickResults = Entities.findRayIntersection(pickRay, true); // accurate picking
@@ -193,150 +217,172 @@ function mousePressEvent(event) {
         return;
     }
 
+    mouse.startDrag(event);
+
     var clickedEntity = pickResults.entityID;
     var entityProperties = Entities.getEntityProperties(clickedEntity)
-    gStartPosition = entityProperties.position;
-    gStartRotation = entityProperties.rotation;
+    this.startPosition = entityProperties.position;
+    this.lastRotation = entityProperties.rotation;
     var cameraPosition = Camera.getPosition();
 
-    gBeaconHeight = Vec3.length(entityProperties.dimensions);
-    gMaxGrabDistance = gBeaconHeight / MAX_SOLID_ANGLE;
-    if (Vec3.distance(gStartPosition, cameraPosition) > gMaxGrabDistance) {
+    var objectBoundingDiameter = Vec3.length(entityProperties.dimensions);
+    beacon.height = objectBoundingDiameter;
+    this.maxDistance = objectBoundingDiameter / MAX_SOLID_ANGLE;
+    if (Vec3.distance(this.startPosition, cameraPosition) > this.maxDistance) {
         // don't allow grabs of things far away
         return;
     }
 
     Entities.editEntity(clickedEntity, { gravity: ZERO_VEC3 });
-    gIsGrabbing = true;
+    this.isGrabbing = true;
 
-    gGrabbedEntity = clickedEntity;
-    gCurrentPosition = entityProperties.position;
-    gOriginalGravity = entityProperties.gravity;
-    gTargetPosition = gStartPosition;
+    this.entityID = clickedEntity;
+    this.currentPosition = entityProperties.position;
+    this.originalGravity = entityProperties.gravity;
+    this.targetPosition = {x: this.startPosition.x, y: this.startPosition.y, z: this.startPosition.z};
 
     // compute the grab point
-    var nearestPoint = Vec3.subtract(gStartPosition, cameraPosition);
+    var nearestPoint = Vec3.subtract(this.startPosition, cameraPosition);
     var distanceToGrab = Vec3.dot(nearestPoint, pickRay.direction);
     nearestPoint = Vec3.multiply(distanceToGrab, pickRay.direction);
-    gPointOnPlane = Vec3.sum(cameraPosition, nearestPoint);
+    this.pointOnPlane = Vec3.sum(cameraPosition, nearestPoint);
 
     // compute the grab offset (points from object center to point of grab)
-    gGrabOffset = Vec3.subtract(gPointOnPlane, gStartPosition);
+    this.offset = Vec3.subtract(this.pointOnPlane, this.startPosition);
 
-    computeNewGrabPlane();
+    this.computeNewGrabPlane();
 
-    updateDropLine(gStartPosition);
+    beacon.updatePosition(this.startPosition);
 
     // TODO: play sounds again when we aren't leaking AudioInjector threads
     //Audio.playSound(grabSound, { position: entityProperties.position, volume: VOLUME });
 }
 
-function mouseReleaseEvent() {
-    if (gIsGrabbing) {
-        if (Vec3.length(gOriginalGravity) != 0) {
-            Entities.editEntity(gGrabbedEntity, { gravity: gOriginalGravity });
+Grabber.prototype.releaseEvent = function() {
+    if (this.isGrabbing) {
+        if (Vec3.length(this.originalGravity) != 0) {
+            Entities.editEntity(this.entityID, { gravity: this.originalGravity});
         }
 
-        gIsGrabbing = false
-        Entities.deleteAction(gGrabbedEntity, gActionID);
-        gActionID = null;
+        this.isGrabbing = false
+        Entities.deleteAction(this.entityID, this.actionID);
+        this.actionID = null;
 
-        Overlays.editOverlay(gBeacon, { visible: false });
+        beacon.disable();
 
         // TODO: play sounds again when we aren't leaking AudioInjector threads
         //Audio.playSound(releaseSound, { position: entityProperties.position, volume: VOLUME });
     }
 }
 
-function mouseMoveEvent(event) {
-    if (!gIsGrabbing) {
+Grabber.prototype.moveEvent = function(event) {
+    if (!this.isGrabbing) {
         return;
     }
+    mouse.updateDrag(event);
 
     // see if something added/restored gravity
-    var entityProperties = Entities.getEntityProperties(gGrabbedEntity);
+    var entityProperties = Entities.getEntityProperties(this.entityID);
     if (Vec3.length(entityProperties.gravity) != 0) {
-        gOriginalGravity = entityProperties.gravity;
+        this.originalGravity = entityProperties.gravity;
     }
-    gCurrentPosition = entityProperties.position;
+    this.currentPosition = entityProperties.position;
 
     var actionArgs = {};
 
-    if (gGrabMode === "rotate") {
-        var deltaMouse = { x: 0, y: 0 };
-        var dx = event.x - gInitialMouse.x;
-        var dy = event.y - gInitialMouse.y;
+    if (this.mode === "rotate") {
+        var drag = mouse.getDrag();
         var orientation = Camera.getOrientation();
-        var dragOffset = Vec3.multiply(dx, Quat.getRight(orientation));
-        dragOffset = Vec3.sum(dragOffset, Vec3.multiply(-dy, Quat.getUp(orientation)));
+        var dragOffset = Vec3.multiply(drag.x, Quat.getRight(orientation));
+        dragOffset = Vec3.sum(dragOffset, Vec3.multiply(-drag.y, Quat.getUp(orientation)));
         var axis = Vec3.cross(dragOffset, Quat.getFront(orientation));
         axis = Vec3.normalize(axis);
         var ROTATE_STRENGTH = 0.4; // magic number tuned by hand
-        var angle = ROTATE_STRENGTH * Math.sqrt((dx * dx) + (dy * dy));
+        var angle = ROTATE_STRENGTH * Math.sqrt((drag.x * drag.x) + (drag.y * drag.y));
         var deltaQ = Quat.angleAxis(angle, axis);
         // var qZero = entityProperties.rotation;
-        var qZero = gStartRotation;
-        var qOne = Quat.multiply(deltaQ, qZero);
-        actionArgs = {targetRotation: qOne, angularTimeScale: 0.1};
+        //var qZero = this.lastRotation;
+        this.lastRotation = Quat.multiply(deltaQ, this.lastRotation);
+        actionArgs = {targetRotation: this.lastRotation, angularTimeScale: 0.1};
     } else {
-        var newTargetPosition;
-        if (gGrabMode === "verticalCylinder") {
+        var newPointOnPlane;
+        if (this.mode === "verticalCylinder") {
             // for this mode we recompute the plane based on current Camera
             var planeNormal = Quat.getFront(Camera.getOrientation());
             planeNormal.y = 0;
             planeNormal = Vec3.normalize(planeNormal);
-            var pointOnCylinder = Vec3.multiply(planeNormal, gXzDistanceToGrab);
+            var pointOnCylinder = Vec3.multiply(planeNormal, this.xzDistanceToGrab);
             pointOnCylinder = Vec3.sum(Camera.getPosition(), pointOnCylinder);
-            newTargetPosition = mouseIntersectionWithPlane(pointOnCylinder, planeNormal, event);
-            gPointOnPlane = Vec3.sum(newTargetPosition, gGrabOffset);
+            this.pointOnPlane = mouseIntersectionWithPlane(pointOnCylinder, planeNormal, mouse.current, this.maxDistance);
+            newPointOnPlane = {x: this.pointOnPlane.x, y: this.pointOnPlane.y, z: this.pointOnPlane.z};
         } else {
             var cameraPosition = Camera.getPosition();
-            newTargetPosition = mouseIntersectionWithPlane(gPointOnPlane, gPlaneNormal, event);
-            var relativePosition = Vec3.subtract(newTargetPosition, cameraPosition);
+            newPointOnPlane = mouseIntersectionWithPlane(this.pointOnPlane, this.planeNormal, mouse.current, this.maxDistance);
+            var relativePosition = Vec3.subtract(newPointOnPlane, cameraPosition);
             var distance = Vec3.length(relativePosition);
-            if (distance > gMaxGrabDistance) {
+            if (distance > this.maxDistance) {
                 // clamp distance
-                relativePosition = Vec3.multiply(relativePosition, gMaxGrabDistance / distance);
-                newTargetPosition = Vec3.sum(relativePosition, cameraPosition);
+                relativePosition = Vec3.multiply(relativePosition, this.maxDistance / distance);
+                newPointOnPlane = Vec3.sum(relativePosition, cameraPosition);
             }
         }
-        gTargetPosition = Vec3.subtract(newTargetPosition, gGrabOffset);
-        actionArgs = {targetPosition: gTargetPosition, linearTimeScale: 0.1};
-    }
-    gPreviousMouse = { x: event.x, y: event.y };
-    gMouseCursorLocation = { x: Window.getCursorPositionX(), y: Window.getCursorPositionY() };
+        this.targetPosition = Vec3.subtract(newPointOnPlane, this.offset);
+        actionArgs = {targetPosition: this.targetPosition, linearTimeScale: 0.1};
 
-    if (!gActionID) {
-        gActionID = Entities.addAction("spring", gGrabbedEntity, actionArgs);
+        beacon.updatePosition(this.targetPosition);
+    }
+
+    if (!this.actionID) {
+        this.actionID = Entities.addAction("spring", this.entityID, actionArgs);
     } else {
-        Entities.updateAction(gGrabbedEntity, gActionID, actionArgs);
+        Entities.updateAction(this.entityID, this.actionID, actionArgs);
     }
-
-    updateDropLine(gTargetPosition);
 }
 
-function keyReleaseEvent(event) {
+Grabber.prototype.keyReleaseEvent = function(event) {
     if (event.text === "SHIFT") {
-        gLiftKey = false;
+        this.liftKey = false;
     }
     if (event.text === "CONTROL") {
-        gRotateKey = false;
+        this.rotateKey = false;
     }
-    computeNewGrabPlane();
+    this.computeNewGrabPlane();
+}
+
+Grabber.prototype.keyPressEvent = function(event) {
+    if (event.text === "SHIFT") {
+        this.liftKey = true;
+    }
+    if (event.text === "CONTROL") {
+        this.rotateKey = true;
+    }
+    this.computeNewGrabPlane();
+}
+
+var grabber = new Grabber();
+
+function pressEvent(event) {
+    grabber.pressEvent(event);
+}
+
+function moveEvent(event) {
+    grabber.moveEvent(event);
+}
+
+function releaseEvent(event) {
+    grabber.releaseEvent(event);
 }
 
 function keyPressEvent(event) {
-    if (event.text === "SHIFT") {
-        gLiftKey = true;
-    }
-    if (event.text === "CONTROL") {
-        gRotateKey = true;
-    }
-    computeNewGrabPlane();
+    grabber.keyPressEvent(event);
 }
 
-Controller.mouseMoveEvent.connect(mouseMoveEvent);
-Controller.mousePressEvent.connect(mousePressEvent);
-Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
+function keyReleaseEvent(event) {
+    grabber.keyReleaseEvent(event);
+}
+
+Controller.mousePressEvent.connect(pressEvent);
+Controller.mouseMoveEvent.connect(moveEvent);
+Controller.mouseReleaseEvent.connect(releaseEvent);
 Controller.keyPressEvent.connect(keyPressEvent);
 Controller.keyReleaseEvent.connect(keyReleaseEvent);
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 1fc0bf19b5..f61f725c4e 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -1571,7 +1571,9 @@ void Application::mouseMoveEvent(QMouseEvent* event, unsigned int deviceID) {
         return;
     }
 
-    _keyboardMouseDevice.mouseMoveEvent(event, deviceID);
+    if (deviceID == 0) {
+        _keyboardMouseDevice.mouseMoveEvent(event, deviceID);
+    }
 
 }
 
@@ -1592,7 +1594,9 @@ void Application::mousePressEvent(QMouseEvent* event, unsigned int deviceID) {
 
 
     if (activeWindow() == _window) {
-        _keyboardMouseDevice.mousePressEvent(event);
+        if (deviceID == 0) {
+            _keyboardMouseDevice.mousePressEvent(event);
+        }
 
         if (event->button() == Qt::LeftButton) {
             _mouseDragStarted = getTrueMouse();
@@ -1632,7 +1636,9 @@ void Application::mouseReleaseEvent(QMouseEvent* event, unsigned int deviceID) {
     }
 
     if (activeWindow() == _window) {
-        _keyboardMouseDevice.mouseReleaseEvent(event);
+        if (deviceID == 0) {
+            _keyboardMouseDevice.mouseReleaseEvent(event);
+        }
 
         if (event->button() == Qt::LeftButton) {
             _mousePressed = false;
diff --git a/interface/src/avatar/Avatar.cpp b/interface/src/avatar/Avatar.cpp
index 97aa496b61..8d72591615 100644
--- a/interface/src/avatar/Avatar.cpp
+++ b/interface/src/avatar/Avatar.cpp
@@ -523,7 +523,7 @@ void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, boo
 
     auto cameraMode = Application::getInstance()->getCamera()->getMode();
     if (!isMyAvatar() || cameraMode != CAMERA_MODE_FIRST_PERSON) {
-        renderDisplayName(batch, *renderArgs->_viewFrustum);
+        renderDisplayName(batch, *renderArgs->_viewFrustum, renderArgs->_viewport);
     }
 }
 
@@ -674,7 +674,7 @@ glm::vec3 Avatar::getDisplayNamePosition() const {
     return namePosition;
 }
 
-Transform Avatar::calculateDisplayNameTransform(const ViewFrustum& frustum, float fontSize) const {
+Transform Avatar::calculateDisplayNameTransform(const ViewFrustum& frustum, float fontSize, const glm::ivec4& viewport) const {
     Transform result;
     // We assume textPosition is whithin the frustum
     glm::vec3 textPosition = getDisplayNamePosition();
@@ -693,12 +693,7 @@ Transform Avatar::calculateDisplayNameTransform(const ViewFrustum& frustum, floa
     glm::vec4 p0 = viewProj * glm::vec4(testPoint0, 1.0);
     glm::vec4 p1 = viewProj * glm::vec4(testPoint1, 1.0);
     
-    // TODO REMOVE vvv
-    GLint viewportMatrix[4];
-    glGetIntegerv(GL_VIEWPORT, viewportMatrix);
-    glm::dmat4 modelViewMatrix;
-    float windowSizeY = viewportMatrix[3] - viewportMatrix[1];
-    // TODO REMOVE ^^^
+    float windowSizeY = viewport.w;
     
     const float DESIRED_HIGHT_ON_SCREEN = 20; // In pixels (this is double on retinas)
     
@@ -731,7 +726,7 @@ Transform Avatar::calculateDisplayNameTransform(const ViewFrustum& frustum, floa
 
 }
 
-void Avatar::renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum) const {
+void Avatar::renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum, const glm::ivec4& viewport) const {
     bool shouldShowReceiveStats = DependencyManager::get<AvatarManager>()->shouldShowReceiveStats() && !isMyAvatar();
 
     // If we have nothing to draw, or it's tottaly transparent, return
@@ -773,7 +768,7 @@ void Avatar::renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum) co
                               (_displayNameAlpha / DISPLAYNAME_ALPHA) * DISPLAYNAME_BACKGROUND_ALPHA);
     
     // Compute display name transform
-    auto textTransform = calculateDisplayNameTransform(frustum, renderer->getFontSize());
+    auto textTransform = calculateDisplayNameTransform(frustum, renderer->getFontSize(), viewport);
     batch.setModelTransform(textTransform);
 
     DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(batch, false, true, true, true);
diff --git a/interface/src/avatar/Avatar.h b/interface/src/avatar/Avatar.h
index b4bf0cf097..bafec6af33 100644
--- a/interface/src/avatar/Avatar.h
+++ b/interface/src/avatar/Avatar.h
@@ -234,8 +234,8 @@ protected:
     float getPelvisFloatingHeight() const;
     glm::vec3 getDisplayNamePosition() const;
 
-    Transform calculateDisplayNameTransform(const ViewFrustum& frustum, float fontSize) const;
-    void renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum) const;
+    Transform calculateDisplayNameTransform(const ViewFrustum& frustum, float fontSize, const glm::ivec4& viewport) const;
+    void renderDisplayName(gpu::Batch& batch, const ViewFrustum& frustum, const glm::ivec4& viewport) const;
     virtual void renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel = 0.0f);
     virtual bool shouldRenderHead(const RenderArgs* renderArgs) const;
     virtual void fixupModelsInScene();
diff --git a/interface/src/avatar/SkeletonModel.cpp b/interface/src/avatar/SkeletonModel.cpp
index 2d4baaf237..0a981706da 100644
--- a/interface/src/avatar/SkeletonModel.cpp
+++ b/interface/src/avatar/SkeletonModel.cpp
@@ -120,8 +120,8 @@ void SkeletonModel::simulate(float deltaTime, bool fullUpdate) {
     Hand* hand = _owningAvatar->getHand();
     hand->getLeftRightPalmIndices(leftPalmIndex, rightPalmIndex);
 
-    const float HAND_RESTORATION_RATE = 0.25f;    
-    if (leftPalmIndex == -1 || rightPalmIndex == -1) {
+    const float HAND_RESTORATION_RATE = 0.25f;
+    if (leftPalmIndex == -1 && rightPalmIndex == -1) {
         // palms are not yet set, use mouse
         if (_owningAvatar->getHandState() == HAND_STATE_NULL) {
             restoreRightHandPosition(HAND_RESTORATION_RATE, PALM_PRIORITY);
@@ -138,8 +138,16 @@ void SkeletonModel::simulate(float deltaTime, bool fullUpdate) {
         restoreLeftHandPosition(HAND_RESTORATION_RATE, PALM_PRIORITY);
 
     } else {
-        applyPalmData(geometry.leftHandJointIndex, hand->getPalms()[leftPalmIndex]);
-        applyPalmData(geometry.rightHandJointIndex, hand->getPalms()[rightPalmIndex]);
+        if (leftPalmIndex != -1) {
+            applyPalmData(geometry.leftHandJointIndex, hand->getPalms()[leftPalmIndex]);
+        } else {
+            restoreLeftHandPosition(HAND_RESTORATION_RATE, PALM_PRIORITY);
+        }
+        if (rightPalmIndex != -1) {
+            applyPalmData(geometry.rightHandJointIndex, hand->getPalms()[rightPalmIndex]);
+        } else {
+            restoreRightHandPosition(HAND_RESTORATION_RATE, PALM_PRIORITY);
+        }
     }
 
     if (_isFirstPerson) {
@@ -791,19 +799,24 @@ void SkeletonModel::renderBoundingCollisionShapes(gpu::Batch& batch, float alpha
     transform.setTranslation(endPoint);
     batch.setModelTransform(transform);
     auto geometryCache = DependencyManager::get<GeometryCache>();
-    geometryCache->renderSphere(batch, _boundingShape.getRadius(), BALL_SUBDIVISIONS, BALL_SUBDIVISIONS, glm::vec4(0.6f, 0.6f, 0.8f, alpha));
+    geometryCache->renderSphere(batch, _boundingShape.getRadius(), BALL_SUBDIVISIONS, BALL_SUBDIVISIONS, 
+                                glm::vec4(0.6f, 0.6f, 0.8f, alpha));
 
     // draw a yellow sphere at the capsule startpoint
     glm::vec3 startPoint;
     _boundingShape.getStartPoint(startPoint);
     startPoint = startPoint - _translation;
     glm::vec3 axis = endPoint - startPoint;
-    glTranslatef(-axis.x, -axis.y, -axis.z);
-    geometryCache->renderSphere(_boundingShape.getRadius(), BALL_SUBDIVISIONS, BALL_SUBDIVISIONS, glm::vec4(0.8f, 0.8f, 0.6f, alpha));
+    Transform axisTransform = Transform();
+    axisTransform.setTranslation(-axis);
+    batch.setModelTransform(axisTransform);
+    geometryCache->renderSphere(batch, _boundingShape.getRadius(), BALL_SUBDIVISIONS, BALL_SUBDIVISIONS, 
+                                glm::vec4(0.8f, 0.8f, 0.6f, alpha));
 
     // draw a green cylinder between the two points
     glm::vec3 origin(0.0f);
-    Avatar::renderJointConnectingCone(batch,  origin, axis, _boundingShape.getRadius(), _boundingShape.getRadius(), glm::vec4(0.6f, 0.8f, 0.6f, alpha));
+    Avatar::renderJointConnectingCone(batch, origin, axis, _boundingShape.getRadius(), _boundingShape.getRadius(), 
+                                      glm::vec4(0.6f, 0.8f, 0.6f, alpha));
 }
 
 bool SkeletonModel::hasSkeleton() {
diff --git a/interface/src/devices/SixenseManager.cpp b/interface/src/devices/SixenseManager.cpp
index 12b6f4263b..c82027cb38 100644
--- a/interface/src/devices/SixenseManager.cpp
+++ b/interface/src/devices/SixenseManager.cpp
@@ -244,14 +244,6 @@ void SixenseManager::update(float deltaTime) {
             palm->setTrigger(data->trigger);
             palm->setJoystick(data->joystick_x, data->joystick_y);
 
-            handleButtonEvent(data->buttons, numActiveControllers - 1);
-            handleAxisEvent(data->joystick_x, data->joystick_y, data->trigger, numActiveControllers - 1);
-
-            // Emulate the mouse so we can use scripts
-            if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseMouseInput) && !_controllersAtBase) {
-                emulateMouse(palm, numActiveControllers - 1);
-            }
-
             // NOTE: Sixense API returns pos data in millimeters but we IMMEDIATELY convert to meters.
             glm::vec3 position(data->pos[0], data->pos[1], data->pos[2]);
             position *= METERS_PER_MILLIMETER;
@@ -260,6 +252,15 @@ void SixenseManager::update(float deltaTime) {
             const float CONTROLLER_AT_BASE_DISTANCE = 0.075f;
             if (glm::length(position) < CONTROLLER_AT_BASE_DISTANCE) {
                 numControllersAtBase++;
+                palm->setActive(false);
+            } else {
+                handleButtonEvent(data->buttons, numActiveControllers - 1);
+                handleAxisEvent(data->joystick_x, data->joystick_y, data->trigger, numActiveControllers - 1);
+                
+                // Emulate the mouse so we can use scripts
+                if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseMouseInput) && !_controllersAtBase) {
+                    emulateMouse(palm, numActiveControllers - 1);
+                }
             }
 
             // Transform the measured position into body frame.
diff --git a/interface/src/ui/ApplicationCompositor.cpp b/interface/src/ui/ApplicationCompositor.cpp
index 8565371a9b..4623109cdd 100644
--- a/interface/src/ui/ApplicationCompositor.cpp
+++ b/interface/src/ui/ApplicationCompositor.cpp
@@ -197,7 +197,6 @@ void ApplicationCompositor::displayOverlayTexture(RenderArgs* renderArgs) {
     updateTooltips();
 
     auto deviceSize = qApp->getDeviceSize();
-    glViewport(0, 0, deviceSize.width(), deviceSize.height());
 
     //Handle fading and deactivation/activation of UI
     gpu::Batch batch;
diff --git a/interface/src/ui/overlays/Cube3DOverlay.cpp b/interface/src/ui/overlays/Cube3DOverlay.cpp
index 3455ce2e51..7f6fd5f971 100644
--- a/interface/src/ui/overlays/Cube3DOverlay.cpp
+++ b/interface/src/ui/overlays/Cube3DOverlay.cpp
@@ -33,8 +33,6 @@ void Cube3DOverlay::render(RenderArgs* args) {
     const float MAX_COLOR = 255.0f;
     glm::vec4 cubeColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
 
-    //glDisable(GL_LIGHTING);
-
     // TODO: handle registration point??
     glm::vec3 position = getPosition();
     glm::vec3 center = getCenter();
diff --git a/libraries/gpu/src/gpu/Batch.h b/libraries/gpu/src/gpu/Batch.h
index bf6883e3a9..244ede7151 100644
--- a/libraries/gpu/src/gpu/Batch.h
+++ b/libraries/gpu/src/gpu/Batch.h
@@ -86,7 +86,7 @@ public:
     // Then by the inverse of the ViewTransform from world space to eye space
     // finaly projected into the clip space by the projection transform
     // WARNING: ViewTransform transform from eye space to world space, its inverse is composed
-    // with the ModelTransformu to create the equivalent of the glModelViewMatrix
+    // with the ModelTransform to create the equivalent of the gl ModelViewMatrix
     void setModelTransform(const Transform& model);
     void setViewTransform(const Transform& view);
     void setProjectionTransform(const Mat4& proj);
@@ -114,7 +114,7 @@ public:
     // TODO: As long as we have gl calls explicitely issued from interface
     // code, we need to be able to record and batch these calls. THe long 
     // term strategy is to get rid of any GL calls in favor of the HIFI GPU API
-    // For now, instead of calling the raw glCall, use the equivalent call on the batch so the call is beeing recorded
+    // For now, instead of calling the raw gl Call, use the equivalent call on the batch so the call is beeing recorded
     // THe implementation of these functions is in GLBackend.cpp
 
     void _glEnable(GLenum cap);
diff --git a/libraries/gpu/src/gpu/Shader.h b/libraries/gpu/src/gpu/Shader.h
index 9193ddb778..9c3953bff5 100755
--- a/libraries/gpu/src/gpu/Shader.h
+++ b/libraries/gpu/src/gpu/Shader.h
@@ -148,7 +148,7 @@ public:
     //
     // As of now (03/2015), the call to makeProgram is in fact calling gpu::Context::makeProgram and does rely
     // on the underneath gpu::Context::Backend available. Since we only support glsl, this means that it relies
-    //  on a glContext and the driver to compile the glsl shader. 
+    // on a gl Context and the driver to compile the glsl shader. 
     // Hoppefully in a few years the shader compilation will be completely abstracted in a separate shader compiler library
     // independant of the graphics api in use underneath (looking at you opengl & vulkan).
     static bool makeProgram(Shader& shader, const Shader::BindingSet& bindings = Shader::BindingSet());
diff --git a/libraries/render-utils/src/GeometryCache.cpp b/libraries/render-utils/src/GeometryCache.cpp
index 7cb882acc1..2bf41bc9b3 100644
--- a/libraries/render-utils/src/GeometryCache.cpp
+++ b/libraries/render-utils/src/GeometryCache.cpp
@@ -433,8 +433,6 @@ void GeometryCache::renderGrid(gpu::Batch& batch, int x, int y, int width, int h
         }
         // Draw vertical grid lines
         for (int i = cols + 1; --i >= 0; ) {
-            //glVertex2i(tx, y);
-            //glVertex2i(tx, y + height);
             *(vertex++) = tx;
             *(vertex++) = y;
 
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 6385041959..07df7fbda4 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -55,10 +55,6 @@
 #include "model_lightmap_specular_map_frag.h"
 #include "model_translucent_frag.h"
 
-
-#define GLBATCH( call ) batch._##call
-//#define GLBATCH( call ) call
-
 using namespace std;
 
 static int modelPointerTypeId = qRegisterMetaType<QPointer<Model> >();
@@ -1850,22 +1846,6 @@ void Model::deleteGeometry() {
     _blendedBlendshapeCoefficients.clear();
 }
 
-void Model::setupBatchTransform(gpu::Batch& batch, RenderArgs* args) {
-    
-    // Capture the view matrix once for the rendering of this model
-    if (_transforms.empty()) {
-        _transforms.push_back(Transform());
-    }
-
-    // We should be able to use the Frustum viewpoint onstead of the "viewTransform"
-    // but it s still buggy in some cases, so let's s wait and fix it...
-    _transforms[0] = _viewState->getViewTransform();
-
-    _transforms[0].preTranslate(-_translation);
-
-    batch.setViewTransform(_transforms[0]);
-}
-
 AABox Model::getPartBounds(int meshIndex, int partIndex) {
 
     if (meshIndex < _meshStates.size()) {
@@ -2000,7 +1980,7 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
     }
     
     if (isSkinned) {
-        GLBATCH(glUniformMatrix4fv)(locations->clusterMatrices, state.clusterMatrices.size(), false,
+        batch._glUniformMatrix4fv(locations->clusterMatrices, state.clusterMatrices.size(), false,
             (const float*)state.clusterMatrices.constData());
        _transforms[0] = Transform();
        _transforms[0].preTranslate(_translation);
@@ -2021,7 +2001,7 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
     }
 
     if (mesh.colors.isEmpty()) {
-        GLBATCH(glColor4f)(1.0f, 1.0f, 1.0f, 1.0f);
+        batch._glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
     }
 
     // guard against partially loaded meshes
@@ -2077,7 +2057,7 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
                 if (!part.emissiveTexture.transform.isIdentity()) {
                     part.emissiveTexture.transform.getMatrix(texcoordTransform[1]);
                 }
-                GLBATCH(glUniformMatrix4fv)(locations->texcoordMatrices, 2, false, (const float*) &texcoordTransform);
+                batch._glUniformMatrix4fv(locations->texcoordMatrices, 2, false, (const float*) &texcoordTransform);
             }
 
             if (!mesh.tangents.isEmpty()) {                 
@@ -2102,7 +2082,7 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
                 //  assert(locations->emissiveParams >= 0); // we should have the emissiveParams defined in the shader
                 float emissiveOffset = part.emissiveParams.x;
                 float emissiveScale = part.emissiveParams.y;
-                GLBATCH(glUniform2f)(locations->emissiveParams, emissiveOffset, emissiveScale);
+                batch._glUniform2f(locations->emissiveParams, emissiveOffset, emissiveScale);
                 
                 NetworkTexture* emissiveMap = networkPart.emissiveTexture.data();
                 batch.setResourceTexture(locations->emissiveTextureUnit, (!emissiveMap || !emissiveMap->isLoaded()) ?
@@ -2210,12 +2190,12 @@ void Model::pickPrograms(gpu::Batch& batch, RenderMode mode, bool translucent, f
     batch.setPipeline((*pipeline).second._pipeline);
 
     if ((locations->alphaThreshold > -1) && (mode != RenderArgs::SHADOW_RENDER_MODE)) {
-        GLBATCH(glUniform1f)(locations->alphaThreshold, alphaThreshold);
+        batch._glUniform1f(locations->alphaThreshold, alphaThreshold);
     }
 
     if ((locations->glowIntensity > -1) && (mode != RenderArgs::SHADOW_RENDER_MODE)) {
         const float DEFAULT_GLOW_INTENSITY = 1.0f; // FIXME - glow is removed
-        GLBATCH(glUniform1f)(locations->glowIntensity, DEFAULT_GLOW_INTENSITY);
+        batch._glUniform1f(locations->glowIntensity, DEFAULT_GLOW_INTENSITY);
     }
 }
 
diff --git a/libraries/render-utils/src/Model.h b/libraries/render-utils/src/Model.h
index b2d5ba7e4a..b3a62b8da7 100644
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@@ -407,7 +407,6 @@ private:
 
     // helper functions used by render() or renderInScene()
 
-    void setupBatchTransform(gpu::Batch& batch, RenderArgs* args);
     static void pickPrograms(gpu::Batch& batch, RenderArgs::RenderMode mode, bool translucent, float alphaThreshold,
                             bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, bool isWireframe, RenderArgs* args,
                             Locations*& locations);
diff --git a/libraries/render-utils/src/TextRenderer.cpp b/libraries/render-utils/src/TextRenderer.cpp
index 0354a0217f..f86b8d226a 100644
--- a/libraries/render-utils/src/TextRenderer.cpp
+++ b/libraries/render-utils/src/TextRenderer.cpp
@@ -504,9 +504,6 @@ glm::vec2 Font::drawString(float x, float y, const QString & str,
     _vao->release();
     _texture->release(); // TODO: Brad & Sam, let's discuss this. Without this non-textured quads get their colors borked.
     _program->release();
-    // FIXME, needed?
-    // glDisable(GL_TEXTURE_2D);
-    
     
     return advance;
 }
diff --git a/libraries/render-utils/src/TextureCache.cpp b/libraries/render-utils/src/TextureCache.cpp
index 4df9718e24..953cfda910 100644
--- a/libraries/render-utils/src/TextureCache.cpp
+++ b/libraries/render-utils/src/TextureCache.cpp
@@ -110,9 +110,6 @@ const gpu::TexturePointer& TextureCache::getPermutationNormalTexture() {
 
         _permutationNormalTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC3, gpu::UINT8, gpu::RGB), 256, 2));
         _permutationNormalTexture->assignStoredMip(0, _blueTexture->getTexelFormat(), sizeof(data), data);
-
-       // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-       // glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     }
     return _permutationNormalTexture;
 }
@@ -122,13 +119,6 @@ const unsigned char OPAQUE_GRAY[] = { 0x80, 0x80, 0x80, 0xFF };
 const unsigned char OPAQUE_BLUE[] = { 0x80, 0x80, 0xFF, 0xFF };
 const unsigned char OPAQUE_BLACK[] = { 0x00, 0x00, 0x00, 0xFF };
 
-/*
-static void loadSingleColorTexture(const unsigned char* color) {
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, color);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-}
-*/
-
 const gpu::TexturePointer& TextureCache::getWhiteTexture() {
     if (!_whiteTexture) {
         _whiteTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA), 1, 1));
diff --git a/libraries/shared/src/Transform.h b/libraries/shared/src/Transform.h
index 6f841151c4..3b66bcd814 100644
--- a/libraries/shared/src/Transform.h
+++ b/libraries/shared/src/Transform.h
@@ -87,20 +87,20 @@ public:
     const Vec3& getTranslation() const;
     void setTranslation(const Vec3& translation); // [new this] = [translation] * [this.rotation] * [this.scale]
     void preTranslate(const Vec3& translation);   // [new this] = [translation] * [this]
-    void postTranslate(const Vec3& translation);  // [new this] = [this] * [translation] equivalent to glTranslate
+    void postTranslate(const Vec3& translation);  // [new this] = [this] * [translation] equivalent to:glTranslate
 
     const Quat& getRotation() const;
     void setRotation(const Quat& rotation); // [new this] = [this.translation] * [rotation] * [this.scale]
     void preRotate(const Quat& rotation);   // [new this] = [rotation] * [this]
-    void postRotate(const Quat& rotation);  // [new this] = [this] * [rotation] equivalent to glRotate
+    void postRotate(const Quat& rotation);  // [new this] = [this] * [rotation] equivalent to:glRotate
 
     const Vec3& getScale() const;
     void setScale(float scale);
     void setScale(const Vec3& scale);  // [new this] = [this.translation] * [this.rotation] * [scale]
     void preScale(float scale);
     void preScale(const Vec3& scale);
-    void postScale(float scale);       // [new this] = [this] * [scale] equivalent to glScale
-    void postScale(const Vec3& scale); // [new this] = [this] * [scale] equivalent to glScale
+    void postScale(float scale);       // [new this] = [this] * [scale] equivalent to:glScale
+    void postScale(const Vec3& scale); // [new this] = [this] * [scale] equivalent to:glScale
 
     bool isIdentity() const { return (_flags & ~Flags(FLAG_CACHE_INVALID_BITSET)).none(); }
     bool isTranslating() const { return _flags[FLAG_TRANSLATION]; }