diff --git a/assignment-client/src/AssignmentActionFactory.cpp b/assignment-client/src/AssignmentActionFactory.cpp
index e1c5d3adff..7c404cbd97 100644
--- a/assignment-client/src/AssignmentActionFactory.cpp
+++ b/assignment-client/src/AssignmentActionFactory.cpp
@@ -17,8 +17,7 @@ EntityActionPointer assignmentActionFactory(EntityActionType type, const QUuid&
 }
 
 
-EntityActionPointer AssignmentActionFactory::factory(EntitySimulation* simulation,
-                                                     EntityActionType type,
+EntityActionPointer AssignmentActionFactory::factory(EntityActionType type,
                                                      const QUuid& id,
                                                      EntityItemPointer ownerEntity,
                                                      QVariantMap arguments) {
@@ -33,9 +32,7 @@ EntityActionPointer AssignmentActionFactory::factory(EntitySimulation* simulatio
 }
 
 
-EntityActionPointer AssignmentActionFactory::factoryBA(EntitySimulation* simulation,
-                                                       EntityItemPointer ownerEntity,
-                                                       QByteArray data) {
+EntityActionPointer AssignmentActionFactory::factoryBA(EntityItemPointer ownerEntity, QByteArray data) {
     QDataStream serializedActionDataStream(data);
     EntityActionType type;
     QUuid id;
diff --git a/assignment-client/src/AssignmentActionFactory.h b/assignment-client/src/AssignmentActionFactory.h
index 41245dac68..e2d58f3e6a 100644
--- a/assignment-client/src/AssignmentActionFactory.h
+++ b/assignment-client/src/AssignmentActionFactory.h
@@ -19,14 +19,11 @@ class AssignmentActionFactory : public EntityActionFactoryInterface {
 public:
     AssignmentActionFactory() : EntityActionFactoryInterface() { }
     virtual ~AssignmentActionFactory() { }
-    virtual EntityActionPointer factory(EntitySimulation* simulation,
-                                        EntityActionType type,
+    virtual EntityActionPointer factory(EntityActionType type,
                                         const QUuid& id,
                                         EntityItemPointer ownerEntity,
                                         QVariantMap arguments);
-    virtual EntityActionPointer factoryBA(EntitySimulation* simulation,
-                                          EntityItemPointer ownerEntity,
-                                          QByteArray data);
+    virtual EntityActionPointer factoryBA(EntityItemPointer ownerEntity, QByteArray data);
 };
 
 #endif // hifi_AssignmentActionFactory_h
diff --git a/examples/animationPerfTest.js b/examples/animationPerfTest.js
index 6bf310db23..b832d2e61f 100644
--- a/examples/animationPerfTest.js
+++ b/examples/animationPerfTest.js
@@ -9,9 +9,7 @@
 var NUM_MOONS = 20; 
 // 1 = 60Hz, 2 = 30Hz, 3 = 20Hz, etc
 var UPDATE_FREQUENCY_DIVISOR = 2;
-
 var MAX_RANGE = 75.0; 
-var LIFETIME = 600;    
 var SCALE = 0.1;
 
 var center = Vec3.sum(MyAvatar.position, 
@@ -22,44 +20,47 @@ var PARTICLE_MIN_SIZE = 2.50;
 var PARTICLE_MAX_SIZE = 2.50;
 
 
-var planet = Entities.addEntity({ 
-        type: "Sphere",
-        position: center,  
-        dimensions: { x: 10 * SCALE, y: 10 * SCALE, z: 10 * SCALE }, 
-        color: { red: 0, green: 0, blue: 255 },
-        ignoreCollisions: true,
-        collisionsWillMove: false,
-        lifetime: LIFETIME
-});
+function deleteAnimationTestEntitites() {
+    var ids = Entities.findEntities(MyAvatar.position, 50);
+    for (var i = 0; i < ids.length; i++) {
+        var id = ids[i];
+        var properties = Entities.getEntityProperties(id);
+        if (properties.name == "AnimationTest") {
+            Entities.deleteEntity(id);
+        }
+    }
+}
+
+deleteAnimationTestEntitites();
 
 var moons = [];
 
 //  Create initial test particles that will move according to gravity from the planets
 for (var i = 0; i < NUM_MOONS; i++) {
-	var radius = PARTICLE_MIN_SIZE + Math.random() * PARTICLE_MAX_SIZE;
-	radius *= SCALE;
-	var gray = Math.random() * 155;
-	var position = { x: 10 , y: i * 3, z: 0 };
-	var color = { red: 100 + gray, green: 100 + gray, blue: 100 + gray };
-	if (i == 0) {
-		color = { red: 255, green: 0, blue: 0 };
-		radius = 6 * SCALE
-	}
-	moons.push(Entities.addEntity({ 
-		type: "Sphere",
-		position: Vec3.sum(center, position),  
-		dimensions: { x: radius, y: radius, z: radius }, 
-		color: color,
-		ignoreCollisions: true,
-		lifetime: LIFETIME,
-		collisionsWillMove: false 
-	})); 
+    var radius = PARTICLE_MIN_SIZE + Math.random() * PARTICLE_MAX_SIZE;
+    radius *= SCALE;
+    var gray = Math.random() * 155;
+    var position = { x: 10 , y: i * 3, z: 0 };
+    var color = { red: 100 + gray, green: 100 + gray, blue: 100 + gray };
+    if (i == 0) {
+        color = { red: 255, green: 0, blue: 0 };
+        radius = 6 * SCALE
+    }
+    moons.push(Entities.addEntity({ 
+        type: "Sphere",
+        name: "AnimationTest",
+        position: Vec3.sum(center, position),  
+        dimensions: { x: radius, y: radius, z: radius }, 
+        color: color,
+        ignoreCollisions: true,
+        collisionsWillMove: false
+
+    })); 
 }
 
 Script.update.connect(update);
 
 function scriptEnding() {
-	Entities.deleteEntity(planet);
     for (var i = 0; i < moons.length; i++) {
         Entities.deleteEntity(moons[i]);
     }
@@ -70,22 +71,20 @@ var updateCount = 0;
 function update(deltaTime) {
     //  Apply gravitational force from planets
     totalTime += deltaTime;
-	updateCount++;
-	if (0 != updateCount % UPDATE_FREQUENCY_DIVISOR) {
-		return;
-	}
-	
-    var planetProperties = Entities.getEntityProperties(planet);
-    var center = planetProperties.position;
+    updateCount++;
+    if (0 != updateCount % UPDATE_FREQUENCY_DIVISOR) {
+        return;
+    }
+    
     var particlePos = Entities.getEntityProperties(moons[0]).position;
     var relativePos = Vec3.subtract(particlePos.position, center);
     for (var t = 0; t < moons.length; t++) {
-		var thetaDelta = (Math.PI * 2.0 / NUM_MOONS) * t;
-		var y = Math.sin(totalTime + thetaDelta) * 10.0 * SCALE;
-		var x = Math.cos(totalTime + thetaDelta) * 10.0 * SCALE;
+        var thetaDelta = (Math.PI * 2.0 / NUM_MOONS) * t;
+        var y = Math.sin(totalTime + thetaDelta) * 10.0 * SCALE;
+        var x = Math.cos(totalTime + thetaDelta) * 10.0 * SCALE;
         var newBasePos = Vec3.sum({ x: 0, y: y, z: x }, center);
         Entities.editEntity(moons[t], { position: newBasePos}); 
     }
 }
 
-Script.scriptEnding.connect(scriptEnding);
+Script.scriptEnding.connect(deleteAnimationTestEntitites);
diff --git a/examples/cubePerfTest.js b/examples/cubePerfTest.js
new file mode 100644
index 0000000000..e349b7add7
--- /dev/null
+++ b/examples/cubePerfTest.js
@@ -0,0 +1,58 @@
+//
+//  Created by Bradley Austin Davis on 2015/07/01
+//  Copyright 2015 High Fidelity, Inc.
+//  
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+var SIDE_SIZE = 10; 
+
+var center = { x: 0, y: 0, z: 0 };
+
+var DEGREES_TO_RADIANS = Math.PI / 180.0;
+var PARTICLE_MIN_SIZE = 2.50; 
+var PARTICLE_MAX_SIZE = 2.50;
+var LIFETIME = 600;
+var boxes = [];
+
+var ids = Entities.findEntities({ x: 512, y: 512, z: 512 }, 50);
+for (var i = 0; i < ids.length; i++) {
+    var id = ids[i];
+    var properties = Entities.getEntityProperties(id);
+    if (properties.name == "PerfTest") {
+    	Entities.deleteEntity(id);
+    }
+}
+
+
+//  Create initial test particles that will move according to gravity from the planets
+for (var x = 0; x < SIDE_SIZE; x++) {
+	for (var y = 0; y < SIDE_SIZE; y++) {
+		for (var z = 0; z < SIDE_SIZE; z++) {
+			var gray = Math.random() * 155;
+			var cube = Math.random() > 0.5;
+			var color = { red: 100 + gray, green: 100 + gray, blue: 100 + gray };
+			var position = { x: 512 + x * 0.2, y: 512 + y * 0.2, z: 512 + z * 0.2};
+			var radius = Math.random() * 0.1;
+			boxes.push(Entities.addEntity({ 
+				type: cube ? "Box" : "Sphere",
+				name: "PerfTest",
+				position: position,  
+				dimensions: { x: radius, y: radius, z: radius }, 
+				color: color,
+				ignoreCollisions: true,
+				collisionsWillMove: false, 
+				lifetime: LIFETIME
+			}));
+		}
+	}
+}
+
+
+function scriptEnding() {
+    for (var i = 0; i < boxes.length; i++) {
+        //Entities.deleteEntity(boxes[i]);
+    }
+}
+Script.scriptEnding.connect(scriptEnding);
diff --git a/examples/example/games/sword.js b/examples/example/games/sword.js
index 66503b62aa..18d6911f0b 100644
--- a/examples/example/games/sword.js
+++ b/examples/example/games/sword.js
@@ -11,24 +11,26 @@
 //
 "use strict";
 /*jslint vars: true*/
-var Script, Entities, MyAvatar, Window, Overlays, Controller, Vec3, Quat, print, ToolBar; // Referenced globals provided by High Fidelity.
-Script.include(["../../libraries/toolBars.js"]);
+var Script, Entities, MyAvatar, Window, Overlays, Controller, Vec3, Quat, print, ToolBar, Settings; // Referenced globals provided by High Fidelity.
+Script.include("http://s3.amazonaws.com/hifi-public/scripts/libraries/toolBars.js");
 
-var hand = "right";
+var hand = Settings.getValue("highfidelity.sword.hand", "right");
 var nullActionID = "00000000-0000-0000-0000-000000000000";
 var controllerID;
 var controllerActive;
 var stickID = null;
 var actionID = nullActionID;
 var targetIDs = [];
-var dimensions = { x: 0.3, y: 0.1, z: 2.0 };
-var AWAY_ORIENTATION =  Quat.fromPitchYawRollDegrees(-90, 0, 0);
+var dimensions = { x: 0.3, y: 0.15, z: 2.0 };
 var BUTTON_SIZE = 32;
 
 var stickModel = "https://hifi-public.s3.amazonaws.com/eric/models/stick.fbx";
 var swordModel = "https://hifi-public.s3.amazonaws.com/ozan/props/sword/sword.fbx";
+var swordCollisionShape = "https://hifi-public.s3.amazonaws.com/ozan/props/sword/sword.obj";
+var swordCollisionSoundURL = "http://public.highfidelity.io/sounds/Collisions-hitsandslaps/swordStrike1.wav";
+var avatarCollisionSoundURL = "https://s3.amazonaws.com/hifi-public/sounds/Collisions-hitsandslaps/airhockey_hit1.wav";
 var whichModel = "sword";
-var attachmentOffset, MOUSE_CONTROLLER_OFFSET = {x: 0.5, y: 0.4, z: 0.0}; // A fudge when using mouse rather than hand-controller, to hit yourself less often.
+var originalAvatarCollisionSound;
 
 var toolBar = new ToolBar(0, 0, ToolBar.vertical, "highfidelity.sword.toolbar", function () {
     return {x: 100, y: 380};
@@ -37,6 +39,7 @@ var toolBar = new ToolBar(0, 0, ToolBar.vertical, "highfidelity.sword.toolbar",
 var SWORD_IMAGE = "http://s3.amazonaws.com/hifi-public/images/billiardsReticle.png";  // Toggle between brandishing/sheathing sword (creating if necessary)
 var TARGET_IMAGE = "http://s3.amazonaws.com/hifi-public/images/puck.png"; // Create a target dummy
 var CLEANUP_IMAGE = "http://s3.amazonaws.com/hifi-public/images/delete.png"; // Remove sword and all target dummies.f
+var SWITCH_HANDS_IMAGE = "http://s3.amazonaws.com/hifi-public/images/up-arrow.svg"; // Toggle left vs right hand. Persists in settings.
 var swordButton = toolBar.addOverlay("image", {
     width: BUTTON_SIZE,
     height: BUTTON_SIZE,
@@ -49,6 +52,12 @@ var targetButton = toolBar.addOverlay("image", {
     imageURL: TARGET_IMAGE,
     alpha: 1
 });
+var switchHandsButton = toolBar.addOverlay("image", {
+    width: BUTTON_SIZE,
+    height: BUTTON_SIZE,
+    imageURL: SWITCH_HANDS_IMAGE,
+    alpha: 1
+});
 var cleanupButton = toolBar.addOverlay("image", {
     width: BUTTON_SIZE,
     height: BUTTON_SIZE,
@@ -77,53 +86,51 @@ function flash(color) {
     flasher.timer = Script.setTimeout(clearFlash, 500);
 }
 
-
 var health = 100;
-var display;
-var isAway = false;
+var display2d, display3d;
+function trackAvatarWithText() {
+    Entities.editEntity(display3d, {
+        position: Vec3.sum(MyAvatar.position, {x: 0, y: 1.5, z: 0}),
+        rotation: Quat.multiply(MyAvatar.orientation, Quat.fromPitchYawRollDegrees(0, 180, 0))
+    });
+}
 function updateDisplay() {
     var text = health.toString();
-    if (!display) {
+    if (!display2d) {
         health = 100;
-        display = Overlays.addOverlay("text", {
+        display2d = Overlays.addOverlay("text", {
             text: text,
             font: { size: 20 },
             color: {red: 0, green: 255, blue: 0},
             backgroundColor: {red: 100, green: 100, blue: 100}, // Why doesn't this and the next work?
             backgroundAlpha: 0.9,
-            x: Window.innerWidth - 50,
-            y: 50
+            x: toolBar.x - 5, // I'd like to add the score to the toolBar and have it drag with it, but toolBar doesn't support text (just buttons).
+            y: toolBar.y - 30 // So next best thing is to position it each time as if it were on top.
         });
+        display3d = Entities.addEntity({
+            name: MyAvatar.displayName + " score",
+            textColor: {red: 255, green: 255, blue: 255},
+            type: "Text",
+            text: text,
+            lineHeight: 0.14,
+            backgroundColor: {red: 64, green: 64, blue: 64},
+            dimensions: {x: 0.3, y: 0.2, z: 0.01},
+        });
+        Script.update.connect(trackAvatarWithText);
     } else {
-        Overlays.editOverlay(display, {text: text});
+        Overlays.editOverlay(display2d, {text: text});
+        Entities.editEntity(display3d, {text: text});
     }
 }
 function removeDisplay() {
-    if (display) {
-        Overlays.deleteOverlay(display);
-        display = null;
+    if (display2d) {
+        Overlays.deleteOverlay(display2d);
+        display2d = null;
+        Script.update.disconnect(trackAvatarWithText);
+        Entities.deleteEntity(display3d);
+        display3d = null;
     }
 }
-
-function cleanUp(leaveButtons) {
-    attachmentOffset = {x: 0, y: 0, z: 0};
-    if (stickID) {
-        Entities.deleteAction(stickID, actionID);
-        Entities.deleteEntity(stickID);
-        stickID = null;
-        actionID = null;
-    }
-    targetIDs.forEach(function (id) {
-        Entities.deleteAction(id.entity, id.action);
-        Entities.deleteEntity(id.entity);
-    });
-    targetIDs = [];
-    removeDisplay();
-    if (!leaveButtons) {
-        toolBar.cleanup();
-    }
-}
-
 function computeEnergy(collision, entityID) {
     var id = entityID || collision.idA || collision.idB;
     var entity = id && Entities.getEntityProperties(id);
@@ -133,31 +140,67 @@ function computeEnergy(collision, entityID) {
     return Math.min(Math.max(1.0, Math.round(energy)), 20);
 }
 function gotHit(collision) {
-    if (isAway) { return; }
     var energy = computeEnergy(collision);
+    print("Got hit - " + energy + " from " + collision.idA + " " + collision.idB);
     health -= energy;
     flash({red: 255, green: 0, blue: 0});
     updateDisplay();
 }
 function scoreHit(idA, idB, collision) {
-    if (isAway) { return; }
     var energy = computeEnergy(collision, idA);
+    print("Score + " + energy + " from " + JSON.stringify(idA) + " " + JSON.stringify(idB));
     health += energy;
     flash({red: 0, green: 255, blue: 0});
     updateDisplay();
 }
 
-function positionStick(stickOrientation) {
-    var baseOffset = Vec3.sum(attachmentOffset, {x: 0.0, y: 0.0, z: -dimensions.z / 2});
-    var offset = Vec3.multiplyQbyV(stickOrientation, baseOffset);
-    Entities.updateAction(stickID, actionID, {relativePosition: offset,
-                                              relativeRotation: stickOrientation});
+function isFighting() {
+    return stickID && (actionID !== nullActionID);
 }
 
-
+function initControls() {
+    print("Sword hand is " + hand);
+    if (hand === "right") {
+        controllerID = 3; // right handed
+    } else {
+        controllerID = 4; // left handed
+    }
+}
+var inHand = false;
+function positionStick(stickOrientation) {
+    var reorient = Quat.fromPitchYawRollDegrees(0, -90, 0);
+    var baseOffset = {x: -dimensions.z * 0.8, y: 0, z: 0};
+    var offset = Vec3.multiplyQbyV(reorient, baseOffset);
+    stickOrientation = Quat.multiply(reorient, stickOrientation);
+    inHand = false;
+    Entities.updateAction(stickID, actionID, {
+        relativePosition: offset,
+        relativeRotation: stickOrientation
+    });
+}
+function resetToHand() { // Maybe coordinate with positionStick?
+    if (inHand) { // Optimization: bail if we're already inHand.
+        return;
+    }
+    print('Reset to hand');
+    Entities.updateAction(stickID, actionID, {
+        relativePosition: {x: 0.0, y: 0.0, z: -dimensions.z * 0.5},
+        relativeRotation: Quat.fromVec3Degrees({x: 45.0, y: 0.0, z: 0.0}),
+        hand: hand,   // It should not be necessary to repeat these two, but there seems to be a bug in that that
+        timeScale: 0.05  // they do not retain their earlier values if you don't repeat them.
+    });
+    inHand = true;
+}
 function mouseMoveEvent(event) {
-    attachmentOffset = MOUSE_CONTROLLER_OFFSET;
-    if (!stickID || actionID === nullActionID || isAway) {
+    if (event.deviceID) { // Not a MOUSE mouse event, but a (e.g., hydra) mouse event, with x/y that is not meaningful for us.
+        resetToHand(); // Can only happen when controller is uncradled, so let's drive with that, resetting our attachement.
+        return;
+    }
+    controllerActive = (Vec3.length(Controller.getSpatialControlPosition(controllerID)) > 0);
+    //print("Mouse move with hand controller " + (controllerActive ? "active" : "inactive") + JSON.stringify(event));
+    if (controllerActive || !isFighting()) {
+        print('Attempting attachment reset');
+        resetToHand();
         return;
     }
     var windowCenterX = Window.innerWidth / 2;
@@ -167,73 +210,80 @@ function mouseMoveEvent(event) {
     var mouseXRatio = mouseXCenterOffset / windowCenterX;
     var mouseYRatio = mouseYCenterOffset / windowCenterY;
 
-    var stickOrientation = Quat.fromPitchYawRollDegrees(mouseYRatio * -90, mouseXRatio * -90, 0);
+    var stickOrientation = Quat.fromPitchYawRollDegrees(mouseYRatio * 90, mouseXRatio * 90, 0);
     positionStick(stickOrientation);
 }
 
-
-function initControls() {
-    if (hand === "right") {
-        controllerID = 3; // right handed
-    } else {
-        controllerID = 4; // left handed
+function removeSword() {
+    if (stickID) {
+        print('deleting action ' + actionID + ' and entity ' + stickID);
+        Entities.deleteAction(stickID, actionID);
+        Entities.deleteEntity(stickID);
+        stickID = null;
+        actionID = nullActionID;
+        Controller.mouseMoveEvent.disconnect(mouseMoveEvent);
+        MyAvatar.collisionWithEntity.disconnect(gotHit);
+        // removeEventhHandler happens automatically when the entity is deleted.
+    }
+    inHand = false;
+    if (originalAvatarCollisionSound !== undefined) {
+        MyAvatar.collisionSoundURL = originalAvatarCollisionSound;
+    }
+    removeDisplay();
+}
+function cleanUp(leaveButtons) {
+    removeSword();
+    targetIDs.forEach(function (id) {
+        Entities.deleteAction(id.entity, id.action);
+        Entities.deleteEntity(id.entity);
+    });
+    targetIDs = [];
+    if (!leaveButtons) {
+        toolBar.cleanup();
     }
 }
-
-
-function update() {
-    var palmPosition = Controller.getSpatialControlPosition(controllerID);
-    controllerActive = (Vec3.length(palmPosition) > 0);
-    if (!controllerActive) {
-        return;
+function makeSword() {
+    initControls();
+    stickID = Entities.addEntity({
+        type: "Model",
+        modelURL: swordModel,
+        compoundShapeURL: swordCollisionShape,
+        dimensions: dimensions,
+        position: (hand === 'right') ? MyAvatar.getRightPalmPosition() : MyAvatar.getLeftPalmPosition(), // initial position doesn't matter, as long as it's close
+        rotation: MyAvatar.orientation,
+        damping: 0.1,
+        collisionSoundURL: swordCollisionSoundURL,
+        restitution: 0.01,
+        collisionsWillMove: true
+    });
+    actionID = Entities.addAction("hold", stickID, {
+        relativePosition: {x: 0.0, y: 0.0, z: -dimensions.z * 0.5},
+        relativeRotation: Quat.fromVec3Degrees({x: 45.0, y: 0.0, z: 0.0}),
+        hand: hand,
+        timeScale: 0.05
+    });
+    if (actionID === nullActionID) {
+        print('*** FAILED TO MAKE SWORD ACTION ***');
+        cleanUp();
     }
-
-    var stickOrientation = Controller.getSpatialControlRawRotation(controllerID);
-    var adjustment = Quat.fromPitchYawRollDegrees(180, 0, 0);
-    stickOrientation = Quat.multiply(stickOrientation, adjustment);
-
-    positionStick(stickOrientation);
-}
-
-function toggleAway() {
-    isAway = !isAway;
-    if (isAway) {
-        positionStick(AWAY_ORIENTATION);
-        removeDisplay();
-    } else {
-        updateDisplay();
+    if (originalAvatarCollisionSound === undefined) {
+        originalAvatarCollisionSound = MyAvatar.collisionSoundURL; // We won't get MyAvatar.collisionWithEntity unless there's a sound URL. (Bug.)
+        SoundCache.getSound(avatarCollisionSoundURL); // Interface does not currently "preload" this? (Bug?)
     }
+    MyAvatar.collisionSoundURL = avatarCollisionSoundURL;
+    Controller.mouseMoveEvent.connect(mouseMoveEvent);
+    MyAvatar.collisionWithEntity.connect(gotHit);
+    Script.addEventHandler(stickID, 'collisionWithEntity', scoreHit);
+    updateDisplay();
 }
 
 function onClick(event) {
     switch (Overlays.getOverlayAtPoint(event)) {
     case swordButton:
         if (!stickID) {
-            initControls();
-            stickID = Entities.addEntity({
-                type: "Model",
-                modelURL: (whichModel === "sword") ? swordModel : stickModel,
-                //compoundShapeURL: "https://hifi-public.s3.amazonaws.com/eric/models/stick.obj",
-                shapeType: "box",
-                dimensions: dimensions,
-                position: MyAvatar.getRightPalmPosition(), // initial position doesn't matter, as long as it's close
-                rotation: MyAvatar.orientation,
-                damping: 0.1,
-                collisionSoundURL: "http://public.highfidelity.io/sounds/Collisions-hitsandslaps/swordStrike1.wav",
-                restitution: 0.01,
-                collisionsWillMove: true
-            });
-            actionID = Entities.addAction("hold", stickID, {relativePosition: {x: 0.0, y: 0.0, z: -dimensions.z / 2},
-                                                            hand: hand,
-                                                            timeScale: 0.15});
-            if (actionID === nullActionID) {
-                print('*** FAILED TO MAKE SWORD ACTION ***');
-                cleanUp();
-            }
-            Script.addEventHandler(stickID, 'collisionWithEntity', scoreHit);
-            updateDisplay();
+            makeSword();
         } else {
-            toggleAway();
+            removeSword();
         }
         break;
     case targetButton:
@@ -256,6 +306,12 @@ function onClick(event) {
                                             });
         targetIDs.push({entity: boxId, action: action});
         break;
+    case switchHandsButton:
+        cleanUp('leaveButtons');
+        hand = hand === "right" ? "left" : "right";
+        Settings.setValue("highfidelity.sword.hand", hand);
+        makeSword();
+        break;
     case cleanupButton:
         cleanUp('leaveButtons');
         break;
@@ -263,7 +319,4 @@ function onClick(event) {
 }
 
 Script.scriptEnding.connect(cleanUp);
-Controller.mouseMoveEvent.connect(mouseMoveEvent);
 Controller.mousePressEvent.connect(onClick);
-Script.update.connect(update);
-MyAvatar.collisionWithEntity.connect(gotHit);
diff --git a/examples/stick-hydra.js b/examples/stick-hydra.js
new file mode 100644
index 0000000000..a74f7954bb
--- /dev/null
+++ b/examples/stick-hydra.js
@@ -0,0 +1,73 @@
+//  stick-hydra.js
+//  examples
+//
+//  Created by Seth Alves on 2015-7-9
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Allow avatar to hold a stick and control it with a hand-tracker
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+var hand = "left";
+var nullActionID = "00000000-0000-0000-0000-000000000000";
+var controllerID;
+var controllerActive;
+var stickID = null;
+var actionID = nullActionID;
+var makingNewStick = false;
+
+function makeNewStick() {
+    if (makingNewStick) {
+        return;
+    }
+    makingNewStick = true;
+    cleanUp();
+    // sometimes if this is run immediately the stick doesn't get created?  use a timer.
+    Script.setTimeout(function() {
+        stickID = Entities.addEntity({
+            type: "Model",
+            name: "stick",
+            modelURL: "https://hifi-public.s3.amazonaws.com/eric/models/stick.fbx",
+            compoundShapeURL: "https://hifi-public.s3.amazonaws.com/eric/models/stick.obj",
+            dimensions: {x: .11, y: .11, z: 1.0},
+            position: MyAvatar.getRightPalmPosition(), // initial position doesn't matter, as long as it's close
+            rotation: MyAvatar.orientation,
+            damping: .1,
+            collisionSoundURL: "http://public.highfidelity.io/sounds/Collisions-hitsandslaps/67LCollision07.wav",
+            restitution: 0.01,
+            collisionsWillMove: true
+        });
+        actionID = Entities.addAction("hold", stickID,
+                                      {relativePosition: {x: 0.0, y: 0.0, z: -0.5},
+                                       relativeRotation: Quat.fromVec3Degrees({x: 0.0, y: 90.0, z: 0.0}),
+                                       hand: hand,
+                                       timeScale: 0.15});
+        if (actionID == nullActionID) {
+            cleanUp();
+        }
+        makingNewStick = false;
+    }, 3000);
+}
+
+
+function cleanUp() {
+    if (stickID) {
+        Entities.deleteEntity(stickID);
+        stickID = null;
+    }
+}
+
+
+function initControls(){
+    if (hand == "right") {
+        controllerID = 3; // right handed
+    } else {
+        controllerID = 4; // left handed
+    }
+}
+
+
+Script.scriptEnding.connect(cleanUp);
+makeNewStick();
diff --git a/examples/voxels.js b/examples/voxels.js
index 799af04bef..e110f15260 100644
--- a/examples/voxels.js
+++ b/examples/voxels.js
@@ -2,6 +2,32 @@ var controlHeld = false;
 var shiftHeld = false;
 
 
+function attemptVoxelChange(intersection) {
+    var ids = Entities.findEntities(intersection.intersection, 10);
+    var success = false;
+    for (var i = 0; i < ids.length; i++) {
+        var id = ids[i];
+        if (controlHeld) {
+            // hold control to erase a sphere
+            if (Entities.setVoxelSphere(id, intersection.intersection, 1.0, 0)) {
+                success = true;
+            }
+        } else if (shiftHeld) {
+            // hold shift to set all voxels to 255
+            if (Entities.setAllVoxels(id, 255)) {
+                success = true;
+            }
+        } else {
+            // no modifier key means to add a sphere
+            if (Entities.setVoxelSphere(id, intersection.intersection, 1.0, 255)) {
+                success = true;
+            }
+        }
+    }
+    return success;
+}
+
+
 function mousePressEvent(event) {
     if (!event.isLeftButton) {
         return;
@@ -9,20 +35,21 @@ function mousePressEvent(event) {
 
     var pickRay = Camera.computePickRay(event.x, event.y);
     var intersection = Entities.findRayIntersection(pickRay, true); // accurate picking
-    // var props = Entities.getEntityProperties(intersection.entityID);
+
+    // we've used a picking ray to decide where to add the new sphere of voxels.  If we pick nothing
+    // or if we pick a non-PolyVox entity, we fall through to the next picking attempt.
     if (intersection.intersects) {
-        var ids = Entities.findEntities(intersection.intersection, 10);
-        for (var i = 0; i < ids.length; i++) {
-            var id = ids[i];
-            if (controlHeld) {
-                Entities.setVoxelSphere(id, intersection.intersection, 1.0, 0);
-            } else if (shiftHeld) {
-                Entities.setAllVoxels(id, 255);
-            } else {
-                Entities.setVoxelSphere(id, intersection.intersection, 1.0, 255);
-            }
+        if (attemptVoxelChange(intersection)) {
+            return;
         }
     }
+
+    // if the PolyVox entity is empty, we can't pick against its voxel.  try picking against its
+    // bounding box, instead.
+    intersection = Entities.findRayIntersection(pickRay, false); // bounding box picking
+    if (intersection.intersects) {
+        attemptVoxelChange(intersection);
+    }
 }
 
 
diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp
index 8562e54ad0..dfae996e49 100644
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@@ -391,6 +391,11 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
         static_cast<NodeList*>(dependency)->deleteLater();
     });
 
+    // setup a timer for domain-server check ins
+    QTimer* domainCheckInTimer = new QTimer(nodeList.data());
+    connect(domainCheckInTimer, &QTimer::timeout, nodeList.data(), &NodeList::sendDomainServerCheckIn);
+    domainCheckInTimer->start(DOMAIN_SERVER_CHECK_IN_MSECS);
+
     // put the NodeList and datagram processing on the node thread
     nodeList->moveToThread(nodeThread);
 
@@ -896,12 +901,6 @@ void Application::paintGL() {
 
     {
         PerformanceTimer perfTimer("renderOverlay");
-        /*
-        gpu::Context context(new gpu::GLBackend());
-        RenderArgs renderArgs(&context, nullptr, getViewFrustum(), lodManager->getOctreeSizeScale(),
-            lodManager->getBoundaryLevelAdjust(), RenderArgs::DEFAULT_RENDER_MODE,
-            RenderArgs::MONO, RenderArgs::RENDER_DEBUG_NONE);
-            */
         _applicationOverlay.renderOverlay(&renderArgs);
     }
 
@@ -977,6 +976,8 @@ void Application::paintGL() {
     } else if (TV3DManager::isConnected()) {
         TV3DManager::display(&renderArgs, _myCamera);
     } else {
+        PROFILE_RANGE(__FUNCTION__ "/mainRender");
+
         DependencyManager::get<GlowEffect>()->prepare(&renderArgs);
 
         // Viewport is assigned to the size of the framebuffer
@@ -1011,6 +1012,7 @@ void Application::paintGL() {
 
 
     if (!OculusManager::isConnected() || OculusManager::allowSwap()) {
+        PROFILE_RANGE(__FUNCTION__ "/bufferSwap");
         _glWidget->swapBuffers();
     }
 
@@ -1060,6 +1062,7 @@ void Application::resetCameras(Camera& camera, const glm::uvec2& size) {
 }
 
 void Application::resizeGL() {
+    PROFILE_RANGE(__FUNCTION__);
     // Set the desired FBO texture size. If it hasn't changed, this does nothing.
     // Otherwise, it must rebuild the FBOs
     QSize renderSize;
@@ -1528,6 +1531,7 @@ void Application::focusOutEvent(QFocusEvent* event) {
 }
 
 void Application::mouseMoveEvent(QMouseEvent* event, unsigned int deviceID) {
+    PROFILE_RANGE(__FUNCTION__);
     // Used by application overlay to determine how to draw cursor(s)
     _lastMouseMoveWasSimulated = deviceID > 0;
     if (!_lastMouseMoveWasSimulated) {
@@ -1794,9 +1798,6 @@ void Application::checkFPS() {
     _frameCount = 0;
     //_datagramProcessor->resetCounters();
     _timerStart.start();
-
-    // ask the node list to check in with the domain server
-    DependencyManager::get<NodeList>()->sendDomainServerCheckIn();
 }
 
 void Application::idle() {
@@ -1842,6 +1843,7 @@ void Application::idle() {
             PerformanceTimer perfTimer("update");
             PerformanceWarning warn(showWarnings, "Application::idle()... update()");
             const float BIGGEST_DELTA_TIME_SECS = 0.25f;
+            PROFILE_RANGE(__FUNCTION__ "/idleUpdate");
             update(glm::clamp((float)timeSinceLastUpdate / 1000.0f, 0.0f, BIGGEST_DELTA_TIME_SECS));
         }
         {
@@ -2943,6 +2945,7 @@ QRect Application::getDesirableApplicationGeometry() {
 //                 or the "myCamera".
 //
 void Application::loadViewFrustum(Camera& camera, ViewFrustum& viewFrustum) {
+    PROFILE_RANGE(__FUNCTION__);
     // We will use these below, from either the camera or head vectors calculated above
     viewFrustum.setProjection(camera.getProjection());
 
@@ -3447,9 +3450,8 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
    // Assuming nothing get's rendered through that
 
     if (!selfAvatarOnly) {
-
-        // render models...
         if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) {
+            // render models...
             PerformanceTimer perfTimer("entities");
             PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
                 "Application::displaySide() ... entities...");
@@ -3457,11 +3459,11 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
             RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE;
 
             if (Menu::getInstance()->isOptionChecked(MenuOption::PhysicsShowHulls)) {
-                renderDebugFlags = (RenderArgs::DebugFlags) (renderDebugFlags | (int) RenderArgs::RENDER_DEBUG_HULLS);
+                renderDebugFlags = (RenderArgs::DebugFlags) (renderDebugFlags | (int)RenderArgs::RENDER_DEBUG_HULLS);
             }
             if (Menu::getInstance()->isOptionChecked(MenuOption::PhysicsShowOwned)) {
                 renderDebugFlags =
-                    (RenderArgs::DebugFlags) (renderDebugFlags | (int) RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP);
+                    (RenderArgs::DebugFlags) (renderDebugFlags | (int)RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP);
             }
             renderArgs->_debugFlags = renderDebugFlags;
             _entities.render(renderArgs);
@@ -4828,7 +4830,7 @@ mat4 Application::getEyeProjection(int eye) const {
     if (isHMDMode()) {
         return OculusManager::getEyeProjection(eye);
     }
-
+    
     return _viewFrustum.getProjection();
 }
 
diff --git a/interface/src/InterfaceActionFactory.cpp b/interface/src/InterfaceActionFactory.cpp
index 363fb66e76..dca1015ecc 100644
--- a/interface/src/InterfaceActionFactory.cpp
+++ b/interface/src/InterfaceActionFactory.cpp
@@ -35,8 +35,7 @@ EntityActionPointer interfaceActionFactory(EntityActionType type, const QUuid& i
 }
 
 
-EntityActionPointer InterfaceActionFactory::factory(EntitySimulation* simulation,
-                                                    EntityActionType type,
+EntityActionPointer InterfaceActionFactory::factory(EntityActionType type,
                                                     const QUuid& id,
                                                     EntityItemPointer ownerEntity,
                                                     QVariantMap arguments) {
@@ -51,9 +50,7 @@ EntityActionPointer InterfaceActionFactory::factory(EntitySimulation* simulation
 }
 
 
-EntityActionPointer InterfaceActionFactory::factoryBA(EntitySimulation* simulation,
-                                                      EntityItemPointer ownerEntity,
-                                                      QByteArray data) {
+EntityActionPointer InterfaceActionFactory::factoryBA(EntityItemPointer ownerEntity, QByteArray data) {
     QDataStream serializedArgumentStream(data);
     EntityActionType type;
     QUuid id;
diff --git a/interface/src/InterfaceActionFactory.h b/interface/src/InterfaceActionFactory.h
index 004c24163f..2031f5c57a 100644
--- a/interface/src/InterfaceActionFactory.h
+++ b/interface/src/InterfaceActionFactory.h
@@ -18,13 +18,11 @@ class InterfaceActionFactory : public EntityActionFactoryInterface {
 public:
     InterfaceActionFactory() : EntityActionFactoryInterface() { }
     virtual ~InterfaceActionFactory() { }
-    virtual EntityActionPointer factory(EntitySimulation* simulation,
-                                        EntityActionType type,
+    virtual EntityActionPointer factory(EntityActionType type,
                                         const QUuid& id,
                                         EntityItemPointer ownerEntity,
                                         QVariantMap arguments);
-    virtual EntityActionPointer factoryBA(EntitySimulation* simulation,
-                                          EntityItemPointer ownerEntity,
+    virtual EntityActionPointer factoryBA(EntityItemPointer ownerEntity,
                                           QByteArray data);
 };
 
diff --git a/interface/src/audio/AudioScope.cpp b/interface/src/audio/AudioScope.cpp
index 8cc27341d6..4b4e86e7f4 100644
--- a/interface/src/audio/AudioScope.cpp
+++ b/interface/src/audio/AudioScope.cpp
@@ -16,6 +16,9 @@
 #include <AudioClient.h>
 #include <AudioConstants.h>
 #include <GeometryCache.h>
+#include <TextureCache.h>
+#include <gpu/Context.h>
+#include <GLMHelpers.h>
 
 #include "AudioScope.h"
 
@@ -104,7 +107,7 @@ void AudioScope::freeScope() {
     }
 }
 
-void AudioScope::render(int width, int height) {
+void AudioScope::render(RenderArgs* renderArgs, int width, int height) {
     
     if (!_isEnabled) {
         return;
@@ -122,24 +125,26 @@ void AudioScope::render(int width, int height) {
     int y = (height - (int)SCOPE_HEIGHT) / 2;
     int w = (int)SCOPE_WIDTH;
     int h = (int)SCOPE_HEIGHT;
-    
-    renderBackground(backgroundColor, x, y, w, h);
-    renderGrid(gridColor, x, y, w, h, gridRows, gridCols);
-    
-    renderLineStrip(_inputID, inputColor, x, y, _samplesPerScope, _scopeInputOffset, _scopeInput);
-    renderLineStrip(_outputLeftID, outputLeftColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputLeft);
-    renderLineStrip(_outputRightD, outputRightColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputRight);
+
+    gpu::Batch batch;
+    auto geometryCache = DependencyManager::get<GeometryCache>();
+    geometryCache->useSimpleDrawPipeline(batch);
+    auto textureCache = DependencyManager::get<TextureCache>();
+    batch.setResourceTexture(0, textureCache->getWhiteTexture());
+    mat4 legacyProjection = glm::ortho<float>(0, width, height, 0, -1000, 1000);
+    batch.setProjectionTransform(legacyProjection);
+    batch.setModelTransform(Transform());
+    batch.setViewTransform(Transform());
+    geometryCache->renderQuad(batch, x, y, w, h, backgroundColor);
+    geometryCache->renderGrid(batch, x, y, w, h, gridRows, gridCols, gridColor, _audioScopeGrid);
+    renderLineStrip(batch, _inputID, inputColor, x, y, _samplesPerScope, _scopeInputOffset, _scopeInput);
+    renderLineStrip(batch, _outputLeftID, outputLeftColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputLeft);
+    renderLineStrip(batch, _outputRightD, outputRightColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputRight);
+    renderArgs->_context->syncCache();
+    renderArgs->_context->render(batch);
 }
 
-void AudioScope::renderBackground(const glm::vec4& color, int x, int y, int width, int height) {
-    DependencyManager::get<GeometryCache>()->renderQuad(x, y, width, height, color);
-}
-
-void AudioScope::renderGrid(const glm::vec4& color, int x, int y, int width, int height, int rows, int cols) {
-    DependencyManager::get<GeometryCache>()->renderGrid(x, y, width, height, rows, cols, color, _audioScopeGrid);
-}
-
-void AudioScope::renderLineStrip(int id, const glm::vec4& color, int x, int y, int n, int offset, const QByteArray* byteArray) {
+void AudioScope::renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& color, int x, int y, int n, int offset, const QByteArray* byteArray) {
 
     int16_t sample;
     int16_t* samples = ((int16_t*) byteArray->data()) + offset;
@@ -194,7 +199,7 @@ void AudioScope::renderLineStrip(int id, const glm::vec4& color, int x, int y, i
     
     
     geometryCache->updateVertices(id, points, color);
-    geometryCache->renderVertices(gpu::LINE_STRIP, id);
+    geometryCache->renderVertices(batch, gpu::LINE_STRIP, id);
 }
 
 int AudioScope::addBufferToScope(QByteArray* byteArray, int frameOffset, const int16_t* source, int sourceSamplesPerChannel,
diff --git a/interface/src/audio/AudioScope.h b/interface/src/audio/AudioScope.h
index cc9367e2d5..4ff4b55c29 100644
--- a/interface/src/audio/AudioScope.h
+++ b/interface/src/audio/AudioScope.h
@@ -14,11 +14,14 @@
 
 #include <glm/glm.hpp>
 
-#include <DependencyManager.h>
-
 #include <QByteArray>
 #include <QObject>
 
+#include <DependencyManager.h>
+#include <gpu/Batch.h>
+#include <RenderArgs.h>
+
+
 class AudioScope : public QObject, public Dependency {
     Q_OBJECT
     SINGLETON_DEPENDENCY
@@ -28,7 +31,7 @@ public:
     void freeScope();
     void reallocateScope(int frames);
     
-    void render(int width, int height);
+    void render(RenderArgs* renderArgs, int width, int height);
     
 public slots:
     void toggle();
@@ -48,9 +51,7 @@ private slots:
     
 private:
     // Audio scope methods for rendering
-    static void renderBackground(const glm::vec4& color, int x, int y, int width, int height);
-    void renderGrid(const glm::vec4& color, int x, int y, int width, int height, int rows, int cols);
-    void renderLineStrip(int id, const glm::vec4& color, int x, int  y, int n, int offset, const QByteArray* byteArray);
+    void renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& color, int x, int  y, int n, int offset, const QByteArray* byteArray);
     
     // Audio scope methods for data acquisition
     int addBufferToScope(QByteArray* byteArray, int frameOffset, const int16_t* source, int sourceSamples,
diff --git a/interface/src/avatar/Avatar.cpp b/interface/src/avatar/Avatar.cpp
index 3d4c158a0b..0dde96c7ce 100644
--- a/interface/src/avatar/Avatar.cpp
+++ b/interface/src/avatar/Avatar.cpp
@@ -644,7 +644,7 @@ void Avatar::renderBillboard(RenderArgs* renderArgs) {
     glm::vec2 texCoordBottomRight(1.0f, 1.0f);
     
     gpu::Batch& batch = *renderArgs->_batch;
-    batch.setUniformTexture(0, _billboardTexture->getGPUTexture());
+    batch.setResourceTexture(0, _billboardTexture->getGPUTexture());
     DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(batch, true);
     DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
                                                         glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
diff --git a/interface/src/avatar/AvatarActionHold.cpp b/interface/src/avatar/AvatarActionHold.cpp
index ca903a9771..0c5145b596 100644
--- a/interface/src/avatar/AvatarActionHold.cpp
+++ b/interface/src/avatar/AvatarActionHold.cpp
@@ -52,39 +52,32 @@ void AvatarActionHold::updateActionWorker(float deltaTimeStep) {
     }
 
     glm::vec3 palmPosition;
+    glm::quat palmRotation;
     if (_hand == "right") {
         palmPosition = myAvatar->getRightPalmPosition();
+        palmRotation = myAvatar->getRightPalmRotation();
     } else {
         palmPosition = myAvatar->getLeftPalmPosition();
+        palmRotation = myAvatar->getLeftPalmRotation();
     }
 
-    auto rotation = myAvatar->getWorldAlignedOrientation();
+    auto rotation = palmRotation * _relativeRotation;
     auto offset = rotation * _relativePosition;
     auto position = palmPosition + offset;
-    rotation *= _relativeRotation;
     unlock();
 
     if (!tryLockForWrite()) {
         return;
     }
 
-    // check for NaNs
-    if (position.x != position.x ||
-        position.y != position.y ||
-        position.z != position.z) {
-        qDebug() << "AvatarActionHold::updateActionWorker -- target position includes NaN";
-        return;
+    if (_positionalTarget != position || _rotationalTarget != rotation) {
+        auto ownerEntity = _ownerEntity.lock();
+        if (ownerEntity) {
+            ownerEntity->setActionDataDirty(true);
+        }
+        _positionalTarget = position;
+        _rotationalTarget = rotation;
     }
-    if (rotation.x != rotation.x ||
-        rotation.y != rotation.y ||
-        rotation.z != rotation.z ||
-        rotation.w != rotation.w) {
-        qDebug() << "AvatarActionHold::updateActionWorker -- target rotation includes NaN";
-        return;
-    }
-
-    _positionalTarget = position;
-    _rotationalTarget = rotation;
     unlock();
 
     ObjectActionSpring::updateActionWorker(deltaTimeStep);
@@ -92,59 +85,51 @@ void AvatarActionHold::updateActionWorker(float deltaTimeStep) {
 
 
 bool AvatarActionHold::updateArguments(QVariantMap arguments) {
-    bool rPOk = true;
+    bool ok = true;
     glm::vec3 relativePosition =
-        EntityActionInterface::extractVec3Argument("hold", arguments, "relativePosition", rPOk, false);
-    bool rROk = true;
+        EntityActionInterface::extractVec3Argument("hold", arguments, "relativePosition", ok, false);
+    if (!ok) {
+        relativePosition = _relativePosition;
+    }
+
+    ok = true;
     glm::quat relativeRotation =
-        EntityActionInterface::extractQuatArgument("hold", arguments, "relativeRotation", rROk, false);
-    bool tSOk = true;
+        EntityActionInterface::extractQuatArgument("hold", arguments, "relativeRotation", ok, false);
+    if (!ok) {
+        relativeRotation = _relativeRotation;
+    }
+    
+    ok = true;
     float timeScale =
-        EntityActionInterface::extractFloatArgument("hold", arguments, "timeScale", tSOk, false);
-    bool hOk = true;
+        EntityActionInterface::extractFloatArgument("hold", arguments, "timeScale", ok, false);
+    if (!ok) {
+        timeScale = _linearTimeScale;
+    }
+
+    ok = true;
     QString hand =
-        EntityActionInterface::extractStringArgument("hold", arguments, "hand", hOk, false);
+        EntityActionInterface::extractStringArgument("hold", arguments, "hand", ok, false);
+    if (!ok || !(hand == "left" || hand == "right")) {
+        hand = _hand;
+    }
 
-    lockForWrite();
-    if (rPOk) {
+    if (relativePosition != _relativePosition
+            || relativeRotation != _relativeRotation
+            || timeScale != _linearTimeScale
+            || hand != _hand) {
+        lockForWrite();
         _relativePosition = relativePosition;
-    } else {
-        _relativePosition = glm::vec3(0.0f, 0.0f, 1.0f);
-    }
-
-    if (rROk) {
         _relativeRotation = relativeRotation;
-    } else {
-        _relativeRotation = glm::quat(0.0f, 0.0f, 0.0f, 1.0f);
-    }
+        const float MIN_TIMESCALE = 0.1f;
+        _linearTimeScale = glm::min(MIN_TIMESCALE, timeScale);
+        _angularTimeScale = _linearTimeScale;
+        _hand = hand;
 
-    if (tSOk) {
-        _linearTimeScale = timeScale;
-        _angularTimeScale = timeScale;
-    } else {
-        _linearTimeScale = 0.2f;
-        _angularTimeScale = 0.2f;
+        _mine = true;
+        _active = true;
+        activateBody();
+        unlock();
     }
-
-    if (hOk) {
-        hand = hand.toLower();
-        if (hand == "left") {
-            _hand = "left";
-        } else if (hand == "right") {
-            _hand = "right";
-        } else {
-            qDebug() << "hold action -- invalid hand argument:" << hand;
-            _hand = "right";
-        }
-    } else {
-        _hand = "right";
-    }
-
-    _mine = true;
-    _positionalTargetSet = true;
-    _rotationalTargetSet = true;
-    _active = true;
-    unlock();
     return true;
 }
 
diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp
index 1384f6e9ca..2dfe4216be 100644
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@@ -371,6 +371,12 @@ glm::vec3 MyAvatar::getLeftPalmPosition() {
     return leftHandPosition;
 }
 
+glm::quat MyAvatar::getLeftPalmRotation() {
+    glm::quat leftRotation;
+    getSkeletonModel().getJointRotationInWorldFrame(getSkeletonModel().getLeftHandJointIndex(), leftRotation);
+    return leftRotation;
+}
+
 glm::vec3 MyAvatar::getRightPalmPosition() {
     glm::vec3 rightHandPosition;
     getSkeletonModel().getRightHandPosition(rightHandPosition);
@@ -380,6 +386,12 @@ glm::vec3 MyAvatar::getRightPalmPosition() {
     return rightHandPosition;
 }
 
+glm::quat MyAvatar::getRightPalmRotation() {
+    glm::quat rightRotation;
+    getSkeletonModel().getJointRotationInWorldFrame(getSkeletonModel().getRightHandJointIndex(), rightRotation);
+    return rightRotation;
+}
+
 void MyAvatar::clearReferential() {
     changeReferential(NULL);
 }
diff --git a/interface/src/avatar/MyAvatar.h b/interface/src/avatar/MyAvatar.h
index 4e76143774..34dfcad2ad 100644
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@@ -195,10 +195,12 @@ public slots:
     void setThrust(glm::vec3 newThrust) { _thrust = newThrust; }
 
     void updateMotionBehavior();
-    
+
     glm::vec3 getLeftPalmPosition();
+    glm::quat getLeftPalmRotation();
     glm::vec3 getRightPalmPosition();
-    
+    glm::quat getRightPalmRotation();
+
     void clearReferential();
     bool setModelReferential(const QUuid& id);
     bool setJointReferential(const QUuid& id, int jointIndex);
diff --git a/interface/src/ui/ApplicationCompositor.cpp b/interface/src/ui/ApplicationCompositor.cpp
index dafa332d53..fb7fffb19c 100644
--- a/interface/src/ui/ApplicationCompositor.cpp
+++ b/interface/src/ui/ApplicationCompositor.cpp
@@ -179,11 +179,12 @@ void ApplicationCompositor::bindCursorTexture(gpu::Batch& batch, uint8_t cursorI
         _cursors[iconId] = DependencyManager::get<TextureCache>()->
             getImageTexture(iconPath);
     }
-    batch.setUniformTexture(0, _cursors[iconId]);
+    batch.setResourceTexture(0, _cursors[iconId]);
 }
 
 // Draws the FBO texture for the screen
 void ApplicationCompositor::displayOverlayTexture(RenderArgs* renderArgs) {
+    PROFILE_RANGE(__FUNCTION__);
     if (_alpha == 0.0f) {
         return;
     }
@@ -252,6 +253,7 @@ vec2 getPolarCoordinates(const PalmData& palm) {
 
 // Draws the FBO texture for Oculus rift.
 void ApplicationCompositor::displayOverlayTextureHmd(RenderArgs* renderArgs, int eye) {
+    PROFILE_RANGE(__FUNCTION__);
     if (_alpha == 0.0f) {
         return;
     }
diff --git a/interface/src/ui/ApplicationOverlay.cpp b/interface/src/ui/ApplicationOverlay.cpp
index e7d220893f..9f742093ee 100644
--- a/interface/src/ui/ApplicationOverlay.cpp
+++ b/interface/src/ui/ApplicationOverlay.cpp
@@ -74,6 +74,7 @@ ApplicationOverlay::~ApplicationOverlay() {
 
 // Renders the overlays either to a texture or to the screen
 void ApplicationOverlay::renderOverlay(RenderArgs* renderArgs) {
+    PROFILE_RANGE(__FUNCTION__);
     CHECK_GL_ERROR();
     PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "ApplicationOverlay::displayOverlay()");
 
@@ -98,6 +99,7 @@ void ApplicationOverlay::renderOverlay(RenderArgs* renderArgs) {
 }
 
 void ApplicationOverlay::renderQmlUi(RenderArgs* renderArgs) {
+    PROFILE_RANGE(__FUNCTION__);
     if (_uiTexture) {
         gpu::Batch batch;
         auto geometryCache = DependencyManager::get<GeometryCache>();
@@ -112,6 +114,7 @@ void ApplicationOverlay::renderQmlUi(RenderArgs* renderArgs) {
 }
 
 void ApplicationOverlay::renderOverlays(RenderArgs* renderArgs) {
+    PROFILE_RANGE(__FUNCTION__);
     glm::vec2 size = qApp->getCanvasSize();
 
     mat4 legacyProjection = glm::ortho<float>(0, size.x, size.y, 0, ORTHO_NEAR_CLIP, ORTHO_FAR_CLIP);
@@ -129,11 +132,12 @@ void ApplicationOverlay::renderOverlays(RenderArgs* renderArgs) {
     emit qApp->renderingOverlay();
     qApp->getOverlays().renderHUD(renderArgs);
 
+    DependencyManager::get<AudioScope>()->render(renderArgs, _overlayFramebuffer->size().width(), _overlayFramebuffer->size().height());
+
     glMatrixMode(GL_PROJECTION);
     glPopMatrix();
     glMatrixMode(GL_MODELVIEW);
 
-    renderArgs->_context->syncCache();
     fboViewport(_overlayFramebuffer);
 }
 
@@ -196,7 +200,7 @@ void ApplicationOverlay::renderDomainConnectionStatusBorder(RenderArgs* renderAr
         geometryCache->useSimpleDrawPipeline(batch);
         batch.setProjectionTransform(mat4());
         batch.setModelTransform(mat4());
-        batch.setUniformTexture(0, DependencyManager::get<TextureCache>()->getWhiteTexture());
+        batch.setResourceTexture(0, DependencyManager::get<TextureCache>()->getWhiteTexture());
         batch._glLineWidth(CONNECTION_STATUS_BORDER_LINE_WIDTH);
 
         // TODO animate the disconnect border for some excitement while not connected?
@@ -219,6 +223,7 @@ GLuint ApplicationOverlay::getOverlayTexture() {
 }
 
 void ApplicationOverlay::buildFramebufferObject() {
+    PROFILE_RANGE(__FUNCTION__);
     QSize fboSize = qApp->getDeviceSize();
     if (_overlayFramebuffer && fboSize == _overlayFramebuffer->size()) {
         // Already built
diff --git a/interface/src/ui/overlays/BillboardOverlay.cpp b/interface/src/ui/overlays/BillboardOverlay.cpp
index 988223765a..1bf4f2a9c7 100644
--- a/interface/src/ui/overlays/BillboardOverlay.cpp
+++ b/interface/src/ui/overlays/BillboardOverlay.cpp
@@ -87,12 +87,12 @@ void BillboardOverlay::render(RenderArgs* args) {
         transform.postScale(glm::vec3(getDimensions(), 1.0f));
         
         batch->setModelTransform(transform);
-        batch->setUniformTexture(0, _texture->getGPUTexture());
+        batch->setResourceTexture(0, _texture->getGPUTexture());
         
         DependencyManager::get<GeometryCache>()->renderQuad(*batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
                                                             glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha));
     
-        batch->setUniformTexture(0, args->_whiteTexture); // restore default white color after me
+        batch->setResourceTexture(0, args->_whiteTexture); // restore default white color after me
     }
 }
 
diff --git a/interface/src/ui/overlays/ImageOverlay.cpp b/interface/src/ui/overlays/ImageOverlay.cpp
index 399e8a459a..7a0c3c00c3 100644
--- a/interface/src/ui/overlays/ImageOverlay.cpp
+++ b/interface/src/ui/overlays/ImageOverlay.cpp
@@ -75,44 +75,44 @@ void ImageOverlay::render(RenderArgs* args) {
     glm::vec2 topLeft(left, top);
     glm::vec2 bottomRight(right, bottom);
 
-    float imageWidth = _texture->getWidth();
-    float imageHeight = _texture->getHeight();
-
     // if for some reason our image is not over 0 width or height, don't attempt to render the image
-    if (_renderImage && imageWidth > 0 && imageHeight > 0) {
+    if (_renderImage) {
+        float imageWidth = _texture->getWidth();
+        float imageHeight = _texture->getHeight();
+        if (imageWidth > 0 && imageHeight > 0) {
+            QRect fromImage;
+            if (_wantClipFromImage) {
+                float scaleX = imageWidth / _texture->getOriginalWidth();
+                float scaleY = imageHeight / _texture->getOriginalHeight();
 
-        QRect fromImage;
-        if (_wantClipFromImage) {
-            float scaleX = imageWidth / _texture->getOriginalWidth();
-            float scaleY = imageHeight / _texture->getOriginalHeight();
+                fromImage.setX(scaleX * _fromImage.x());
+                fromImage.setY(scaleY * _fromImage.y());
+                fromImage.setWidth(scaleX * _fromImage.width());
+                fromImage.setHeight(scaleY * _fromImage.height());
+            }
+            else {
+                fromImage.setX(0);
+                fromImage.setY(0);
+                fromImage.setWidth(imageWidth);
+                fromImage.setHeight(imageHeight);
+            }
 
-            fromImage.setX(scaleX * _fromImage.x());
-            fromImage.setY(scaleY * _fromImage.y());
-            fromImage.setWidth(scaleX * _fromImage.width());
-            fromImage.setHeight(scaleY * _fromImage.height());
+            float x = fromImage.x() / imageWidth;
+            float y = fromImage.y() / imageHeight;
+            float w = fromImage.width() / imageWidth; // ?? is this what we want? not sure
+            float h = fromImage.height() / imageHeight;
+
+            glm::vec2 texCoordTopLeft(x, y);
+            glm::vec2 texCoordBottomRight(x + w, y + h);
+
+            DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, quadColor);
         } else {
-            fromImage.setX(0);
-            fromImage.setY(0);
-            fromImage.setWidth(imageWidth);
-            fromImage.setHeight(imageHeight);
+            DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, quadColor);
         }
-
-        float x = fromImage.x() / imageWidth;
-        float y = fromImage.y() / imageHeight;
-        float w = fromImage.width() / imageWidth; // ?? is this what we want? not sure
-        float h = fromImage.height() / imageHeight;
-
-        glm::vec2 texCoordTopLeft(x, y);
-        glm::vec2 texCoordBottomRight(x + w, y + h);
-
-        DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, quadColor);
+        glDisable(GL_TEXTURE_2D);
     } else {
         DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, quadColor);
     }
-
-    if (_renderImage) {
-        glDisable(GL_TEXTURE_2D);
-    }
 }
 
 void ImageOverlay::setProperties(const QScriptValue& properties) {
diff --git a/interface/src/ui/overlays/Overlays.cpp b/interface/src/ui/overlays/Overlays.cpp
index fb0a095e13..db1bc2185a 100644
--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@@ -96,6 +96,7 @@ void Overlays::cleanupOverlaysToDelete() {
 }
 
 void Overlays::renderHUD(RenderArgs* renderArgs) {
+    PROFILE_RANGE(__FUNCTION__);
     QReadLocker lock(&_lock);
     gpu::Batch batch;
     renderArgs->_batch = &batch;
diff --git a/libraries/animation/src/AnimationLoop.cpp b/libraries/animation/src/AnimationLoop.cpp
index e60df1eaf9..43e049f851 100644
--- a/libraries/animation/src/AnimationLoop.cpp
+++ b/libraries/animation/src/AnimationLoop.cpp
@@ -84,14 +84,14 @@ void AnimationLoop::setStartAutomatically(bool startAutomatically) {
 }
     
 void AnimationLoop::setRunning(bool running) {
-    if (_running == running) {
+    // don't do anything if the new value is the same as the value we already have
+    if (_running != running) {
+        _running = running;
+        
+        // If we just set running to true, then also reset the frame to the first frame
         if (running) {
             // move back to the beginning
             _frameIndex = _firstFrame;
         }
-        return;
-    }
-    if ((_running = running)) {
-        _frameIndex = _firstFrame;
     }
 }
diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.cpp b/libraries/entities-renderer/src/EntityTreeRenderer.cpp
index 03d88200c5..11d24c6d9d 100644
--- a/libraries/entities-renderer/src/EntityTreeRenderer.cpp
+++ b/libraries/entities-renderer/src/EntityTreeRenderer.cpp
@@ -802,6 +802,8 @@ void EntityTreeRenderer::connectSignalsToSlots(EntityScriptingInterface* entityS
     connect(this, &EntityTreeRenderer::enterEntity, entityScriptingInterface, &EntityScriptingInterface::enterEntity);
     connect(this, &EntityTreeRenderer::leaveEntity, entityScriptingInterface, &EntityScriptingInterface::leaveEntity);
     connect(this, &EntityTreeRenderer::collisionWithEntity, entityScriptingInterface, &EntityScriptingInterface::collisionWithEntity);
+
+    connect(&(*DependencyManager::get<SceneScriptingInterface>()), &SceneScriptingInterface::shouldRenderEntitiesChanged, this, &EntityTreeRenderer::updateEntityRenderStatus, Qt::QueuedConnection);
 }
 
 QScriptValueList EntityTreeRenderer::createMouseEventArgs(const EntityItemID& entityID, QMouseEvent* event, unsigned int deviceID) {
@@ -1152,3 +1154,17 @@ void EntityTreeRenderer::entityCollisionWithEntity(const EntityItemID& idA, cons
         entityScriptB.property("collisionWithEntity").call(entityScriptA, args);
     }
 }
+
+void EntityTreeRenderer::updateEntityRenderStatus(bool shouldRenderEntities) {
+    if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderEntities()) {
+        for (auto entityID : _entityIDsLastInScene) {
+            addingEntity(entityID);
+        }
+        _entityIDsLastInScene.clear();
+    } else {
+        _entityIDsLastInScene = _entitiesInScene.keys();
+        for (auto entityID : _entityIDsLastInScene) {
+            deletingEntity(entityID);
+        }
+    }
+}
diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.h b/libraries/entities-renderer/src/EntityTreeRenderer.h
index 54cd5d80e2..84aa3fa8cb 100644
--- a/libraries/entities-renderer/src/EntityTreeRenderer.h
+++ b/libraries/entities-renderer/src/EntityTreeRenderer.h
@@ -90,6 +90,9 @@ public:
     virtual void scriptContentsAvailable(const QUrl& url, const QString& scriptContents);
     virtual void errorInLoadingScript(const QUrl& url);
 
+    // For Scene.shouldRenderEntities
+    QList<EntityItemID>& getEntitiesLastInScene() { return _entityIDsLastInScene; }
+
 signals:
     void mousePressOnEntity(const RayToEntityIntersectionResult& entityItemID, const QMouseEvent* event, unsigned int deviceId);
     void mouseMoveOnEntity(const RayToEntityIntersectionResult& entityItemID, const QMouseEvent* event, unsigned int deviceId);
@@ -112,6 +115,7 @@ public slots:
     void deletingEntity(const EntityItemID& entityID);
     void entitySciptChanging(const EntityItemID& entityID, const bool reload);
     void entityCollisionWithEntity(const EntityItemID& idA, const EntityItemID& idB, const Collision& collision);
+    void updateEntityRenderStatus(bool shouldRenderEntities);
 
     // optional slots that can be wired to menu items
     void setDisplayElementChildProxies(bool value) { _displayElementChildProxies = value; }
@@ -188,6 +192,8 @@ private:
     int _previousStageDay;
     
     QHash<EntityItemID, EntityItemPointer> _entitiesInScene;
+    // For Scene.shouldRenderEntities
+    QList<EntityItemID> _entityIDsLastInScene;
 };
 
 
diff --git a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
index d00728a9eb..2eb95d1bef 100644
--- a/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
+++ b/libraries/entities-renderer/src/RenderableParticleEffectEntityItem.cpp
@@ -50,7 +50,7 @@ void RenderableParticleEffectEntityItem::render(RenderArgs* args) {
     Q_ASSERT(args->_batch);
     gpu::Batch& batch = *args->_batch;
     if (textured) {
-        batch.setUniformTexture(0, _texture->getGPUTexture());
+        batch.setResourceTexture(0, _texture->getGPUTexture());
     }
     batch.setModelTransform(getTransformToCenter());
     DependencyManager::get<DeferredLightingEffect>()->bindSimpleProgram(batch, textured);
diff --git a/libraries/entities/src/EntityActionFactoryInterface.h b/libraries/entities/src/EntityActionFactoryInterface.h
index 9f4056cdff..adff1a53ba 100644
--- a/libraries/entities/src/EntityActionFactoryInterface.h
+++ b/libraries/entities/src/EntityActionFactoryInterface.h
@@ -23,13 +23,11 @@ class EntityActionFactoryInterface : public QObject, public Dependency {
  public:
     EntityActionFactoryInterface() { }
     virtual ~EntityActionFactoryInterface() { }
-    virtual EntityActionPointer factory(EntitySimulation* simulation,
-                                        EntityActionType type,
+    virtual EntityActionPointer factory(EntityActionType type,
                                         const QUuid& id,
                                         EntityItemPointer ownerEntity,
                                         QVariantMap arguments) { assert(false); return nullptr; }
-    virtual EntityActionPointer factoryBA(EntitySimulation* simulation,
-                                          EntityItemPointer ownerEntity,
+    virtual EntityActionPointer factoryBA(EntityItemPointer ownerEntity,
                                           QByteArray data) { assert(false); return nullptr; }
 };
 
diff --git a/libraries/entities/src/EntityActionInterface.cpp b/libraries/entities/src/EntityActionInterface.cpp
index 2b723d4e15..ba7f3afea4 100644
--- a/libraries/entities/src/EntityActionInterface.cpp
+++ b/libraries/entities/src/EntityActionInterface.cpp
@@ -127,21 +127,21 @@ glm::vec3 EntityActionInterface::extractVec3Argument(QString objectName, QVarian
             qDebug() << objectName << "requires argument:" << argumentName;
         }
         ok = false;
-        return glm::vec3();
+        return glm::vec3(0.0f);
     }
 
     QVariant resultV = arguments[argumentName];
     if (resultV.type() != (QVariant::Type) QMetaType::QVariantMap) {
         qDebug() << objectName << "argument" << argumentName << "must be a map";
         ok = false;
-        return glm::vec3();
+        return glm::vec3(0.0f);
     }
 
     QVariantMap resultVM = resultV.toMap();
     if (!resultVM.contains("x") || !resultVM.contains("y") || !resultVM.contains("z")) {
-        qDebug() << objectName << "argument" << argumentName << "must be a map with keys of x, y, z";
+        qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, z";
         ok = false;
-        return glm::vec3();
+        return glm::vec3(0.0f);
     }
 
     QVariant xV = resultVM["x"];
@@ -155,9 +155,15 @@ glm::vec3 EntityActionInterface::extractVec3Argument(QString objectName, QVarian
     float y = yV.toFloat(&yOk);
     float z = zV.toFloat(&zOk);
     if (!xOk || !yOk || !zOk) {
-        qDebug() << objectName << "argument" << argumentName << "must be a map with keys of x, y, z and values of type float.";
+        qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, and z of type float.";
         ok = false;
-        return glm::vec3();
+        return glm::vec3(0.0f);
+    }
+
+    if (x != x || y != y || z != z) {
+        // at least one of the values is NaN
+        ok = false;
+        return glm::vec3(0.0f);
     }
 
     return glm::vec3(x, y, z);
@@ -181,8 +187,8 @@ glm::quat EntityActionInterface::extractQuatArgument(QString objectName, QVarian
     }
 
     QVariantMap resultVM = resultV.toMap();
-    if (!resultVM.contains("x") || !resultVM.contains("y") || !resultVM.contains("z")) {
-        qDebug() << objectName << "argument" << argumentName << "must be a map with keys of x, y, z";
+    if (!resultVM.contains("x") || !resultVM.contains("y") || !resultVM.contains("z") || !resultVM.contains("w")) {
+        qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, z, and w";
         ok = false;
         return glm::quat();
     }
@@ -202,12 +208,18 @@ glm::quat EntityActionInterface::extractQuatArgument(QString objectName, QVarian
     float w = wV.toFloat(&wOk);
     if (!xOk || !yOk || !zOk || !wOk) {
         qDebug() << objectName << "argument" << argumentName
-                 << "must be a map with keys of x, y, z, w and values of type float.";
+                 << "must be a map with keys: x, y, z, and w of type float.";
         ok = false;
         return glm::quat();
     }
 
-    return glm::quat(w, x, y, z);
+    if (x != x || y != y || z != z || w != w) {
+        // at least one of the components is NaN!
+        ok = false;
+        return glm::quat();
+    }
+
+    return glm::normalize(glm::quat(w, x, y, z));
 }
 
 float EntityActionInterface::extractFloatArgument(QString objectName, QVariantMap arguments,
@@ -224,7 +236,7 @@ float EntityActionInterface::extractFloatArgument(QString objectName, QVariantMa
     bool vOk = true;
     float v = vV.toFloat(&vOk);
 
-    if (!vOk) {
+    if (!vOk || v != v) {
         ok = false;
         return 0.0f;
     }
diff --git a/libraries/entities/src/EntityItem.cpp b/libraries/entities/src/EntityItem.cpp
index ebe16aee71..fd8ee502bb 100644
--- a/libraries/entities/src/EntityItem.cpp
+++ b/libraries/entities/src/EntityItem.cpp
@@ -1489,20 +1489,22 @@ void EntityItem::clearSimulationOwnership() {
 
 }
 
+
 bool EntityItem::addAction(EntitySimulation* simulation, EntityActionPointer action) {
+    lockForWrite();
     checkWaitingToRemove(simulation);
-    if (!checkWaitingActionData(simulation)) {
-        return false;
-    }
 
     bool result = addActionInternal(simulation, action);
     if (!result) {
-        removeAction(simulation, action->getID());
+        removeActionInternal(action->getID());
     }
+
+    unlock();
     return result;
 }
 
 bool EntityItem::addActionInternal(EntitySimulation* simulation, EntityActionPointer action) {
+    assertLocked();
     assert(action);
     assert(simulation);
     auto actionOwnerEntity = action->getOwnerEntity().lock();
@@ -1518,41 +1520,44 @@ bool EntityItem::addActionInternal(EntitySimulation* simulation, EntityActionPoi
     QByteArray newDataCache = serializeActions(success);
     if (success) {
         _allActionsDataCache = newDataCache;
+        _dirtyFlags |= EntityItem::DIRTY_PHYSICS_ACTIVATION;
     }
     return success;
 }
 
 bool EntityItem::updateAction(EntitySimulation* simulation, const QUuid& actionID, const QVariantMap& arguments) {
+    lockForWrite();
     checkWaitingToRemove(simulation);
-    if (!checkWaitingActionData(simulation)) {
-        return false;
-    }
 
     if (!_objectActions.contains(actionID)) {
+        unlock();
         return false;
     }
     EntityActionPointer action = _objectActions[actionID];
-    bool success = action->updateArguments(arguments);
 
+    bool success = action->updateArguments(arguments);
     if (success) {
         _allActionsDataCache = serializeActions(success);
+        _dirtyFlags |= EntityItem::DIRTY_PHYSICS_ACTIVATION;
     } else {
         qDebug() << "EntityItem::updateAction failed";
     }
 
+    unlock();
     return success;
 }
 
 bool EntityItem::removeAction(EntitySimulation* simulation, const QUuid& actionID) {
+    lockForWrite();
     checkWaitingToRemove(simulation);
-    if (!checkWaitingActionData(simulation)) {
-        return false;;
-    }
 
-    return removeActionInternal(actionID);
+    bool success = removeActionInternal(actionID);
+    unlock();
+    return success;
 }
 
 bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulation* simulation) {
+    assertWriteLocked();
     if (_objectActions.contains(actionID)) {
         if (!simulation) {
             EntityTree* entityTree = _element ? _element->getTree() : nullptr;
@@ -1569,13 +1574,14 @@ bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulation* s
 
         bool success = true;
         _allActionsDataCache = serializeActions(success);
+        _dirtyFlags |= EntityItem::DIRTY_PHYSICS_ACTIVATION;
         return success;
     }
     return false;
 }
 
 bool EntityItem::clearActions(EntitySimulation* simulation) {
-    _waitingActionData.clear();
+    lockForWrite();
     QHash<QUuid, EntityActionPointer>::iterator i = _objectActions.begin();
     while (i != _objectActions.end()) {
         const QUuid id = i.key();
@@ -1584,85 +1590,85 @@ bool EntityItem::clearActions(EntitySimulation* simulation) {
         action->setOwnerEntity(nullptr);
         action->removeFromSimulation(simulation);
     }
+    // empty _serializedActions means no actions for the EntityItem
     _actionsToRemove.clear();
     _allActionsDataCache.clear();
+    _dirtyFlags |= EntityItem::DIRTY_PHYSICS_ACTIVATION;
+    unlock();
     return true;
 }
 
-bool EntityItem::deserializeActions(QByteArray allActionsData, EntitySimulation* simulation) const {
-    bool success = true;
-    QVector<QByteArray> serializedActions;
-    if (allActionsData.size() > 0) {
-        QDataStream serializedActionsStream(allActionsData);
-        serializedActionsStream >> serializedActions;
+
+void EntityItem::deserializeActions() {
+    assertUnlocked();
+    lockForWrite();
+    deserializeActionsInternal();
+    unlock();
+}
+
+
+void EntityItem::deserializeActionsInternal() {
+    assertWriteLocked();
+
+    if (!_element) {
+        return;
     }
 
     // Keep track of which actions got added or updated by the new actionData
-    QSet<QUuid> updated;
 
     EntityTree* entityTree = _element ? _element->getTree() : nullptr;
-    if (!simulation) {
-        simulation = entityTree ? entityTree->getSimulation() : nullptr;
+    assert(entityTree);
+    EntitySimulation* simulation = entityTree ? entityTree->getSimulation() : nullptr;
+    assert(simulation);
+
+    QVector<QByteArray> serializedActions;
+    if (_allActionsDataCache.size() > 0) {
+        QDataStream serializedActionsStream(_allActionsDataCache);
+        serializedActionsStream >> serializedActions;
     }
 
-    if (simulation && entityTree) {
-        foreach(QByteArray serializedAction, serializedActions) {
-            QDataStream serializedActionStream(serializedAction);
-            EntityActionType actionType;
-            QUuid actionID;
-            serializedActionStream >> actionType;
-            serializedActionStream >> actionID;
-            updated << actionID;
+    QSet<QUuid> updated;
 
-            if (_objectActions.contains(actionID)) {
-                EntityActionPointer action = _objectActions[actionID];
-                // TODO: make sure types match?  there isn't currently a way to
-                // change the type of an existing action.
-                action->deserialize(serializedAction);
-            } else {
-                auto actionFactory = DependencyManager::get<EntityActionFactoryInterface>();
-                if (simulation) {
-                    EntityItemPointer entity = entityTree->findEntityByEntityItemID(_id);
-                    EntityActionPointer action = actionFactory->factoryBA(simulation, entity, serializedAction);
-                    if (action) {
-                        entity->addActionInternal(simulation, action);
-                    }
-                } else {
-                    // we can't yet add the action.  This method will be called later.
-                    success = false;
-                }
+    foreach(QByteArray serializedAction, serializedActions) {
+        QDataStream serializedActionStream(serializedAction);
+        EntityActionType actionType;
+        QUuid actionID;
+        serializedActionStream >> actionType;
+        serializedActionStream >> actionID;
+        updated << actionID;
+
+        if (_objectActions.contains(actionID)) {
+            EntityActionPointer action = _objectActions[actionID];
+            // TODO: make sure types match?  there isn't currently a way to
+            // change the type of an existing action.
+            action->deserialize(serializedAction);
+        } else {
+            auto actionFactory = DependencyManager::get<EntityActionFactoryInterface>();
+
+            // EntityItemPointer entity = entityTree->findEntityByEntityItemID(_id, false);
+            EntityItemPointer entity = shared_from_this();
+            EntityActionPointer action = actionFactory->factoryBA(entity, serializedAction);
+            if (action) {
+                entity->addActionInternal(simulation, action);
             }
         }
+    }
 
-        // remove any actions that weren't included in the new data.
-        QHash<QUuid, EntityActionPointer>::const_iterator i = _objectActions.begin();
-        while (i != _objectActions.end()) {
-            const QUuid id = i.key();
-            if (!updated.contains(id)) {
-                _actionsToRemove << id;
-            }
-            i++;
+    // remove any actions that weren't included in the new data.
+    QHash<QUuid, EntityActionPointer>::const_iterator i = _objectActions.begin();
+    while (i != _objectActions.end()) {
+        QUuid id = i.key();
+        if (!updated.contains(id)) {
+            _actionsToRemove << id;
         }
-    } else {
-        // no simulation
-        success = false;
+        i++;
     }
 
-    return success;
-}
-
-bool EntityItem::checkWaitingActionData(EntitySimulation* simulation) const {
-    if (_waitingActionData.size() == 0) {
-        return true;
-    }
-    bool success = deserializeActions(_waitingActionData, simulation);
-    if (success) {
-        _waitingActionData.clear();
-    }
-    return success;
+    return;
 }
 
 void EntityItem::checkWaitingToRemove(EntitySimulation* simulation) {
+    assertLocked();
     foreach(QUuid actionID, _actionsToRemove) {
         removeActionInternal(actionID, simulation);
     }
@@ -1670,21 +1676,22 @@ void EntityItem::checkWaitingToRemove(EntitySimulation* simulation) {
 }
 
 void EntityItem::setActionData(QByteArray actionData) {
+    assertUnlocked();
+    lockForWrite();
+    setActionDataInternal(actionData);
+    unlock();
+}
+
+void EntityItem::setActionDataInternal(QByteArray actionData) {
+    assertWriteLocked();
     checkWaitingToRemove();
-    bool success = deserializeActions(actionData);
     _allActionsDataCache = actionData;
-    if (success) {
-        _waitingActionData.clear();
-    } else {
-        _waitingActionData = actionData;
-    }
+    deserializeActionsInternal();
 }
 
 QByteArray EntityItem::serializeActions(bool& success) const {
+    assertLocked();
     QByteArray result;
-    if (!checkWaitingActionData()) {
-        return _waitingActionData;
-    }
 
     if (_objectActions.size() == 0) {
         success = true;
@@ -1713,21 +1720,132 @@ QByteArray EntityItem::serializeActions(bool& success) const {
     return result;
 }
 
-const QByteArray EntityItem::getActionData() const {
+const QByteArray EntityItem::getActionDataInternal() const {
+    if (_actionDataDirty) {
+        bool success;
+        QByteArray newDataCache = serializeActions(success);
+        if (success) {
+            _allActionsDataCache = newDataCache;
+        }
+        _actionDataDirty = false;
+    }
     return _allActionsDataCache;
 }
 
+const QByteArray EntityItem::getActionData() const {
+    assertUnlocked();
+    lockForRead();
+    auto result = getActionDataInternal();
+    unlock();
+    return result;
+}
+
 QVariantMap EntityItem::getActionArguments(const QUuid& actionID) const {
     QVariantMap result;
-
-    if (!checkWaitingActionData()) {
-        return result;
-    }
+    lockForRead();
 
     if (_objectActions.contains(actionID)) {
         EntityActionPointer action = _objectActions[actionID];
         result = action->getArguments();
         result["type"] = EntityActionInterface::actionTypeToString(action->getType());
     }
+    unlock();
     return result;
 }
+
+
+
+#define ENABLE_LOCKING 1
+
+#ifdef ENABLE_LOCKING
+void EntityItem::lockForRead() const {
+    _lock.lockForRead();
+}
+
+bool EntityItem::tryLockForRead() const {
+    return _lock.tryLockForRead();
+}
+
+void EntityItem::lockForWrite() const {
+    _lock.lockForWrite();
+}
+
+bool EntityItem::tryLockForWrite() const {
+    return _lock.tryLockForWrite();
+}
+
+void EntityItem::unlock() const {
+    _lock.unlock();
+}
+
+bool EntityItem::isLocked() const {
+    bool readSuccess = tryLockForRead();
+    if (readSuccess) {
+        unlock();
+    }
+    bool writeSuccess = tryLockForWrite();
+    if (writeSuccess) {
+        unlock();
+    }
+    if (readSuccess && writeSuccess) {
+        return false;  // if we can take both kinds of lock, there was no previous lock
+    }
+    return true; // either read or write failed, so there is some lock in place.
+}
+
+
+bool EntityItem::isWriteLocked() const {
+    bool readSuccess = tryLockForRead();
+    if (readSuccess) {
+        unlock();
+        return false;
+    }
+    bool writeSuccess = tryLockForWrite();
+    if (writeSuccess) {
+        unlock();
+        return false;
+    }
+    return true; // either read or write failed, so there is some lock in place.
+}
+
+
+bool EntityItem::isUnlocked() const {
+    // this can't be sure -- this may get unlucky and hit locks from other threads.  what we're actually trying
+    // to discover is if *this* thread hasn't locked the EntityItem.  Try repeatedly to take both kinds of lock.
+    bool readSuccess = false;
+    for (int i=0; i<80; i++) {
+        readSuccess = tryLockForRead();
+        if (readSuccess) {
+            unlock();
+            break;
+        }
+        QThread::usleep(200);
+    }
+
+    bool writeSuccess = false;
+    if (readSuccess) {
+        for (int i=0; i<80; i++) {
+            writeSuccess = tryLockForWrite();
+            if (writeSuccess) {
+                unlock();
+                break;
+            }
+            QThread::usleep(300);
+        }
+    }
+
+    if (readSuccess && writeSuccess) {
+        return true;  // if we can take both kinds of lock, there was no previous lock
+    }
+    return false;
+}
+#else
+void EntityItem::lockForRead() const { }
+bool EntityItem::tryLockForRead() const { return true; }
+void EntityItem::lockForWrite() const { }
+bool EntityItem::tryLockForWrite() const { return true; }
+void EntityItem::unlock() const { }
+bool EntityItem::isLocked() const { return true; }
+bool EntityItem::isWriteLocked() const { return true; }
+bool EntityItem::isUnlocked() const { return true; }
+#endif
diff --git a/libraries/entities/src/EntityItem.h b/libraries/entities/src/EntityItem.h
index 7efe1569d2..f95ddad89d 100644
--- a/libraries/entities/src/EntityItem.h
+++ b/libraries/entities/src/EntityItem.h
@@ -68,10 +68,28 @@ const float ACTIVATION_ANGULAR_VELOCITY_DELTA = 0.03f;
 #define debugTimeOnly(T) qPrintable(QString("%1").arg(T, 16, 10))
 #define debugTreeVector(V) V << "[" << V << " in meters ]"
 
+#if DEBUG
+  #define assertLocked() assert(isLocked())
+#else
+  #define assertLocked()
+#endif
+
+#if DEBUG
+  #define assertWriteLocked() assert(isWriteLocked())
+#else
+  #define assertWriteLocked()
+#endif
+
+#if DEBUG
+  #define assertUnlocked() assert(isUnlocked())
+#else
+  #define assertUnlocked()
+#endif
+
 /// EntityItem class this is the base class for all entity types. It handles the basic properties and functionality available
 /// to all other entity types. In particular: postion, size, rotation, age, lifetime, velocity, gravity. You can not instantiate
 /// one directly, instead you must only construct one of it's derived classes with additional features.
-class EntityItem {
+class EntityItem : public std::enable_shared_from_this<EntityItem> {
     // These two classes manage lists of EntityItem pointers and must be able to cleanup pointers when an EntityItem is deleted.
     // To make the cleanup robust each EntityItem has backpointers to its manager classes (which are only ever set/cleared by
     // the managers themselves, hence they are fiends) whose NULL status can be used to determine which managers still need to
@@ -395,9 +413,14 @@ public:
     bool hasActions() { return !_objectActions.empty(); }
     QList<QUuid> getActionIDs() { return _objectActions.keys(); }
     QVariantMap getActionArguments(const QUuid& actionID) const;
+    void deserializeActions();
+    void setActionDataDirty(bool value) const { _actionDataDirty = value; }
 
 protected:
 
+    const QByteArray getActionDataInternal() const;
+    void setActionDataInternal(QByteArray actionData);
+
     static bool _sendPhysicsUpdates;
     EntityTypes::EntityType _type;
     QUuid _id;
@@ -470,18 +493,28 @@ protected:
 
     bool addActionInternal(EntitySimulation* simulation, EntityActionPointer action);
     bool removeActionInternal(const QUuid& actionID, EntitySimulation* simulation = nullptr);
-    bool deserializeActions(QByteArray allActionsData, EntitySimulation* simulation = nullptr) const;
+    void deserializeActionsInternal();
     QByteArray serializeActions(bool& success) const;
     QHash<QUuid, EntityActionPointer> _objectActions;
+
     static int _maxActionsDataSize;
     mutable QByteArray _allActionsDataCache;
     // when an entity-server starts up, EntityItem::setActionData is called before the entity-tree is
     // ready.  This means we can't find our EntityItemPointer or add the action to the simulation.  These
     // are used to keep track of and work around this situation.
-    bool checkWaitingActionData(EntitySimulation* simulation = nullptr) const;
     void checkWaitingToRemove(EntitySimulation* simulation = nullptr);
-    mutable QByteArray _waitingActionData;
     mutable QSet<QUuid> _actionsToRemove;
+    mutable bool _actionDataDirty = false;
+
+    mutable QReadWriteLock _lock;
+    void lockForRead() const;
+    bool tryLockForRead() const;
+    void lockForWrite() const;
+    bool tryLockForWrite() const;
+    void unlock() const;
+    bool isLocked() const;
+    bool isWriteLocked() const;
+    bool isUnlocked() const;
 };
 
 #endif // hifi_EntityItem_h
diff --git a/libraries/entities/src/EntityItemProperties.cpp b/libraries/entities/src/EntityItemProperties.cpp
index 91f3e9402c..8d96e0a60a 100644
--- a/libraries/entities/src/EntityItemProperties.cpp
+++ b/libraries/entities/src/EntityItemProperties.cpp
@@ -128,6 +128,10 @@ void EntityItemProperties::setSittingPoints(const QVector<SittingPoint>& sitting
     }
 }
 
+bool EntityItemProperties::animationSettingsChanged() const { 
+    return _animationSettingsChanged; 
+}
+
 void EntityItemProperties::setAnimationSettings(const QString& value) {
     // the animations setting is a JSON string that may contain various animation settings.
     // if it includes fps, frameIndex, or running, those values will be parsed out and
diff --git a/libraries/entities/src/EntityScriptingInterface.cpp b/libraries/entities/src/EntityScriptingInterface.cpp
index 02e129c251..b81717c0c9 100644
--- a/libraries/entities/src/EntityScriptingInterface.cpp
+++ b/libraries/entities/src/EntityScriptingInterface.cpp
@@ -543,6 +543,9 @@ bool EntityScriptingInterface::actionWorker(const QUuid& entityID,
     }
 
     bool success = actor(simulation, entity);
+    if (success) {
+        _entityTree->entityChanged(entity);
+    }
     _entityTree->unlock();
 
     // transmit the change
@@ -574,7 +577,7 @@ QUuid EntityScriptingInterface::addAction(const QString& actionTypeString,
             if (actionType == ACTION_TYPE_NONE) {
                 return false;
             }
-            EntityActionPointer action = actionFactory->factory(simulation, actionType, actionID, entity, arguments);
+            EntityActionPointer action = actionFactory->factory(actionType, actionID, entity, arguments);
             if (action) {
                 entity->addAction(simulation, action);
                 auto nodeList = DependencyManager::get<NodeList>();
diff --git a/libraries/entities/src/EntitySimulation.cpp b/libraries/entities/src/EntitySimulation.cpp
index a2d20fe5d5..f2bd1e873e 100644
--- a/libraries/entities/src/EntitySimulation.cpp
+++ b/libraries/entities/src/EntitySimulation.cpp
@@ -146,6 +146,7 @@ void EntitySimulation::sortEntitiesThatMoved() {
 
 void EntitySimulation::addEntity(EntityItemPointer entity) {
     assert(entity);
+    entity->deserializeActions();
     if (entity->isMortal()) {
         _mortalEntities.insert(entity);
         quint64 expiry = entity->getExpiry();
diff --git a/libraries/gpu/src/gpu/Batch.cpp b/libraries/gpu/src/gpu/Batch.cpp
index 98d7b70db8..5fbac3bc6c 100644
--- a/libraries/gpu/src/gpu/Batch.cpp
+++ b/libraries/gpu/src/gpu/Batch.cpp
@@ -114,6 +114,23 @@ void Batch::clearFramebuffer(Framebuffer::Masks targets, const Vec4& color, floa
     _params.push_back(targets);
 }
 
+void Batch::clearColorFramebuffer(Framebuffer::Masks targets, const Vec4& color) {
+    clearFramebuffer(targets & Framebuffer::BUFFER_COLORS, color, 1.0f, 0);
+}
+
+void Batch::clearDepthFramebuffer(float depth) {
+    clearFramebuffer(Framebuffer::BUFFER_DEPTH, Vec4(0.0f), depth, 0);
+}
+
+void Batch::clearStencilFramebuffer(int stencil) {
+    clearFramebuffer(Framebuffer::BUFFER_STENCIL, Vec4(0.0f), 1.0f, stencil);
+}
+
+void Batch::clearDepthStencilFramebuffer(float depth, int stencil) {
+    clearFramebuffer(Framebuffer::BUFFER_DEPTHSTENCIL, Vec4(0.0f), depth, stencil);
+}
+
+
 void Batch::setInputFormat(const Stream::FormatPointer& format) {
     ADD_COMMAND(setInputFormat);
 
@@ -152,6 +169,10 @@ void Batch::setIndexBuffer(Type type, const BufferPointer& buffer, Offset offset
     _params.push_back(type);
 }
 
+void Batch::setIndexBuffer(const BufferView& buffer) {
+    setIndexBuffer(buffer._element.getType(), buffer._buffer, buffer._offset);
+}
+
 void Batch::setModelTransform(const Transform& model) {
     ADD_COMMAND(setModelTransform);
 
@@ -170,10 +191,10 @@ void Batch::setProjectionTransform(const Mat4& proj) {
     _params.push_back(cacheData(sizeof(Mat4), &proj));
 }
 
-void Batch::setViewportTransform(const Vec4i& viewport) {
-    ADD_COMMAND(setViewportTransform);
-
-    _params.push_back(cacheData(sizeof(Vec4i), &viewport));
+void Batch::setViewportTransform(const Vec4i& viewport) {
+    ADD_COMMAND(setViewportTransform);
+
+    _params.push_back(cacheData(sizeof(Vec4i), &viewport));
 }
 
 void Batch::setPipeline(const PipelinePointer& pipeline) {
@@ -206,21 +227,38 @@ void Batch::setUniformBuffer(uint32 slot, const BufferView& view) {
 }
 
 
-void Batch::setUniformTexture(uint32 slot, const TexturePointer& texture) {
-    ADD_COMMAND(setUniformTexture);
+void Batch::setResourceTexture(uint32 slot, const TexturePointer& texture) {
+    ADD_COMMAND(setResourceTexture);
 
     _params.push_back(_textures.cache(texture));
     _params.push_back(slot);
 }
 
-void Batch::setUniformTexture(uint32 slot, const TextureView& view) {
-    setUniformTexture(slot, view._texture);
+void Batch::setResourceTexture(uint32 slot, const TextureView& view) {
+    setResourceTexture(slot, view._texture);
 }
 
 void Batch::setFramebuffer(const FramebufferPointer& framebuffer) {
-    ADD_COMMAND(setUniformTexture);
+    ADD_COMMAND(setFramebuffer);
 
     _params.push_back(_framebuffers.cache(framebuffer));
 
 }
 
+void Batch::beginQuery(const QueryPointer& query) {
+    ADD_COMMAND(beginQuery);
+
+    _params.push_back(_queries.cache(query));
+}
+
+void Batch::endQuery(const QueryPointer& query) {
+    ADD_COMMAND(endQuery);
+
+    _params.push_back(_queries.cache(query));
+}
+
+void Batch::getQuery(const QueryPointer& query) {
+    ADD_COMMAND(getQuery);
+
+    _params.push_back(_queries.cache(query));
+}
diff --git a/libraries/gpu/src/gpu/Batch.h b/libraries/gpu/src/gpu/Batch.h
index 5583294aba..abd9982cd0 100644
--- a/libraries/gpu/src/gpu/Batch.h
+++ b/libraries/gpu/src/gpu/Batch.h
@@ -18,6 +18,7 @@
 
 #include <vector>
 
+#include "Query.h"
 #include "Stream.h"
 #include "Texture.h"
 
@@ -38,19 +39,6 @@
 
 namespace gpu {
 
-enum Primitive {
-    POINTS = 0,
-    LINES,
-    LINE_STRIP,
-    TRIANGLES,
-    TRIANGLE_STRIP,
-    TRIANGLE_FAN,
-    QUADS,
-    QUAD_STRIP,
-
-    NUM_PRIMITIVES,
-};
-
 enum ReservedSlot {
 /*    TRANSFORM_OBJECT_SLOT = 6,
     TRANSFORM_CAMERA_SLOT = 7,
@@ -76,7 +64,12 @@ public:
     void drawIndexedInstanced(uint32 nbInstances, Primitive primitiveType, uint32 nbIndices, uint32 startIndex = 0, uint32 startInstance = 0);
 
     // Clear framebuffer layers
+    // Targets can be any of the render buffers contained in the Framebuffer
     void clearFramebuffer(Framebuffer::Masks targets, const Vec4& color, float depth, int stencil);
+    void clearColorFramebuffer(Framebuffer::Masks targets, const Vec4& color); // not a command, just a shortcut for clearFramebuffer, mask out targets to make sure it touches only color targets
+    void clearDepthFramebuffer(float depth); // not a command, just a shortcut for clearFramebuffer, it touches only depth target
+    void clearStencilFramebuffer(int stencil); // not a command, just a shortcut for clearFramebuffer, it touches only stencil target
+    void clearDepthStencilFramebuffer(float depth, int stencil); // not a command, just a shortcut for clearFramebuffer, it touches depth and stencil target
     
     // Input Stage
     // InputFormat
@@ -89,6 +82,7 @@ public:
     void setInputStream(Slot startChannel, const BufferStream& stream); // not a command, just unroll into a loop of setInputBuffer
 
     void setIndexBuffer(Type type, const BufferPointer& buffer, Offset offset);
+    void setIndexBuffer(const BufferView& buffer); // not a command, just a shortcut from a BufferView
 
     // Transform Stage
     // Vertex position is transformed by ModelTransform from object space to world space
@@ -109,12 +103,17 @@ public:
     void setUniformBuffer(uint32 slot, const BufferPointer& buffer, Offset offset, Offset size);
     void setUniformBuffer(uint32 slot, const BufferView& view); // not a command, just a shortcut from a BufferView
 
-    void setUniformTexture(uint32 slot, const TexturePointer& view);
-    void setUniformTexture(uint32 slot, const TextureView& view); // not a command, just a shortcut from a TextureView
+    void setResourceTexture(uint32 slot, const TexturePointer& view);
+    void setResourceTexture(uint32 slot, const TextureView& view); // not a command, just a shortcut from a TextureView
 
     // Framebuffer Stage
     void setFramebuffer(const FramebufferPointer& framebuffer);
 
+    // Query Section
+    void beginQuery(const QueryPointer& query);
+    void endQuery(const QueryPointer& query);
+    void getQuery(const QueryPointer& query);
+
     // 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
@@ -179,10 +178,14 @@ public:
         COMMAND_setStateBlendFactor,
 
         COMMAND_setUniformBuffer,
-        COMMAND_setUniformTexture,
+        COMMAND_setResourceTexture,
 
         COMMAND_setFramebuffer,
 
+        COMMAND_beginQuery,
+        COMMAND_endQuery,
+        COMMAND_getQuery,
+
         // 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
@@ -286,6 +289,7 @@ public:
     typedef Cache<Transform>::Vector TransformCaches;
     typedef Cache<PipelinePointer>::Vector PipelineCaches;
     typedef Cache<FramebufferPointer>::Vector FramebufferCaches;
+    typedef Cache<QueryPointer>::Vector QueryCaches;
 
     // Cache Data in a byte array if too big to fit in Param
     // FOr example Mat4s are going there
@@ -310,6 +314,7 @@ public:
     TransformCaches _transforms;
     PipelineCaches _pipelines;
     FramebufferCaches _framebuffers;
+    QueryCaches _queries;
 
 protected:
 };
diff --git a/libraries/gpu/src/gpu/Context.h b/libraries/gpu/src/gpu/Context.h
index 98ddc7fb64..4eb0976e3c 100644
--- a/libraries/gpu/src/gpu/Context.h
+++ b/libraries/gpu/src/gpu/Context.h
@@ -42,7 +42,7 @@ public:
         Mat4 _projectionViewUntranslated;
         Mat4 _projection;
         Mat4 _projectionInverse;
-        Vec4 _viewport;
+        Vec4 _viewport; // Public value is int but float in the shader to stay in floats for all the transform computations.
     };
 
     template< typename T >
@@ -99,6 +99,15 @@ public:
         return reinterpret_cast<T*>(framebuffer.getGPUObject());
     }
 
+    template< typename T >
+    static void setGPUObject(const Query& query, T* object) {
+        query.setGPUObject(object);
+    }
+    template< typename T >
+    static T* getGPUObject(const Query& query) {
+        return reinterpret_cast<T*>(query.getGPUObject());
+    }
+
 protected:
 
 };
diff --git a/libraries/gpu/src/gpu/DrawTexture.slf b/libraries/gpu/src/gpu/DrawTexture.slf
new file mode 100755
index 0000000000..e456c49649
--- /dev/null
+++ b/libraries/gpu/src/gpu/DrawTexture.slf
@@ -0,0 +1,21 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  Draw texture 0 fetched at texcoord.xy
+//
+//  Created by Sam Gateau on 6/22/2015
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+
+uniform sampler2D colorMap;
+
+varying vec2 varTexcoord;
+
+void main(void) {
+    gl_FragColor = texture2D(colorMap, varTexcoord);
+}
diff --git a/libraries/gpu/src/gpu/DrawTransformUnitQuad.slv b/libraries/gpu/src/gpu/DrawTransformUnitQuad.slv
new file mode 100755
index 0000000000..2d1e4584a7
--- /dev/null
+++ b/libraries/gpu/src/gpu/DrawTransformUnitQuad.slv
@@ -0,0 +1,36 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  Draw and transform the unit quad [-1,-1 -> 1,1]
+//  Simply draw a Triangle_strip of 2 triangles, no input buffers or index buffer needed
+//
+//  Created by Sam Gateau on 6/22/2015
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Transform.slh@>
+
+<$declareStandardTransform()$>
+
+varying vec2 varTexcoord;
+
+void main(void) {
+    const vec4 UNIT_QUAD[4] = vec4[4](
+        vec4(-1.0, -1.0, 0.0, 1.0),
+        vec4(1.0, -1.0, 0.0, 1.0),
+        vec4(-1.0, 1.0, 0.0, 1.0),
+        vec4(1.0, 1.0, 0.0, 1.0)
+    );
+    vec4 pos = UNIT_QUAD[gl_VertexID];
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToClipPos(cam, obj, pos, gl_Position)$>
+
+    varTexcoord = (pos.xy + 1) * 0.5;
+}
diff --git a/libraries/gpu/src/gpu/DrawViewportQuadTransformTexcoord.slv b/libraries/gpu/src/gpu/DrawViewportQuadTransformTexcoord.slv
new file mode 100755
index 0000000000..e91b8a7644
--- /dev/null
+++ b/libraries/gpu/src/gpu/DrawViewportQuadTransformTexcoord.slv
@@ -0,0 +1,38 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  Draw the unit quad [-1,-1 -> 1,1] filling in 
+//  Simply draw a Triangle_strip of 2 triangles, no input buffers or index buffer needed
+//
+//  Created by Sam Gateau on 6/22/2015
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Transform.slh@>
+
+<$declareStandardTransform()$>
+
+varying vec2 varTexcoord;
+
+void main(void) {
+    const vec4 UNIT_QUAD[4] = vec4[4](
+        vec4(-1.0, -1.0, 0.0, 1.0),
+        vec4(1.0, -1.0, 0.0, 1.0),
+        vec4(-1.0, 1.0, 0.0, 1.0),
+        vec4(1.0, 1.0, 0.0, 1.0)
+    );
+    vec4 pos = UNIT_QUAD[gl_VertexID];
+
+    // standard transform but applied to the Texcoord
+    vec4 tc = vec4((pos.xy + 1) * 0.5, pos.zw);
+
+    TransformObject obj = getTransformObject();
+    <$transformModelToWorldPos(obj, tc, tc)$>
+
+    gl_Position = pos;
+    varTexcoord = tc.xy;
+}
diff --git a/libraries/gpu/src/gpu/Format.h b/libraries/gpu/src/gpu/Format.h
index ac71cc7940..981a560965 100644
--- a/libraries/gpu/src/gpu/Format.h
+++ b/libraries/gpu/src/gpu/Format.h
@@ -182,6 +182,9 @@ public:
     }
 
     static const Element COLOR_RGBA_32;
+    static const Element VEC3F_XYZ;
+    static const Element INDEX_UINT16;
+    static const Element PART_DRAWCALL;
 
  protected:
     uint8 _semantic;
@@ -203,6 +206,19 @@ enum ComparisonFunction {
     NUM_COMPARISON_FUNCS,
 };
 
+enum Primitive {
+    POINTS = 0,
+    LINES,
+    LINE_STRIP,
+    TRIANGLES,
+    TRIANGLE_STRIP,
+    TRIANGLE_FAN,
+    QUADS,
+    QUAD_STRIP,
+
+    NUM_PRIMITIVES,
+};
+
 };
 
 
diff --git a/libraries/gpu/src/gpu/GLBackend.cpp b/libraries/gpu/src/gpu/GLBackend.cpp
index 302dc0e8be..1168b119a3 100644
--- a/libraries/gpu/src/gpu/GLBackend.cpp
+++ b/libraries/gpu/src/gpu/GLBackend.cpp
@@ -35,10 +35,13 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
     (&::gpu::GLBackend::do_setStateBlendFactor),
 
     (&::gpu::GLBackend::do_setUniformBuffer),
-    (&::gpu::GLBackend::do_setUniformTexture),
+    (&::gpu::GLBackend::do_setResourceTexture),
 
     (&::gpu::GLBackend::do_setFramebuffer),
 
+    (&::gpu::GLBackend::do_beginQuery),
+    (&::gpu::GLBackend::do_endQuery),
+    (&::gpu::GLBackend::do_getQuery),
 
     (&::gpu::GLBackend::do_glEnable),
     (&::gpu::GLBackend::do_glDisable),
@@ -233,17 +236,34 @@ void GLBackend::do_clearFramebuffer(Batch& batch, uint32 paramOffset) {
         glmask |= GL_DEPTH_BUFFER_BIT;
     } 
 
+    std::vector<GLenum> drawBuffers;
     if (masks & Framebuffer::BUFFER_COLORS) {
-        glClearColor(color.x, color.y, color.z, color.w);
-        glmask |= GL_COLOR_BUFFER_BIT;
+        for (int i = 0; i < Framebuffer::MAX_NUM_RENDER_BUFFERS; i++) {
+            if (masks & (1 << i)) {
+                drawBuffers.push_back(GL_COLOR_ATTACHMENT0 + i);
+            }
+        }
+
+        if (!drawBuffers.empty()) {
+            glDrawBuffers(drawBuffers.size(), drawBuffers.data());
+            glClearColor(color.x, color.y, color.z, color.w);
+            glmask |= GL_COLOR_BUFFER_BIT;
+        }
     }
 
     glClear(glmask);
 
+    // Restore the color draw buffers only if a frmaebuffer is bound
+    if (_output._framebuffer && !drawBuffers.empty()) {
+        auto glFramebuffer = syncGPUObject(*_output._framebuffer);
+        if (glFramebuffer) {
+            glDrawBuffers(glFramebuffer->_colorBuffers.size(), glFramebuffer->_colorBuffers.data());
+        }
+    }
+
     (void) CHECK_GL_ERROR();
 }
 
-
 // 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
@@ -598,10 +618,11 @@ void GLBackend::do_glUniform4fv(Batch& batch, uint32 paramOffset) {
         return;
     }
     updatePipeline();
-    glUniform4fv(
-        batch._params[paramOffset + 2]._int,
-        batch._params[paramOffset + 1]._uint,
-        (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint));
+    
+    GLint location = batch._params[paramOffset + 2]._int;
+    GLsizei count = batch._params[paramOffset + 1]._uint;
+    const GLfloat* value = (const GLfloat*)batch.editData(batch._params[paramOffset + 0]._uint);
+    glUniform4fv(location, count, value);
 
     (void) CHECK_GL_ERROR();
 }
diff --git a/libraries/gpu/src/gpu/GLBackend.h b/libraries/gpu/src/gpu/GLBackend.h
index d798e9aaac..8df55a7f67 100644
--- a/libraries/gpu/src/gpu/GLBackend.h
+++ b/libraries/gpu/src/gpu/GLBackend.h
@@ -181,6 +181,7 @@ public:
     class GLFramebuffer : public GPUObject {
     public:
         GLuint _fbo = 0;
+        std::vector<GLenum> _colorBuffers;
 
         GLFramebuffer();
         ~GLFramebuffer();
@@ -188,6 +189,18 @@ public:
     static GLFramebuffer* syncGPUObject(const Framebuffer& framebuffer);
     static GLuint getFramebufferID(const FramebufferPointer& framebuffer);
 
+    class GLQuery : public GPUObject {
+    public:
+        GLuint _qo = 0;
+        GLuint64 _result = 0;
+
+        GLQuery();
+        ~GLQuery();
+    };
+    static GLQuery* syncGPUObject(const Query& query);
+    static GLuint getQueryID(const QueryPointer& query);
+
+
     static const int MAX_NUM_ATTRIBUTES = Stream::NUM_INPUT_SLOTS;
     static const int MAX_NUM_INPUT_BUFFERS = 16;
 
@@ -198,7 +211,7 @@ public:
     void do_setStateFillMode(int32 mode);
     void do_setStateCullMode(int32 mode);
     void do_setStateFrontFaceClockwise(bool isClockwise);
-    void do_setStateDepthClipEnable(bool enable);
+    void do_setStateDepthClampEnable(bool enable);
     void do_setStateScissorEnable(bool enable);
     void do_setStateMultisampleEnable(bool enable);
     void do_setStateAntialiasedLineEnable(bool enable);
@@ -298,6 +311,7 @@ protected:
             _model(),
             _view(),
             _projection(),
+            _viewport(0,0,1,1),
             _invalidModel(true),
             _invalidView(true),
             _invalidProj(false),
@@ -307,7 +321,7 @@ protected:
 
     // Uniform Stage
     void do_setUniformBuffer(Batch& batch, uint32 paramOffset);
-    void do_setUniformTexture(Batch& batch, uint32 paramOffset);
+    void do_setResourceTexture(Batch& batch, uint32 paramOffset);
     
     struct UniformStageState {
         
@@ -367,6 +381,11 @@ protected:
         OutputStageState() {}
     } _output;
 
+    // Query section
+    void do_beginQuery(Batch& batch, uint32 paramOffset);
+    void do_endQuery(Batch& batch, uint32 paramOffset);
+    void do_getQuery(Batch& batch, uint32 paramOffset);
+
     // 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
diff --git a/libraries/gpu/src/gpu/GLBackendOutput.cpp b/libraries/gpu/src/gpu/GLBackendOutput.cpp
index 903c97f45b..1a7c5d2281 100755
--- a/libraries/gpu/src/gpu/GLBackendOutput.cpp
+++ b/libraries/gpu/src/gpu/GLBackendOutput.cpp
@@ -40,8 +40,7 @@ GLBackend::GLFramebuffer* GLBackend::syncGPUObject(const Framebuffer& framebuffe
 
         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 
-        unsigned int nbColorBuffers = 0;
-        GLenum colorBuffers[16];
+        std::vector<GLenum> colorBuffers;
         if (framebuffer.hasColor()) {
             static const GLenum colorAttachments[] = {
                 GL_COLOR_ATTACHMENT0,
@@ -69,8 +68,7 @@ GLBackend::GLFramebuffer* GLBackend::syncGPUObject(const Framebuffer& framebuffe
                     if (gltexture) {
                         glFramebufferTexture2D(GL_FRAMEBUFFER, colorAttachments[unit], GL_TEXTURE_2D, gltexture->_texture, 0);
                     }
-                    colorBuffers[nbColorBuffers] = colorAttachments[unit];
-                    nbColorBuffers++;
+                    colorBuffers.push_back(colorAttachments[unit]);
                     unit++;
                 }
             }
@@ -100,8 +98,8 @@ GLBackend::GLFramebuffer* GLBackend::syncGPUObject(const Framebuffer& framebuffe
         }
 
         // Last but not least, define where we draw
-        if (nbColorBuffers > 0) {
-            glDrawBuffers(nbColorBuffers, colorBuffers);
+        if (!colorBuffers.empty()) {
+            glDrawBuffers(colorBuffers.size(), colorBuffers.data());
         } else {
             glDrawBuffer( GL_NONE );
         }
@@ -139,6 +137,7 @@ GLBackend::GLFramebuffer* GLBackend::syncGPUObject(const Framebuffer& framebuffe
         // All is green, assign the gpuobject to the Framebuffer
         object = new GLFramebuffer();
         object->_fbo = fbo;
+        object->_colorBuffers = colorBuffers;
         Backend::setGPUObject(framebuffer, object);
     }
 
@@ -167,4 +166,3 @@ void GLBackend::do_setFramebuffer(Batch& batch, uint32 paramOffset) {
         _output._framebuffer = framebuffer;
     }
 }
-
diff --git a/libraries/gpu/src/gpu/GLBackendPipeline.cpp b/libraries/gpu/src/gpu/GLBackendPipeline.cpp
index a770cf89b3..51a3a24e9b 100755
--- a/libraries/gpu/src/gpu/GLBackendPipeline.cpp
+++ b/libraries/gpu/src/gpu/GLBackendPipeline.cpp
@@ -147,9 +147,9 @@ void GLBackend::updatePipeline() {
 
 #if (GPU_TRANSFORM_PROFILE == GPU_CORE)
 #else
-    // If shader program needs the model we need to provide it
-    if (_pipeline._program_transformObject_model >= 0) {
-        glUniformMatrix4fv(_pipeline._program_transformObject_model, 1, false, (const GLfloat*) &_transform._transformObject._model);
+    // If shader program needs the model we need to provide it
+    if (_pipeline._program_transformObject_model >= 0) {
+        glUniformMatrix4fv(_pipeline._program_transformObject_model, 1, false, (const GLfloat*) &_transform._transformObject._model);
     }
 
     // If shader program needs the inverseView we need to provide it
@@ -188,7 +188,7 @@ void GLBackend::do_setUniformBuffer(Batch& batch, uint32 paramOffset) {
     (void) CHECK_GL_ERROR();
 }
 
-void GLBackend::do_setUniformTexture(Batch& batch, uint32 paramOffset) {
+void GLBackend::do_setResourceTexture(Batch& batch, uint32 paramOffset) {
     GLuint slot = batch._params[paramOffset + 1]._uint;
     TexturePointer uniformTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
 
diff --git a/libraries/gpu/src/gpu/GLBackendQuery.cpp b/libraries/gpu/src/gpu/GLBackendQuery.cpp
new file mode 100644
index 0000000000..39db19dafd
--- /dev/null
+++ b/libraries/gpu/src/gpu/GLBackendQuery.cpp
@@ -0,0 +1,106 @@
+//
+//  GLBackendQuery.cpp
+//  libraries/gpu/src/gpu
+//
+//  Created by Sam Gateau on 7/7/2015.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#include "GPULogging.h"
+#include "GLBackendShared.h"
+
+
+using namespace gpu;
+
+GLBackend::GLQuery::GLQuery() {}
+
+GLBackend::GLQuery::~GLQuery() {
+    if (_qo != 0) {
+        glDeleteQueries(1, &_qo);
+    }
+}
+
+GLBackend::GLQuery* GLBackend::syncGPUObject(const Query& query) {
+    GLQuery* object = Backend::getGPUObject<GLBackend::GLQuery>(query);
+
+    // If GPU object already created and in sync
+    if (object) {
+        return object;
+    }
+
+    // need to have a gpu object?
+    if (!object) {
+        GLuint qo;
+        glGenQueries(1, &qo);
+        (void) CHECK_GL_ERROR();
+        GLuint64 result = -1;
+
+        // All is green, assign the gpuobject to the Query
+        object = new GLQuery();
+        object->_qo = qo;
+        object->_result = result;
+        Backend::setGPUObject(query, object);
+    }
+
+    return object;
+}
+
+
+
+GLuint GLBackend::getQueryID(const QueryPointer& query) {
+    if (!query) {
+        return 0;
+    }
+    GLQuery* object = GLBackend::syncGPUObject(*query);
+    if (object) {
+        return object->_qo;
+    } else {
+        return 0;
+    }
+}
+
+void GLBackend::do_beginQuery(Batch& batch, uint32 paramOffset) {
+    auto query = batch._queries.get(batch._params[paramOffset]._uint);
+    GLQuery* glquery = syncGPUObject(*query);
+    if (glquery) {
+        #if (GPU_FEATURE_PROFILE == GPU_LEGACY)
+            // (EXT_TIMER_QUERY)
+            glBeginQuery(GL_TIME_ELAPSED_EXT, glquery->_qo);
+        #else
+            glBeginQuery(GL_TIME_ELAPSED, glquery->_qo);
+        #endif
+        (void)CHECK_GL_ERROR();
+    }
+}
+
+void GLBackend::do_endQuery(Batch& batch, uint32 paramOffset) {
+    auto query = batch._queries.get(batch._params[paramOffset]._uint);
+    GLQuery* glquery = syncGPUObject(*query);
+    if (glquery) {
+        #if (GPU_FEATURE_PROFILE == GPU_LEGACY)
+            // (EXT_TIMER_QUERY)
+            glEndQuery(GL_TIME_ELAPSED_EXT);
+        #else
+            glEndQuery(GL_TIME_ELAPSED);
+        #endif
+        (void)CHECK_GL_ERROR();
+    }
+}
+
+void GLBackend::do_getQuery(Batch& batch, uint32 paramOffset) {
+    auto query = batch._queries.get(batch._params[paramOffset]._uint);
+    GLQuery* glquery = syncGPUObject(*query);
+    if (glquery) { 
+        #if (GPU_FEATURE_PROFILE == GPU_LEGACY)
+            // (EXT_TIMER_QUERY)
+            #if !defined(Q_OS_LINUX)
+            glGetQueryObjectui64vEXT(glquery->_qo, GL_QUERY_RESULT, &glquery->_result);
+            #endif
+        #else
+            glGetQueryObjectui64v(glquery->_qo, GL_QUERY_RESULT, &glquery->_result);
+        #endif
+        (void)CHECK_GL_ERROR();
+    }
+}
diff --git a/libraries/gpu/src/gpu/GLBackendShader.cpp b/libraries/gpu/src/gpu/GLBackendShader.cpp
index ec02c1333b..7902275c27 100755
--- a/libraries/gpu/src/gpu/GLBackendShader.cpp
+++ b/libraries/gpu/src/gpu/GLBackendShader.cpp
@@ -111,10 +111,10 @@ void makeBindings(GLBackend::GLShader* shader) {
         shader->_transformCameraSlot = gpu::TRANSFORM_CAMERA_SLOT;
     }
 #else
-    loc = glGetUniformLocation(glprogram, "transformObject_model");
-    if (loc >= 0) {
-        shader->_transformObject_model = loc;
-    }
+    loc = glGetUniformLocation(glprogram, "transformObject_model");
+    if (loc >= 0) {
+        shader->_transformObject_model = loc;
+    }
 
     loc = glGetUniformLocation(glprogram, "transformCamera_viewInverse");
     if (loc >= 0) {
diff --git a/libraries/gpu/src/gpu/GLBackendState.cpp b/libraries/gpu/src/gpu/GLBackendState.cpp
index 274e33a049..e898a29245 100644
--- a/libraries/gpu/src/gpu/GLBackendState.cpp
+++ b/libraries/gpu/src/gpu/GLBackendState.cpp
@@ -51,7 +51,7 @@ const GLBackend::GLState::Commands makeResetStateCommands() {
         CommandPointer(new Command1I(&GLBackend::do_setStateFillMode, DEFAULT.fillMode)),
         CommandPointer(new Command1I(&GLBackend::do_setStateCullMode, DEFAULT.cullMode)),
         CommandPointer(new Command1B(&GLBackend::do_setStateFrontFaceClockwise, DEFAULT.frontFaceClockwise)),
-        CommandPointer(new Command1B(&GLBackend::do_setStateDepthClipEnable, DEFAULT.depthClipEnable)),
+        CommandPointer(new Command1B(&GLBackend::do_setStateDepthClampEnable, DEFAULT.depthClampEnable)),
         CommandPointer(new Command1B(&GLBackend::do_setStateScissorEnable, DEFAULT.scissorEnable)),
         CommandPointer(new Command1B(&GLBackend::do_setStateMultisampleEnable, DEFAULT.multisampleEnable)),
         CommandPointer(new Command1B(&GLBackend::do_setStateAntialiasedLineEnable, DEFAULT.antialisedLineEnable)),
@@ -89,8 +89,8 @@ void generateFrontFaceClockwise(GLBackend::GLState::Commands& commands, bool isC
     commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateFrontFaceClockwise, isClockwise)));
 }
 
-void generateDepthClipEnable(GLBackend::GLState::Commands& commands, bool enable) {
-    commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateDepthClipEnable, enable)));
+void generateDepthClampEnable(GLBackend::GLState::Commands& commands, bool enable) {
+    commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateDepthClampEnable, enable)));
 }
 
 void generateScissorEnable(GLBackend::GLState::Commands& commands, bool enable) {
@@ -176,8 +176,8 @@ GLBackend::GLState* GLBackend::syncGPUObject(const State& state) {
                     generateFrontFaceClockwise(object->_commands, state.isFrontFaceClockwise());
                     break;
                 }
-                case State::DEPTH_CLIP_ENABLE: {
-                    generateDepthClipEnable(object->_commands, state.isDepthClipEnable());
+                case State::DEPTH_CLAMP_ENABLE: {
+                    generateDepthClampEnable(object->_commands, state.isDepthClampEnable());
                     break;
                 }
                 case State::SCISSOR_ENABLE: {
@@ -373,7 +373,7 @@ void GLBackend::getCurrentGLState(State::Data& state) {
         GLint winding;
         glGetIntegerv(GL_FRONT_FACE, &winding);
         state.frontFaceClockwise = (winding == GL_CW);
-        state.depthClipEnable = glIsEnabled(GL_DEPTH_CLAMP);
+        state.depthClampEnable = glIsEnabled(GL_DEPTH_CLAMP);
         state.scissorEnable = glIsEnabled(GL_SCISSOR_TEST);
         state.multisampleEnable = glIsEnabled(GL_MULTISAMPLE);
         state.antialisedLineEnable = glIsEnabled(GL_LINE_SMOOTH);
@@ -533,8 +533,8 @@ void GLBackend::do_setStateFrontFaceClockwise(bool isClockwise) {
     }
 }
 
-void GLBackend::do_setStateDepthClipEnable(bool enable) {
-    if (_pipeline._stateCache.depthClipEnable != enable) {
+void GLBackend::do_setStateDepthClampEnable(bool enable) {
+    if (_pipeline._stateCache.depthClampEnable != enable) {
         if (enable) {
             glEnable(GL_DEPTH_CLAMP);
         } else {
@@ -542,7 +542,7 @@ void GLBackend::do_setStateDepthClipEnable(bool enable) {
         }
         (void) CHECK_GL_ERROR();
 
-        _pipeline._stateCache.depthClipEnable = enable;
+        _pipeline._stateCache.depthClampEnable = enable;
     }
 }
 
diff --git a/libraries/gpu/src/gpu/GLBackendTransform.cpp b/libraries/gpu/src/gpu/GLBackendTransform.cpp
index 21a2d57271..48a42fe5f1 100755
--- a/libraries/gpu/src/gpu/GLBackendTransform.cpp
+++ b/libraries/gpu/src/gpu/GLBackendTransform.cpp
@@ -15,7 +15,6 @@
 using namespace gpu;
 
 // Transform Stage
-
 void GLBackend::do_setModelTransform(Batch& batch, uint32 paramOffset) {
     _transform._model = batch._transforms.get(batch._params[paramOffset]._uint);
     _transform._invalidModel = true;
@@ -31,11 +30,10 @@ void GLBackend::do_setProjectionTransform(Batch& batch, uint32 paramOffset) {
     _transform._invalidProj = true;
 }
 
-void GLBackend::do_setViewportTransform(Batch& batch, uint32 paramOffset) {
-    memcpy(&_transform._viewport, batch.editData(batch._params[paramOffset]._uint), sizeof(Vec4i));
-    _transform._invalidViewport = true;
-}
-
+void GLBackend::do_setViewportTransform(Batch& batch, uint32 paramOffset) {
+    memcpy(&_transform._viewport, batch.editData(batch._params[paramOffset]._uint), sizeof(Vec4i));
+    _transform._invalidViewport = true;
+}
 
 void GLBackend::initTransform() {
  #if (GPU_TRANSFORM_PROFILE == GPU_CORE)
@@ -68,7 +66,7 @@ void GLBackend::syncTransformStateCache() {
     _transform._invalidView = true;
     _transform._invalidModel = true;
 
-     glGetIntegerv(GL_VIEWPORT, (GLint*) &_transform._viewport);
+    glGetIntegerv(GL_VIEWPORT, (GLint*) &_transform._viewport);
 
     GLint currentMode;
     glGetIntegerv(GL_MATRIX_MODE, &currentMode);
@@ -87,11 +85,11 @@ void GLBackend::updateTransform() {
     GLint originalMatrixMode;
     glGetIntegerv(GL_MATRIX_MODE, &originalMatrixMode);
     // Check all the dirty flags and update the state accordingly
-    if (_transform._invalidViewport) {
-        _transform._transformCamera._viewport = glm::vec4(_transform._viewport);
-
-        // Where we assign the GL viewport
-        glViewport(_transform._viewport.x, _transform._viewport.y, _transform._viewport.z, _transform._viewport.w);
+    if (_transform._invalidViewport) {
+        _transform._transformCamera._viewport = glm::vec4(_transform._viewport);
+
+        // Where we assign the GL viewport
+        glViewport(_transform._viewport.x, _transform._viewport.y, _transform._viewport.z, _transform._viewport.w);
     }
 
     if (_transform._invalidProj) {
@@ -116,18 +114,18 @@ void GLBackend::updateTransform() {
     }
  
  #if (GPU_TRANSFORM_PROFILE == GPU_CORE)
-   if (_transform._invalidView || _transform._invalidProj || _transform._invalidViewport) {
+    if (_transform._invalidView || _transform._invalidProj || _transform._invalidViewport) {
         glBindBufferBase(GL_UNIFORM_BUFFER, TRANSFORM_CAMERA_SLOT, 0);
         glBindBuffer(GL_ARRAY_BUFFER, _transform._transformCameraBuffer);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(_transform._transformCamera), (const void*) &_transform._transformCamera, GL_DYNAMIC_DRAW);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(_transform._transformCamera), (const void*)&_transform._transformCamera);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
         CHECK_GL_ERROR();
-   }
+    }
 
     if (_transform._invalidModel) {
         glBindBufferBase(GL_UNIFORM_BUFFER, TRANSFORM_OBJECT_SLOT, 0);
         glBindBuffer(GL_ARRAY_BUFFER, _transform._transformObjectBuffer);
-        glBufferData(GL_ARRAY_BUFFER, sizeof(_transform._transformObject), (const void*) &_transform._transformObject, GL_DYNAMIC_DRAW);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(_transform._transformObject), (const void*) &_transform._transformObject);
         glBindBuffer(GL_ARRAY_BUFFER, 0);
         CHECK_GL_ERROR();
     }
diff --git a/libraries/gpu/src/gpu/Query.cpp b/libraries/gpu/src/gpu/Query.cpp
new file mode 100644
index 0000000000..b8ed729c99
--- /dev/null
+++ b/libraries/gpu/src/gpu/Query.cpp
@@ -0,0 +1,27 @@
+//
+//  Query.cpp
+//  interface/src/gpu
+//
+//  Created by Niraj Venkat on 7/7/2015.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#include "Query.h"
+
+#include <QDebug>
+
+using namespace gpu;
+
+Query::Query()
+{
+}
+
+Query::~Query()
+{
+}
+
+double Query::getElapsedTime() {
+    return 0.0;
+}
diff --git a/libraries/gpu/src/gpu/Query.h b/libraries/gpu/src/gpu/Query.h
new file mode 100644
index 0000000000..0a4d554e77
--- /dev/null
+++ b/libraries/gpu/src/gpu/Query.h
@@ -0,0 +1,45 @@
+//
+//  Query.h
+//  interface/src/gpu
+//
+//  Created by Niraj Venkat on 7/7/2015.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#ifndef hifi_gpu_Query_h
+#define hifi_gpu_Query_h
+
+#include <assert.h>
+#include <memory>
+#include <vector>
+#include "GPUConfig.h"
+
+#include "Format.h"
+
+namespace gpu {
+
+    class Query {
+    public:
+        Query();
+        ~Query();
+
+        uint32 queryResult;
+
+        double getElapsedTime();
+
+    protected:
+        
+        // This shouldn't be used by anything else than the Backend class with the proper casting.
+        mutable GPUObject* _gpuObject = NULL;
+        void setGPUObject(GPUObject* gpuObject) const { _gpuObject = gpuObject; }
+        GPUObject* getGPUObject() const { return _gpuObject; }
+        friend class Backend; 
+    };
+    
+    typedef std::shared_ptr<Query> QueryPointer;
+    typedef std::vector< QueryPointer > Queries;
+};
+
+#endif
diff --git a/libraries/gpu/src/gpu/Resource.cpp b/libraries/gpu/src/gpu/Resource.cpp
index 046cf9fe40..5498e24189 100644
--- a/libraries/gpu/src/gpu/Resource.cpp
+++ b/libraries/gpu/src/gpu/Resource.cpp
@@ -15,6 +15,9 @@
 using namespace gpu;
 
 const Element Element::COLOR_RGBA_32 = Element(VEC4, UINT8, RGBA);
+const Element Element::VEC3F_XYZ = Element(VEC3, FLOAT, XYZ);
+const Element Element::INDEX_UINT16 = Element(SCALAR, UINT16, INDEX);
+const Element Element::PART_DRAWCALL = Element(VEC4, UINT32, PART);
 
 Resource::Size Resource::Sysmem::allocateMemory(Byte** dataAllocated, Size size) {
     if ( !dataAllocated ) { 
diff --git a/libraries/gpu/src/gpu/StandardShaderLib.cpp b/libraries/gpu/src/gpu/StandardShaderLib.cpp
new file mode 100755
index 0000000000..581ce47cde
--- /dev/null
+++ b/libraries/gpu/src/gpu/StandardShaderLib.cpp
@@ -0,0 +1,44 @@
+//
+//  StandardShaderLib.cpp
+//  libraries/gpu/src/gpu
+//
+//  Collection of standard shaders that can be used all over the place
+//
+//  Created by Sam Gateau on 6/22/2015.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#include "StandardShaderLib.h"
+
+#include "DrawTransformUnitQuad_vert.h"
+#include "DrawViewportQuadTransformTexcoord_vert.h"
+#include "DrawTexture_frag.h"
+
+using namespace gpu;
+
+ShaderPointer StandardShaderLib::_drawTransformUnitQuadVS;
+ShaderPointer StandardShaderLib::_drawViewportQuadTransformTexcoordVS;
+ShaderPointer StandardShaderLib::_drawTexturePS;
+
+ShaderPointer StandardShaderLib::getDrawTransformUnitQuadVS() {
+    if (!_drawTransformUnitQuadVS) {
+        _drawTransformUnitQuadVS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(DrawTransformUnitQuad_vert)));
+    }
+    return _drawTransformUnitQuadVS;
+}
+
+ShaderPointer StandardShaderLib::getDrawViewportQuadTransformTexcoordVS() {
+    if (!_drawViewportQuadTransformTexcoordVS) {
+        _drawViewportQuadTransformTexcoordVS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(DrawViewportQuadTransformTexcoord_vert)));
+    }
+    return _drawViewportQuadTransformTexcoordVS;
+}
+
+ShaderPointer StandardShaderLib::getDrawTexturePS() {
+    if (!_drawTexturePS) {
+        _drawTexturePS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(DrawTexture_frag)));
+    }
+    return _drawTexturePS;
+}
diff --git a/libraries/gpu/src/gpu/StandardShaderLib.h b/libraries/gpu/src/gpu/StandardShaderLib.h
new file mode 100755
index 0000000000..a8fc5126f8
--- /dev/null
+++ b/libraries/gpu/src/gpu/StandardShaderLib.h
@@ -0,0 +1,44 @@
+//
+//  StandardShaderLib.h
+//  libraries/gpu/src/gpu
+//
+//  Collection of standard shaders that can be used all over the place
+//
+//  Created by Sam Gateau on 6/22/2015.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#ifndef hifi_gpu_StandardShaderLib_h
+#define hifi_gpu_StandardShaderLib_h
+
+#include <assert.h>
+
+#include "Shader.h"
+
+namespace gpu {
+
+class StandardShaderLib {
+public:
+
+    // Shader draw the unit quad objectPos = ([(-1,-1),(1,1)]) and transform it by the full model transform stack (Model, View, Proj). 
+    // A texcoord attribute is also generated texcoord = [(0,0),(1,1)]
+    static ShaderPointer getDrawTransformUnitQuadVS();
+
+    // Shader draws the unit quad in the full viewport clipPos = ([(-1,-1),(1,1)]) and transform the texcoord = [(0,0),(1,1)] by the model transform.
+    static ShaderPointer getDrawViewportQuadTransformTexcoordVS();
+
+    static ShaderPointer getDrawTexturePS();
+
+protected:
+
+    static ShaderPointer _drawTransformUnitQuadVS;
+    static ShaderPointer _drawViewportQuadTransformTexcoordVS;
+    static ShaderPointer _drawTexturePS;
+};
+
+
+};
+
+#endif
diff --git a/libraries/gpu/src/gpu/State.cpp b/libraries/gpu/src/gpu/State.cpp
index ca254626e9..da3ab20c7b 100755
--- a/libraries/gpu/src/gpu/State.cpp
+++ b/libraries/gpu/src/gpu/State.cpp
@@ -24,20 +24,20 @@ State::~State() {
 // Please make sure to go check makeResetStateCommands() before modifying this value
 const State::Data State::DEFAULT = State::Data();
 
-State::Signature State::evalSignature(const Data& state) {
+State::Signature State::evalSignature(const Data& state) {
     Signature signature(0);
 
     if (state.fillMode != State::DEFAULT.fillMode) {
         signature.set(State::FILL_MODE);
-    }
+    }
     if (state.cullMode != State::DEFAULT.cullMode) {
         signature.set(State::CULL_MODE);
     }
     if (state.frontFaceClockwise != State::DEFAULT.frontFaceClockwise) {
         signature.set(State::FRONT_FACE_CLOCKWISE);
     }
-    if (state.depthClipEnable != State::DEFAULT.depthClipEnable) {
-        signature.set(State::DEPTH_CLIP_ENABLE);
+    if (state.depthClampEnable != State::DEFAULT.depthClampEnable) {
+        signature.set(State::DEPTH_CLAMP_ENABLE);
     }
     if (state.scissorEnable != State::DEFAULT.scissorEnable) {
         signature.set(State::SCISSOR_ENABLE);
@@ -47,16 +47,16 @@ State::Signature State::evalSignature(const Data& state) {
     }
     if (state.antialisedLineEnable != State::DEFAULT.antialisedLineEnable) {
         signature.set(State::ANTIALISED_LINE_ENABLE);
-    }
+    }
     if (state.depthBias != State::DEFAULT.depthBias) {
         signature.set(State::DEPTH_BIAS);
     }
     if (state.depthBiasSlopeScale != State::DEFAULT.depthBiasSlopeScale) {
         signature.set(State::DEPTH_BIAS_SLOPE_SCALE);
-    }
+    }
     if (state.depthTest != State::DEFAULT.depthTest) {
         signature.set(State::DEPTH_TEST); 
-    }
+    }
     if (state.stencilActivation != State::DEFAULT.stencilActivation) {
         signature.set(State::STENCIL_ACTIVATION);
     }
@@ -68,21 +68,21 @@ State::Signature State::evalSignature(const Data& state) {
     }
     if (state.sampleMask != State::DEFAULT.sampleMask) {
         signature.set(State::SAMPLE_MASK);
-    }
-    if (state.alphaToCoverageEnable != State::DEFAULT.alphaToCoverageEnable) {
-        signature.set(State::ALPHA_TO_COVERAGE_ENABLE); 
-    }
-    if (state.blendFunction != State::DEFAULT.blendFunction) {
-        signature.set(State::BLEND_FUNCTION);
-    }
-    if (state.colorWriteMask != State::DEFAULT.colorWriteMask) {
-        signature.set(State::COLOR_WRITE_MASK);
-    }
-
-    return signature;
-}
-
-State::State(const Data& values) :
-    _values(values) {
-    _signature = evalSignature(_values);
-}
+    }
+    if (state.alphaToCoverageEnable != State::DEFAULT.alphaToCoverageEnable) {
+        signature.set(State::ALPHA_TO_COVERAGE_ENABLE); 
+    }
+    if (state.blendFunction != State::DEFAULT.blendFunction) {
+        signature.set(State::BLEND_FUNCTION);
+    }
+    if (state.colorWriteMask != State::DEFAULT.colorWriteMask) {
+        signature.set(State::COLOR_WRITE_MASK);
+    }
+
+    return signature;
+}
+
+State::State(const Data& values) :
+    _values(values) {
+    _signature = evalSignature(_values);
+}
diff --git a/libraries/gpu/src/gpu/State.h b/libraries/gpu/src/gpu/State.h
index dce9e50488..39cad1445f 100755
--- a/libraries/gpu/src/gpu/State.h
+++ b/libraries/gpu/src/gpu/State.h
@@ -249,7 +249,7 @@ public:
         uint8 colorWriteMask = WRITE_ALL;
 
         bool frontFaceClockwise : 1;
-        bool depthClipEnable : 1;
+        bool depthClampEnable : 1;
         bool scissorEnable : 1;
         bool multisampleEnable : 1;
         bool antialisedLineEnable : 1;
@@ -257,7 +257,7 @@ public:
 
         Data() :
             frontFaceClockwise(false),
-            depthClipEnable(false),
+            depthClampEnable(false),
             scissorEnable(false),
             multisampleEnable(false),
             antialisedLineEnable(false),
@@ -276,8 +276,8 @@ public:
     void setFrontFaceClockwise(bool isClockwise) { SET_FIELD(FRONT_FACE_CLOCKWISE, DEFAULT.frontFaceClockwise, isClockwise, _values.frontFaceClockwise); }
     bool isFrontFaceClockwise() const { return _values.frontFaceClockwise; }
     
-    void setDepthClipEnable(bool enable) { SET_FIELD(DEPTH_CLIP_ENABLE, DEFAULT.depthClipEnable, enable, _values.depthClipEnable); }
-    bool isDepthClipEnable() const { return _values.depthClipEnable; }
+    void setDepthClampEnable(bool enable) { SET_FIELD(DEPTH_CLAMP_ENABLE, DEFAULT.depthClampEnable, enable, _values.depthClampEnable); }
+    bool isDepthClampEnable() const { return _values.depthClampEnable; }
     
     void setScissorEnable(bool enable) { SET_FIELD(SCISSOR_ENABLE, DEFAULT.scissorEnable, enable, _values.scissorEnable); }
     bool isScissorEnable() const { return _values.scissorEnable; }
@@ -341,6 +341,7 @@ public:
     
     // Color write mask
     void setColorWriteMask(uint8 mask) { SET_FIELD(COLOR_WRITE_MASK, DEFAULT.colorWriteMask, mask, _values.colorWriteMask); }
+    void setColorWriteMask(bool red, bool green, bool blue, bool alpha) { uint32 value = ((WRITE_RED * red) | (WRITE_GREEN * green) | (WRITE_BLUE * blue) | (WRITE_ALPHA * alpha)); SET_FIELD(COLOR_WRITE_MASK, DEFAULT.colorWriteMask, value, _values.colorWriteMask); }
     uint8 getColorWriteMask() const { return _values.colorWriteMask; }
     
     // All the possible fields
@@ -348,7 +349,7 @@ public:
         FILL_MODE,
         CULL_MODE,
         FRONT_FACE_CLOCKWISE,
-        DEPTH_CLIP_ENABLE,
+        DEPTH_CLAMP_ENABLE,
         SCISSOR_ENABLE,
         MULTISAMPLE_ENABLE,
         ANTIALISED_LINE_ENABLE,
diff --git a/libraries/gpu/src/gpu/Transform.slh b/libraries/gpu/src/gpu/Transform.slh
index 274032a642..a3299ae599 100644
--- a/libraries/gpu/src/gpu/Transform.slh
+++ b/libraries/gpu/src/gpu/Transform.slh
@@ -86,6 +86,7 @@ TransformCamera getTransformCamera() {
     return camera;
 }
 
+uniform mat4 transformObject_model;
 uniform mat4 transformCamera_viewInverse;
 uniform vec4 transformCamera_viewport;
 
@@ -130,6 +131,16 @@ uniform vec4 transformCamera_viewport;
 <@endif@>
 <@endfunc@>
 
+<@func transformModelToWorldPos(objectTransform, modelPos, worldPos)@>
+<@if GPU_TRANSFORM_PROFILE == GPU_CORE@>
+    { // transformModelToWorldPos
+        <$worldPos$> = (<$objectTransform$>._model * <$modelPos$>);
+    }
+<@else@>
+    <$worldPos$> = (transformObject_model * <$modelPos$>);
+<@endif@>
+<@endfunc@>
+
 <@func transformModelToEyeDir(cameraTransform, objectTransform, modelDir, eyeDir)@>
 <@if GPU_TRANSFORM_PROFILE == GPU_CORE@>
     { // transformModelToEyeDir
diff --git a/libraries/model/src/model/Geometry.h b/libraries/model/src/model/Geometry.h
index ddefaf4e96..16ebb60b72 100755
--- a/libraries/model/src/model/Geometry.h
+++ b/libraries/model/src/model/Geometry.h
@@ -113,6 +113,8 @@ public:
     // Generate a BufferStream on the mesh vertices and attributes
     const gpu::BufferStream makeBufferStream() const;
 
+    static gpu::Primitive topologyToPrimitive(Topology topo) { return static_cast<gpu::Primitive>(topo); }
+
 protected:
 
     gpu::Stream::FormatPointer _vertexFormat;
diff --git a/libraries/model/src/model/Light.cpp b/libraries/model/src/model/Light.cpp
index 60c6f6b3af..b7635b4af3 100755
--- a/libraries/model/src/model/Light.cpp
+++ b/libraries/model/src/model/Light.cpp
@@ -77,18 +77,27 @@ void Light::setMaximumRadius(float radius) {
     editSchema()._attenuation = Vec4(surfaceRadius, 1.0f/surfaceRadius, CutOffIntensityRatio, radius);
 }
 
+#include <math.h>
+
 void Light::setSpotAngle(float angle) {
-    if (angle <= 0.f) {
-        angle = 0.0f;
+    double dangle = angle;
+    if (dangle <= 0.0) {
+        dangle = 0.0;
     }
-    editSchema()._spot.x = cos(angle);
-    editSchema()._spot.y = sin(angle);
-    editSchema()._spot.z = angle;
+    if (dangle > glm::half_pi<double>()) {
+        dangle = glm::half_pi<double>();
+    }
+
+    auto cosAngle = cos(dangle);
+    auto sinAngle = sin(dangle);
+    editSchema()._spot.x = (float) std::abs(cosAngle);
+    editSchema()._spot.y = (float) std::abs(sinAngle);
+    editSchema()._spot.z = (float) angle;
 }
 
 void Light::setSpotExponent(float exponent) {
     if (exponent <= 0.f) {
-        exponent = 1.0f;
+        exponent = 0.0f;
     }
     editSchema()._spot.w = exponent;
 }
diff --git a/libraries/model/src/model/Light.h b/libraries/model/src/model/Light.h
index 920549d0f9..1ed07a942c 100755
--- a/libraries/model/src/model/Light.h
+++ b/libraries/model/src/model/Light.h
@@ -81,6 +81,7 @@ public:
     bool isSpot() const { return getType() == SPOT; }
     void setSpotAngle(float angle);
     float getSpotAngle() const { return getSchema()._spot.z; }
+    glm::vec2 getSpotAngleCosSin() const { return glm::vec2(getSchema()._spot.x, getSchema()._spot.y); }
     void setSpotExponent(float exponent);
     float getSpotExponent() const { return getSchema()._spot.w; }
 
@@ -107,7 +108,7 @@ public:
         Color _color{1.0f};
         float _intensity{1.0f};
         Vec4 _attenuation{1.0f};
-        Vec4 _spot{0.0f, 0.0f, 0.0f, 3.0f};
+        Vec4 _spot{0.0f, 0.0f, 0.0f, 0.0f};
         Vec4 _shadow{0.0f};
 
         Vec4 _control{0.0f, 0.0f, 0.0f, 0.0f};
diff --git a/libraries/model/src/model/Skybox.cpp b/libraries/model/src/model/Skybox.cpp
index 10199adda3..0fb2458f01 100755
--- a/libraries/model/src/model/Skybox.cpp
+++ b/libraries/model/src/model/Skybox.cpp
@@ -51,7 +51,7 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky
             static gpu::BufferPointer theBuffer;
             static gpu::Stream::FormatPointer theFormat;
             static gpu::BufferPointer theConstants;
-            int SKYBOX_CONSTANTS_SLOT = 0; // need to be defined by the compilation of the shader
+            static int SKYBOX_CONSTANTS_SLOT = 0; // need to be defined by the compilation of the shader
             if (!thePipeline) {
                 auto skyVS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(Skybox_vert)));
                 auto skyFS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(Skybox_frag)));
@@ -103,7 +103,7 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky
             batch.setInputBuffer(gpu::Stream::POSITION, theBuffer, 0, 8);
             batch.setUniformBuffer(SKYBOX_CONSTANTS_SLOT, theConstants, 0, theConstants->getSize());
             batch.setInputFormat(theFormat);
-            batch.setUniformTexture(0, skybox.getCubemap());
+            batch.setResourceTexture(0, skybox.getCubemap());
             batch.draw(gpu::TRIANGLE_STRIP, 4);
         }
 
diff --git a/libraries/physics/src/EntityMotionState.cpp b/libraries/physics/src/EntityMotionState.cpp
index 1976ddd814..4e6eb8353c 100644
--- a/libraries/physics/src/EntityMotionState.cpp
+++ b/libraries/physics/src/EntityMotionState.cpp
@@ -287,6 +287,7 @@ bool EntityMotionState::remoteSimulationOutOfSync(uint32_t simulationStep) {
     }
 
     if (_serverActionData != _entity->getActionData()) {
+        setOutgoingPriority(SCRIPT_EDIT_SIMULATION_PRIORITY);
         return true;
     }
 
diff --git a/libraries/physics/src/ObjectAction.cpp b/libraries/physics/src/ObjectAction.cpp
index 101b69f03a..5205e08c62 100644
--- a/libraries/physics/src/ObjectAction.cpp
+++ b/libraries/physics/src/ObjectAction.cpp
@@ -129,3 +129,10 @@ void ObjectAction::setAngularVelocity(glm::vec3 angularVelocity) {
     rigidBody->activate();
 }
 
+void ObjectAction::activateBody() {
+    auto rigidBody = getRigidBody();
+    if (rigidBody) {
+        rigidBody->activate();
+    }
+}
+
diff --git a/libraries/physics/src/ObjectAction.h b/libraries/physics/src/ObjectAction.h
index f619657e92..f27ed9ab07 100644
--- a/libraries/physics/src/ObjectAction.h
+++ b/libraries/physics/src/ObjectAction.h
@@ -55,6 +55,7 @@ protected:
     virtual void setLinearVelocity(glm::vec3 linearVelocity);
     virtual glm::vec3 getAngularVelocity();
     virtual void setAngularVelocity(glm::vec3 angularVelocity);
+    virtual void activateBody();
 
     void lockForRead() { _lock.lockForRead(); }
     bool tryLockForRead() { return _lock.tryLockForRead(); }
diff --git a/libraries/physics/src/ObjectActionOffset.cpp b/libraries/physics/src/ObjectActionOffset.cpp
index 2391ded13d..a00bbbd418 100644
--- a/libraries/physics/src/ObjectActionOffset.cpp
+++ b/libraries/physics/src/ObjectActionOffset.cpp
@@ -59,10 +59,6 @@ void ObjectActionOffset::updateActionWorker(btScalar deltaTimeStep) {
 
     const float MAX_LINEAR_TIMESCALE = 600.0f;  // 10 minutes is a long time
     if (_positionalTargetSet && _linearTimeScale < MAX_LINEAR_TIMESCALE) {
-        if (_needsActivation) {
-            rigidBody->activate();
-            _needsActivation = false;
-        }
         glm::vec3 objectPosition = bulletToGLM(rigidBody->getCenterOfMassPosition());
         glm::vec3 springAxis = objectPosition - _pointToOffsetFrom; // from anchor to object
         float distance = glm::length(springAxis);
@@ -95,26 +91,21 @@ bool ObjectActionOffset::updateArguments(QVariantMap arguments) {
     glm::vec3 pointToOffsetFrom =
         EntityActionInterface::extractVec3Argument("offset action", arguments, "pointToOffsetFrom", ok, true);
     if (!ok) {
-        return false;
+        pointToOffsetFrom = _pointToOffsetFrom;
     }
 
     ok = true;
     float linearTimeScale =
         EntityActionInterface::extractFloatArgument("offset action", arguments, "linearTimeScale", ok, false);
-    if (ok) { 
-        if (linearTimeScale <= 0.0f) {
-            qDebug() << "offset action -- linearTimeScale must be greater than zero.";
-            return false;
-        }
-    } else {
-        linearTimeScale = 0.1f;
+    if (!ok) { 
+        linearTimeScale = _linearTimeScale;
     }
 
     ok = true;
     float linearDistance =
         EntityActionInterface::extractFloatArgument("offset action", arguments, "linearDistance", ok, false);
     if (!ok) {
-        linearDistance = 0.0f;
+        linearDistance = _linearDistance;
     }
 
     // only change stuff if something actually changed
@@ -127,7 +118,7 @@ bool ObjectActionOffset::updateArguments(QVariantMap arguments) {
         _linearDistance = linearDistance;
         _positionalTargetSet = true;
         _active = true;
-        _needsActivation = true;
+        activateBody();
         unlock();
     }
     return true;
diff --git a/libraries/physics/src/ObjectActionOffset.h b/libraries/physics/src/ObjectActionOffset.h
index a0190f3832..1918da6996 100644
--- a/libraries/physics/src/ObjectActionOffset.h
+++ b/libraries/physics/src/ObjectActionOffset.h
@@ -36,7 +36,6 @@ public:
     float _linearDistance;
     float _linearTimeScale;
     bool _positionalTargetSet;
-    bool _needsActivation = true;
 };
 
 #endif // hifi_ObjectActionOffset_h
diff --git a/libraries/physics/src/ObjectActionSpring.cpp b/libraries/physics/src/ObjectActionSpring.cpp
index cb1dd20472..dde47f7c4e 100644
--- a/libraries/physics/src/ObjectActionSpring.cpp
+++ b/libraries/physics/src/ObjectActionSpring.cpp
@@ -17,14 +17,15 @@ const float SPRING_MAX_SPEED = 10.0f;
 
 const uint16_t ObjectActionSpring::springVersion = 1;
 
+
 ObjectActionSpring::ObjectActionSpring(const QUuid& id, EntityItemPointer ownerEntity) :
     ObjectAction(ACTION_TYPE_SPRING, id, ownerEntity),
     _positionalTarget(glm::vec3(0.0f)),
-    _linearTimeScale(0.2f),
-    _positionalTargetSet(false),
+    _linearTimeScale(FLT_MAX),
+    _positionalTargetSet(true),
     _rotationalTarget(glm::quat()),
-    _angularTimeScale(0.2f),
-    _rotationalTargetSet(false) {
+    _angularTimeScale(FLT_MAX),
+    _rotationalTargetSet(true) {
     #if WANT_DEBUG
     qDebug() << "ObjectActionSpring::ObjectActionSpring";
     #endif
@@ -61,130 +62,92 @@ void ObjectActionSpring::updateActionWorker(btScalar deltaTimeStep) {
         return;
     }
 
-    // handle the linear part
-    if (_positionalTargetSet) {
-        // check for NaN
-        if (_positionalTarget.x != _positionalTarget.x ||
-            _positionalTarget.y != _positionalTarget.y ||
-            _positionalTarget.z != _positionalTarget.z) {
-            qDebug() << "ObjectActionSpring::updateActionWorker -- target position includes NaN";
-            unlock();
-            lockForWrite();
-            _active = false;
-            unlock();
-            return;
-        }
-        glm::vec3 offset = _positionalTarget - bulletToGLM(rigidBody->getCenterOfMassPosition());
-        float offsetLength = glm::length(offset);
-        float speed = offsetLength / _linearTimeScale;
+    const float MAX_TIMESCALE = 600.0f; // 10 min is a long time
+    if (_linearTimeScale < MAX_TIMESCALE) {
+        btVector3 offset = rigidBody->getCenterOfMassPosition() - glmToBullet(_positionalTarget);
+        float offsetLength = offset.length();
+        float speed = (offsetLength > FLT_EPSILON) ? glm::min(offsetLength / _linearTimeScale, SPRING_MAX_SPEED) : 0.0f;
 
-        // cap speed
-        if (speed > SPRING_MAX_SPEED) {
-            speed = SPRING_MAX_SPEED;
-        }
-
-        if (offsetLength > IGNORE_POSITION_DELTA) {
-            glm::vec3 newVelocity = glm::normalize(offset) * speed;
-            rigidBody->setLinearVelocity(glmToBullet(newVelocity));
-            rigidBody->activate();
-        } else {
-            rigidBody->setLinearVelocity(glmToBullet(glm::vec3(0.0f)));
-        }
+        // this action is aggresively critically damped and defeats the current velocity
+        rigidBody->setLinearVelocity((- speed / offsetLength) * offset);
     }
 
-    // handle rotation
-    if (_rotationalTargetSet) {
-        if (_rotationalTarget.x != _rotationalTarget.x ||
-            _rotationalTarget.y != _rotationalTarget.y ||
-            _rotationalTarget.z != _rotationalTarget.z ||
-            _rotationalTarget.w != _rotationalTarget.w) {
-            qDebug() << "AvatarActionHold::updateActionWorker -- target rotation includes NaN";
-            unlock();
-            lockForWrite();
-            _active = false;
-            unlock();
-            return;
-        }
+    if (_angularTimeScale < MAX_TIMESCALE) {
+        btVector3 targetVelocity(0.0f, 0.0f, 0.0f);
 
-        glm::quat bodyRotation = bulletToGLM(rigidBody->getOrientation());
-        // if qZero and qOne are too close to each other, we can get NaN for angle.
-        auto alignmentDot = glm::dot(bodyRotation, _rotationalTarget);
-        const float almostOne = 0.99999f;
-        if (glm::abs(alignmentDot) < almostOne) {
-            glm::quat target = _rotationalTarget;
-            if (alignmentDot < 0) {
+        btQuaternion bodyRotation = rigidBody->getOrientation();
+        auto alignmentDot = bodyRotation.dot(glmToBullet(_rotationalTarget));
+        const float ALMOST_ONE = 0.99999f;
+        if (glm::abs(alignmentDot) < ALMOST_ONE) {
+            btQuaternion target = glmToBullet(_rotationalTarget);
+            if (alignmentDot < 0.0f) {
                 target = -target;
             }
-            glm::quat qZeroInverse = glm::inverse(bodyRotation);
-            glm::quat deltaQ = target * qZeroInverse;
-            glm::vec3 axis = glm::axis(deltaQ);
-            float angle = glm::angle(deltaQ);
-            assert(!isNaN(angle));
-            glm::vec3 newAngularVelocity = (angle / _angularTimeScale) * glm::normalize(axis);
-            rigidBody->setAngularVelocity(glmToBullet(newAngularVelocity));
-            rigidBody->activate();
-        } else {
-            rigidBody->setAngularVelocity(glmToBullet(glm::vec3(0.0f)));
+            // if dQ is the incremental rotation that gets an object from Q0 to Q1 then:
+            //
+            //      Q1 = dQ * Q0 
+            //
+            // solving for dQ gives:
+            //
+            //      dQ = Q1 * Q0^
+            btQuaternion deltaQ = target * bodyRotation.inverse();
+            float angle = deltaQ.getAngle();
+            const float MIN_ANGLE = 1.0e-4;
+            if (angle > MIN_ANGLE) {
+                targetVelocity = (angle / _angularTimeScale) * deltaQ.getAxis();
+            }
         }
+        // this action is aggresively critically damped and defeats the current velocity
+        rigidBody->setAngularVelocity(targetVelocity);
     }
-
     unlock();
 }
 
+const float MIN_TIMESCALE = 0.1f;
 
 bool ObjectActionSpring::updateArguments(QVariantMap arguments) {
     // targets are required, spring-constants are optional
-    bool ptOk = true;
+    bool ok = true;
     glm::vec3 positionalTarget =
-        EntityActionInterface::extractVec3Argument("spring action", arguments, "targetPosition", ptOk, false);
-    bool pscOk = true;
+        EntityActionInterface::extractVec3Argument("spring action", arguments, "targetPosition", ok, false);
+    if (!ok) {
+        positionalTarget = _positionalTarget;
+    }
+    ok = true;
     float linearTimeScale =
-        EntityActionInterface::extractFloatArgument("spring action", arguments, "linearTimeScale", pscOk, false);
-    if (ptOk && pscOk && linearTimeScale <= 0.0f) {
-        qDebug() << "spring action -- linearTimeScale must be greater than zero.";
-        return false;
+        EntityActionInterface::extractFloatArgument("spring action", arguments, "linearTimeScale", ok, false);
+    if (!ok || linearTimeScale <= 0.0f) {
+        linearTimeScale = _linearTimeScale;
     }
 
-    bool rtOk = true;
+    ok = true;
     glm::quat rotationalTarget =
-        EntityActionInterface::extractQuatArgument("spring action", arguments, "targetRotation", rtOk, false);
-    bool rscOk = true;
+        EntityActionInterface::extractQuatArgument("spring action", arguments, "targetRotation", ok, false);
+    if (!ok) {
+        rotationalTarget = _rotationalTarget;
+    }
+
+    ok = true;
     float angularTimeScale =
-        EntityActionInterface::extractFloatArgument("spring action", arguments, "angularTimeScale", rscOk, false);
-
-    if (!ptOk && !rtOk) {
-        qDebug() << "spring action requires at least one of targetPosition or targetRotation argument";
-        return false;
+        EntityActionInterface::extractFloatArgument("spring action", arguments, "angularTimeScale", ok, false);
+    if (!ok) {
+        angularTimeScale = _angularTimeScale;
     }
 
-    lockForWrite();
-
-    _positionalTargetSet = _rotationalTargetSet = false;
-
-    if (ptOk) {
+    if (positionalTarget != _positionalTarget
+            || linearTimeScale != _linearTimeScale
+            || rotationalTarget != _rotationalTarget
+            || angularTimeScale != _angularTimeScale) {
+        // something changed
+        lockForWrite();
         _positionalTarget = positionalTarget;
-        _positionalTargetSet = true;
-
-        if (pscOk) {
-            _linearTimeScale = linearTimeScale;
-        } else {
-            _linearTimeScale = 0.1f;
-        }
-    }
-
-    if (rtOk) {
+        _linearTimeScale = glm::max(MIN_TIMESCALE, glm::abs(linearTimeScale));
         _rotationalTarget = rotationalTarget;
-        _rotationalTargetSet = true;
-
-        if (rscOk) {
-            _angularTimeScale = angularTimeScale;
-        } else {
-            _angularTimeScale = 0.1f;
-        }
+        _angularTimeScale = glm::max(MIN_TIMESCALE, glm::abs(angularTimeScale));
+        _active = true;
+        activateBody();
+        unlock();
     }
-
-    _active = true;
-    unlock();
     return true;
 }
 
@@ -192,15 +155,11 @@ QVariantMap ObjectActionSpring::getArguments() {
     QVariantMap arguments;
     lockForRead();
 
-    if (_positionalTargetSet) {
-        arguments["linearTimeScale"] = _linearTimeScale;
-        arguments["targetPosition"] = glmToQMap(_positionalTarget);
-    }
+    arguments["linearTimeScale"] = _linearTimeScale;
+    arguments["targetPosition"] = glmToQMap(_positionalTarget);
 
-    if (_rotationalTargetSet) {
-        arguments["targetRotation"] = glmToQMap(_rotationalTarget);
-        arguments["angularTimeScale"] = _angularTimeScale;
-    }
+    arguments["targetRotation"] = glmToQMap(_rotationalTarget);
+    arguments["angularTimeScale"] = _angularTimeScale;
 
     unlock();
     return arguments;
@@ -210,7 +169,7 @@ QByteArray ObjectActionSpring::serialize() const {
     QByteArray serializedActionArguments;
     QDataStream dataStream(&serializedActionArguments, QIODevice::WriteOnly);
 
-    dataStream << getType();
+    dataStream << ACTION_TYPE_SPRING;
     dataStream << getID();
     dataStream << ObjectActionSpring::springVersion;
 
@@ -230,7 +189,7 @@ void ObjectActionSpring::deserialize(QByteArray serializedArguments) {
 
     EntityActionType type;
     dataStream >> type;
-    assert(type == getType());
+    assert(type == ACTION_TYPE_SPRING);
 
     QUuid id;
     dataStream >> id;
diff --git a/libraries/render-utils/src/DeferredLightingEffect.cpp b/libraries/render-utils/src/DeferredLightingEffect.cpp
index cc3ced93db..5d4a7adea8 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.cpp
+++ b/libraries/render-utils/src/DeferredLightingEffect.cpp
@@ -9,7 +9,6 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-// include this before QOpenGLFramebufferObject, which includes an earlier version of OpenGL
 #include <gpu/GPUConfig.h>
 
 #include <GLMHelpers.h>
@@ -24,7 +23,8 @@
 #include "TextureCache.h"
 
 #include "gpu/Batch.h"
-#include "gpu/GLBackend.h"
+#include "gpu/Context.h"
+#include "gpu/StandardShaderLib.h"
 
 #include "simple_vert.h"
 #include "simple_textured_frag.h"
@@ -32,6 +32,7 @@
 
 #include "deferred_light_vert.h"
 #include "deferred_light_limited_vert.h"
+#include "deferred_light_spot_vert.h"
 
 #include "directional_light_frag.h"
 #include "directional_light_shadow_map_frag.h"
@@ -90,26 +91,40 @@ void DeferredLightingEffect::init(AbstractViewStateInterface* viewState) {
     gpu::Shader::makeProgram(*_emissiveShader, slotBindings);
 
     _viewState = viewState;
-    loadLightProgram(directional_light_frag, false, _directionalLight, _directionalLightLocations);
-    loadLightProgram(directional_light_shadow_map_frag, false, _directionalLightShadowMap,
+    loadLightProgram(deferred_light_vert, directional_light_frag, false, _directionalLight, _directionalLightLocations);
+    loadLightProgram(deferred_light_vert, directional_light_shadow_map_frag, false, _directionalLightShadowMap,
         _directionalLightShadowMapLocations);
-    loadLightProgram(directional_light_cascaded_shadow_map_frag, false, _directionalLightCascadedShadowMap,
+    loadLightProgram(deferred_light_vert, directional_light_cascaded_shadow_map_frag, false, _directionalLightCascadedShadowMap,
         _directionalLightCascadedShadowMapLocations);
 
-    loadLightProgram(directional_ambient_light_frag, false, _directionalAmbientSphereLight, _directionalAmbientSphereLightLocations);
-    loadLightProgram(directional_ambient_light_shadow_map_frag, false, _directionalAmbientSphereLightShadowMap,
+    loadLightProgram(deferred_light_vert, directional_ambient_light_frag, false, _directionalAmbientSphereLight, _directionalAmbientSphereLightLocations);
+    loadLightProgram(deferred_light_vert, directional_ambient_light_shadow_map_frag, false, _directionalAmbientSphereLightShadowMap,
         _directionalAmbientSphereLightShadowMapLocations);
-    loadLightProgram(directional_ambient_light_cascaded_shadow_map_frag, false, _directionalAmbientSphereLightCascadedShadowMap,
+    loadLightProgram(deferred_light_vert, directional_ambient_light_cascaded_shadow_map_frag, false, _directionalAmbientSphereLightCascadedShadowMap,
         _directionalAmbientSphereLightCascadedShadowMapLocations);
 
-    loadLightProgram(directional_skybox_light_frag, false, _directionalSkyboxLight, _directionalSkyboxLightLocations);
-    loadLightProgram(directional_skybox_light_shadow_map_frag, false, _directionalSkyboxLightShadowMap,
+    loadLightProgram(deferred_light_vert, directional_skybox_light_frag, false, _directionalSkyboxLight, _directionalSkyboxLightLocations);
+    loadLightProgram(deferred_light_vert, directional_skybox_light_shadow_map_frag, false, _directionalSkyboxLightShadowMap,
         _directionalSkyboxLightShadowMapLocations);
-    loadLightProgram(directional_skybox_light_cascaded_shadow_map_frag, false, _directionalSkyboxLightCascadedShadowMap,
+    loadLightProgram(deferred_light_vert, directional_skybox_light_cascaded_shadow_map_frag, false, _directionalSkyboxLightCascadedShadowMap,
         _directionalSkyboxLightCascadedShadowMapLocations);
 
-    loadLightProgram(point_light_frag, true, _pointLight, _pointLightLocations);
-    loadLightProgram(spot_light_frag, true, _spotLight, _spotLightLocations);
+
+    loadLightProgram(deferred_light_limited_vert, point_light_frag, true, _pointLight, _pointLightLocations);
+    loadLightProgram(deferred_light_spot_vert, spot_light_frag, true, _spotLight, _spotLightLocations);
+
+    {
+        auto VSFS = gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS();
+        auto PSBlit = gpu::StandardShaderLib::getDrawTexturePS();
+        auto blitProgram = gpu::ShaderPointer(gpu::Shader::createProgram(VSFS, PSBlit));
+        gpu::Shader::makeProgram(*blitProgram);
+        gpu::StatePointer blitState = gpu::StatePointer(new gpu::State());
+        blitState->setBlendFunction(true,
+                                gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
+                                gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
+        blitState->setColorWriteMask(true, true, true, false);
+        _blitLightBuffer = gpu::PipelinePointer(gpu::Pipeline::create(blitProgram, blitState));
+    }
 
     // Allocate a global light representing the Global Directional light casting shadow (the sun) and the ambient light
     _globalLights.push_back(0);
@@ -131,7 +146,7 @@ void DeferredLightingEffect::bindSimpleProgram(gpu::Batch& batch, bool textured,
     
     if (!config.isTextured()) {
         // If it is not textured, bind white texture and keep using textured pipeline
-        batch.setUniformTexture(0, DependencyManager::get<TextureCache>()->getWhiteTexture());
+        batch.setResourceTexture(0, DependencyManager::get<TextureCache>()->getWhiteTexture());
     }
 }
 
@@ -201,51 +216,40 @@ void DeferredLightingEffect::addSpotLight(const glm::vec3& position, float radiu
 }
 
 void DeferredLightingEffect::prepare(RenderArgs* args) {
-    // clear the normal and specular buffers
+
     auto textureCache = DependencyManager::get<TextureCache>();
-    textureCache->setPrimaryDrawBuffers(false, true, false);
-    glClear(GL_COLOR_BUFFER_BIT);
-    textureCache->setPrimaryDrawBuffers(false, false, true);
-    // clearing to zero alpha for specular causes problems on my Nvidia card; clear to lowest non-zero value instead
+    gpu::Batch batch;
+    
+    // clear the normal and specular buffers
+    batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR1, glm::vec4(0.0f, 0.0f, 0.0f, 0.0f));
     const float MAX_SPECULAR_EXPONENT = 128.0f;
-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f / MAX_SPECULAR_EXPONENT);
-    glClear(GL_COLOR_BUFFER_BIT);
-    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
-    textureCache->setPrimaryDrawBuffers(true, false, false);
+    batch.clearColorFramebuffer(gpu::Framebuffer::BUFFER_COLOR2, glm::vec4(0.0f, 0.0f, 0.0f, 1.0f / MAX_SPECULAR_EXPONENT));
+
+    args->_context->syncCache();
+    args->_context->render(batch);
 }
 
 void DeferredLightingEffect::render(RenderArgs* args) {
-    // perform deferred lighting, rendering to free fbo
-    glDisable(GL_BLEND);
-    glDisable(GL_LIGHTING);
-    glDisable(GL_DEPTH_TEST);
-    glDisable(GL_COLOR_MATERIAL);
-    glDepthMask(false);
+    gpu::Batch batch;
 
+    // perform deferred lighting, rendering to free fbo
     auto textureCache = DependencyManager::get<TextureCache>();
     
-    glBindFramebuffer(GL_FRAMEBUFFER, 0 );
-
     QSize framebufferSize = textureCache->getFrameBufferSize();
     
     // binding the first framebuffer
     auto freeFBO = DependencyManager::get<GlowEffect>()->getFreeFramebuffer();
-    glBindFramebuffer(GL_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(freeFBO));
+    batch.setFramebuffer(freeFBO);
  
-    glClear(GL_COLOR_BUFFER_BIT);
-   // glEnable(GL_FRAMEBUFFER_SRGB);
+    batch.clearColorFramebuffer(freeFBO->getBufferMask(), glm::vec4(0.0f, 0.0f, 0.0f, 0.0f));
+    
+    batch.setResourceTexture(0, textureCache->getPrimaryColorTexture());
 
-   // glBindTexture(GL_TEXTURE_2D, primaryFBO->texture());
-    glBindTexture(GL_TEXTURE_2D, textureCache->getPrimaryColorTextureID());
+    batch.setResourceTexture(1, textureCache->getPrimaryNormalTexture());
     
-    glActiveTexture(GL_TEXTURE1);
-    glBindTexture(GL_TEXTURE_2D, textureCache->getPrimaryNormalTextureID());
+    batch.setResourceTexture(2, textureCache->getPrimarySpecularTexture());
     
-    glActiveTexture(GL_TEXTURE2);
-    glBindTexture(GL_TEXTURE_2D, textureCache->getPrimarySpecularTextureID());
-    
-    glActiveTexture(GL_TEXTURE3);
-    glBindTexture(GL_TEXTURE_2D, textureCache->getPrimaryDepthTextureID());
+    batch.setResourceTexture(3, textureCache->getPrimaryDepthTexture());
         
     // get the viewport side (left, right, both)
     int viewport[4];
@@ -264,55 +268,53 @@ void DeferredLightingEffect::render(RenderArgs* args) {
 
     // Fetch the ViewMatrix;
     glm::mat4 invViewMat;
-    _viewState->getViewTransform().getMatrix(invViewMat);
+    invViewMat = args->_viewFrustum->getView();
 
-    ProgramObject* program = &_directionalLight;
+    auto& program = _directionalLight;
     const LightLocations* locations = &_directionalLightLocations;
     bool shadowsEnabled = _viewState->getShadowsEnabled();
     if (shadowsEnabled) {
-        glActiveTexture(GL_TEXTURE4);
-        glBindTexture(GL_TEXTURE_2D, textureCache->getShadowDepthTextureID());
+        batch.setResourceTexture(4, textureCache->getShadowFramebuffer()->getDepthStencilBuffer());
         
-        program = &_directionalLightShadowMap;
+        program = _directionalLightShadowMap;
         locations = &_directionalLightShadowMapLocations;
         if (_viewState->getCascadeShadowsEnabled()) {
-            program = &_directionalLightCascadedShadowMap;
+            program = _directionalLightCascadedShadowMap;
             locations = &_directionalLightCascadedShadowMapLocations;
             if (useSkyboxCubemap) {
-                program = &_directionalSkyboxLightCascadedShadowMap;
+                program = _directionalSkyboxLightCascadedShadowMap;
                 locations = &_directionalSkyboxLightCascadedShadowMapLocations;
             } else if (_ambientLightMode > -1) {
-                program = &_directionalAmbientSphereLightCascadedShadowMap;
+                program = _directionalAmbientSphereLightCascadedShadowMap;
                 locations = &_directionalAmbientSphereLightCascadedShadowMapLocations;
             }
-            program->bind();
-            program->setUniform(locations->shadowDistances, _viewState->getShadowDistances());
+            batch.setPipeline(program);
+            batch._glUniform3fv(locations->shadowDistances, 1, (const GLfloat*) &_viewState->getShadowDistances());
         
         } else {
             if (useSkyboxCubemap) {
-                program = &_directionalSkyboxLightShadowMap;
+                program = _directionalSkyboxLightShadowMap;
                 locations = &_directionalSkyboxLightShadowMapLocations;
             } else if (_ambientLightMode > -1) {
-                program = &_directionalAmbientSphereLightShadowMap;
+                program = _directionalAmbientSphereLightShadowMap;
                 locations = &_directionalAmbientSphereLightShadowMapLocations;
             }
-            program->bind();
+            batch.setPipeline(program);
         }
-        program->setUniformValue(locations->shadowScale,
-            1.0f / textureCache->getShadowFramebuffer()->getWidth());
+        batch._glUniform1f(locations->shadowScale, 1.0f / textureCache->getShadowFramebuffer()->getWidth());
         
     } else {
         if (useSkyboxCubemap) {
-                program = &_directionalSkyboxLight;
+                program = _directionalSkyboxLight;
                 locations = &_directionalSkyboxLightLocations;
         } else if (_ambientLightMode > -1) {
-            program = &_directionalAmbientSphereLight;
+            program = _directionalAmbientSphereLight;
             locations = &_directionalAmbientSphereLightLocations;
         }
-        program->bind();
+        batch.setPipeline(program);
     }
 
-    {
+    { // Setup the global lighting
         auto globalLight = _allocatedLights[_globalLights.front()];
     
         if (locations->ambientSphere >= 0) {
@@ -321,220 +323,239 @@ void DeferredLightingEffect::render(RenderArgs* args) {
                 sh = (*_skybox->getCubemap()->getIrradiance());
             }
             for (int i =0; i <gpu::SphericalHarmonics::NUM_COEFFICIENTS; i++) {
-                program->setUniformValue(locations->ambientSphere + i, *(((QVector4D*) &sh) + i)); 
+               batch._glUniform4fv(locations->ambientSphere + i, 1, (const GLfloat*) (&sh) + i * 4);
             }
         }
     
         if (useSkyboxCubemap) {
-            glActiveTexture(GL_TEXTURE5);
-            glBindTexture(GL_TEXTURE_CUBE_MAP, gpu::GLBackend::getTextureID(_skybox->getCubemap()));
+            batch.setResourceTexture(5, _skybox->getCubemap());
         }
 
         if (locations->lightBufferUnit >= 0) {
-            gpu::Batch batch;
             batch.setUniformBuffer(locations->lightBufferUnit, globalLight->getSchemaBuffer());
-            gpu::GLBackend::renderBatch(batch);
         }
         
         if (_atmosphere && (locations->atmosphereBufferUnit >= 0)) {
-            gpu::Batch batch;
             batch.setUniformBuffer(locations->atmosphereBufferUnit, _atmosphere->getDataBuffer());
-            gpu::GLBackend::renderBatch(batch);
         }
-        glUniformMatrix4fv(locations->invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
+        batch._glUniformMatrix4fv(locations->invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
     }
 
     float left, right, bottom, top, nearVal, farVal;
     glm::vec4 nearClipPlane, farClipPlane;
-    _viewState->computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
-    program->setUniformValue(locations->nearLocation, nearVal);
+    args->_viewFrustum->computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
+
+    batch._glUniform1f(locations->nearLocation, nearVal);
+
     float depthScale = (farVal - nearVal) / farVal;
-    program->setUniformValue(locations->depthScale, depthScale);
+    batch._glUniform1f(locations->depthScale, depthScale);
+
     float nearScale = -1.0f / nearVal;
     float depthTexCoordScaleS = (right - left) * nearScale / sWidth;
     float depthTexCoordScaleT = (top - bottom) * nearScale / tHeight;
     float depthTexCoordOffsetS = left * nearScale - sMin * depthTexCoordScaleS;
     float depthTexCoordOffsetT = bottom * nearScale - tMin * depthTexCoordScaleT;
-    program->setUniformValue(locations->depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
-    program->setUniformValue(locations->depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
+    batch._glUniform2f(locations->depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
+    batch._glUniform2f(locations->depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
     
-    renderFullscreenQuad(sMin, sMin + sWidth, tMin, tMin + tHeight);
-    
-    program->release();
+    {
+        Transform model;
+        model.setTranslation(glm::vec3(sMin, tMin, 0.0));
+        model.setScale(glm::vec3(sWidth, tHeight, 1.0));
+        batch.setModelTransform(model);
+
+        batch.setProjectionTransform(glm::mat4());
+        batch.setViewTransform(Transform());
+
+        glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
+        glm::vec2 topLeft(-1.0f, -1.0f);
+        glm::vec2 bottomRight(1.0f, 1.0f);
+        glm::vec2 texCoordTopLeft(sMin, tMin);
+        glm::vec2 texCoordBottomRight(sMin + sWidth, tMin + tHeight);
+
+        DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
+    }
 
     if (useSkyboxCubemap) {
-        glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
-        if (!shadowsEnabled) {
-            glActiveTexture(GL_TEXTURE3);
-        }
+        batch.setResourceTexture(5, nullptr);
     }
 
     if (shadowsEnabled) {
-        glBindTexture(GL_TEXTURE_2D, 0);        
-        glActiveTexture(GL_TEXTURE3);
+        batch.setResourceTexture(4, nullptr);
     }
-    
-    // additive blending
-    glEnable(GL_BLEND);
-    glBlendFunc(GL_ONE, GL_ONE);
-    
-    glEnable(GL_CULL_FACE);
-    
+
     glm::vec4 sCoefficients(sWidth / 2.0f, 0.0f, 0.0f, sMin + sWidth / 2.0f);
     glm::vec4 tCoefficients(0.0f, tHeight / 2.0f, 0.0f, tMin + tHeight / 2.0f);
-    glTexGenfv(GL_S, GL_OBJECT_PLANE, (const GLfloat*)&sCoefficients);
-    glTexGenfv(GL_T, GL_OBJECT_PLANE, (const GLfloat*)&tCoefficients);
-    
+    auto texcoordMat = glm::mat4();
+    texcoordMat[0] = glm::vec4(sWidth / 2.0f, 0.0f, 0.0f, sMin + sWidth / 2.0f);
+    texcoordMat[1] = glm::vec4(0.0f, tHeight / 2.0f, 0.0f, tMin + tHeight / 2.0f);
+    texcoordMat[2] = glm::vec4(0.0f, 0.0f, 1.0f, 0.0f);
+    texcoordMat[3] = glm::vec4(0.0f, 0.0f, 0.0f, 1.0f);
+
     // enlarge the scales slightly to account for tesselation
     const float SCALE_EXPANSION = 0.05f;
-    
-    const glm::vec3& eyePoint = _viewState->getCurrentViewFrustum()->getPosition();
-    float nearRadius = glm::distance(eyePoint, _viewState->getCurrentViewFrustum()->getNearTopLeft());
+
+    auto eyePoint = args->_viewFrustum->getPosition();
+    float nearRadius = glm::distance(eyePoint, args->_viewFrustum->getNearTopLeft());
 
     auto geometryCache = DependencyManager::get<GeometryCache>();
     
+    glm::mat4 projMat;
+    Transform viewMat;
+    args->_viewFrustum->evalProjectionMatrix(projMat);
+    args->_viewFrustum->evalViewTransform(viewMat);
+    if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
+        viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
+    }
+    batch.setProjectionTransform(projMat);
+    batch.setViewTransform(viewMat);
+
     if (!_pointLights.empty()) {
-        _pointLight.bind();
-        _pointLight.setUniformValue(_pointLightLocations.nearLocation, nearVal);
-        _pointLight.setUniformValue(_pointLightLocations.depthScale, depthScale);
-        _pointLight.setUniformValue(_pointLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
-        _pointLight.setUniformValue(_pointLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
+        batch.setPipeline(_pointLight);
+        batch._glUniform1f(_pointLightLocations.nearLocation, nearVal);
+        batch._glUniform1f(_pointLightLocations.depthScale, depthScale);
+        batch._glUniform2f(_pointLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
+        batch._glUniform2f(_pointLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
+        
+        batch._glUniformMatrix4fv(_pointLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
+
+        batch._glUniformMatrix4fv(_pointLightLocations.texcoordMat, 1, false, reinterpret_cast< const GLfloat* >(&texcoordMat));
 
         for (auto lightID : _pointLights) {
-            auto light = _allocatedLights[lightID];
-
+            auto& light = _allocatedLights[lightID];
+            // IN DEBUG: light->setShowContour(true);
             if (_pointLightLocations.lightBufferUnit >= 0) {
-                gpu::Batch batch;
                 batch.setUniformBuffer(_pointLightLocations.lightBufferUnit, light->getSchemaBuffer());
-                gpu::GLBackend::renderBatch(batch);
             }
-            glUniformMatrix4fv(_pointLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
 
-            glPushMatrix();
-            
             float expandedRadius = light->getMaximumRadius() * (1.0f + SCALE_EXPANSION);
+            // TODO: We shouldn;t have to do that test and use a different volume geometry for when inside the vlight volume,
+            // we should be able to draw thre same geometry use DepthClamp but for unknown reason it's s not working...
             if (glm::distance(eyePoint, glm::vec3(light->getPosition())) < expandedRadius + nearRadius) {
-                glLoadIdentity();
-                glTranslatef(0.0f, 0.0f, -1.0f);
-                
-                glMatrixMode(GL_PROJECTION);
-                glPushMatrix();
-                glLoadIdentity();
-                
-                renderFullscreenQuad();
-            
-                glPopMatrix();
-                glMatrixMode(GL_MODELVIEW);
+                Transform model;
+                model.setTranslation(glm::vec3(0.0f, 0.0f, -1.0f));
+                batch.setModelTransform(model);
+                batch.setViewTransform(Transform());
+                batch.setProjectionTransform(glm::mat4());
+
+                glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
+                glm::vec2 topLeft(-1.0f, -1.0f);
+                glm::vec2 bottomRight(1.0f, 1.0f);
+                glm::vec2 texCoordTopLeft(sMin, tMin);
+                glm::vec2 texCoordBottomRight(sMin + sWidth, tMin + tHeight);
+
+                DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
                 
+                batch.setProjectionTransform(projMat);
+                batch.setViewTransform(viewMat);
             } else {
-                glTranslatef(light->getPosition().x, light->getPosition().y, light->getPosition().z);   
-                geometryCache->renderSphere(expandedRadius, 32, 32, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
+                Transform model;
+                model.setTranslation(glm::vec3(light->getPosition().x, light->getPosition().y, light->getPosition().z));
+                batch.setModelTransform(model);
+                geometryCache->renderSphere(batch, expandedRadius, 32, 32, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
             }
-            
-            glPopMatrix();
         }
         _pointLights.clear();
-        
-        _pointLight.release();
     }
     
     if (!_spotLights.empty()) {
-        _spotLight.bind();
-        _spotLight.setUniformValue(_spotLightLocations.nearLocation, nearVal);
-        _spotLight.setUniformValue(_spotLightLocations.depthScale, depthScale);
-        _spotLight.setUniformValue(_spotLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
-        _spotLight.setUniformValue(_spotLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
+        batch.setPipeline(_spotLight);
+        batch._glUniform1f(_spotLightLocations.nearLocation, nearVal);
+        batch._glUniform1f(_spotLightLocations.depthScale, depthScale);
+        batch._glUniform2f(_spotLightLocations.depthTexCoordOffset, depthTexCoordOffsetS, depthTexCoordOffsetT);
+        batch._glUniform2f(_spotLightLocations.depthTexCoordScale, depthTexCoordScaleS, depthTexCoordScaleT);
         
+        batch._glUniformMatrix4fv(_spotLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
+
+        batch._glUniformMatrix4fv(_spotLightLocations.texcoordMat, 1, false, reinterpret_cast< const GLfloat* >(&texcoordMat));
+
         for (auto lightID : _spotLights) {
             auto light = _allocatedLights[lightID];
+            // IN DEBUG: light->setShowContour(true);
 
-            if (_spotLightLocations.lightBufferUnit >= 0) {
-                gpu::Batch batch;
-                batch.setUniformBuffer(_spotLightLocations.lightBufferUnit, light->getSchemaBuffer());
-                gpu::GLBackend::renderBatch(batch);
-            }
-            glUniformMatrix4fv(_spotLightLocations.invViewMat, 1, false, reinterpret_cast< const GLfloat* >(&invViewMat));
-
-            glPushMatrix();
+            batch.setUniformBuffer(_spotLightLocations.lightBufferUnit, light->getSchemaBuffer());
             
+            auto eyeLightPos = eyePoint - light->getPosition();
+            auto eyeHalfPlaneDistance = glm::dot(eyeLightPos, light->getDirection());
+            
+            const float TANGENT_LENGTH_SCALE = 0.666f;
+            glm::vec4 coneParam(light->getSpotAngleCosSin(), TANGENT_LENGTH_SCALE * tan(0.5 * light->getSpotAngle()), 1.0f);
+
             float expandedRadius = light->getMaximumRadius() * (1.0f + SCALE_EXPANSION);
-            float edgeRadius = expandedRadius / glm::cos(light->getSpotAngle());
-            if (glm::distance(eyePoint, glm::vec3(light->getPosition())) < edgeRadius + nearRadius) {
-                glLoadIdentity();
-                glTranslatef(0.0f, 0.0f, -1.0f);
+            // TODO: We shouldn;t have to do that test and use a different volume geometry for when inside the vlight volume,
+            // we should be able to draw thre same geometry use DepthClamp but for unknown reason it's s not working...
+            if ((eyeHalfPlaneDistance > -nearRadius) && (glm::distance(eyePoint, glm::vec3(light->getPosition())) < expandedRadius + nearRadius)) {
+                coneParam.w = 0.0f;
+                batch._glUniform4fv(_spotLightLocations.coneParam, 1, reinterpret_cast< const GLfloat* >(&coneParam));
+
+                Transform model;
+                model.setTranslation(glm::vec3(0.0f, 0.0f, -1.0f));
+                batch.setModelTransform(model);
+                batch.setViewTransform(Transform());
+                batch.setProjectionTransform(glm::mat4());
                 
-                glMatrixMode(GL_PROJECTION);
-                glPushMatrix();
-                glLoadIdentity();
-                
-                renderFullscreenQuad();
-                
-                glPopMatrix();
-                glMatrixMode(GL_MODELVIEW);
+                glm::vec4 color(1.0f, 1.0f, 1.0f, 1.0f);
+                glm::vec2 topLeft(-1.0f, -1.0f);
+                glm::vec2 bottomRight(1.0f, 1.0f);
+                glm::vec2 texCoordTopLeft(sMin, tMin);
+                glm::vec2 texCoordBottomRight(sMin + sWidth, tMin + tHeight);
+
+                DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight, color);
                 
+                batch.setProjectionTransform(projMat);
+                batch.setViewTransform(viewMat);
             } else {
-                glTranslatef(light->getPosition().x, light->getPosition().y, light->getPosition().z);
-                glm::quat spotRotation = rotationBetween(glm::vec3(0.0f, 0.0f, -1.0f), light->getDirection());
-                glm::vec3 axis = glm::axis(spotRotation);
-                glRotatef(glm::degrees(glm::angle(spotRotation)), axis.x, axis.y, axis.z);   
-                glTranslatef(0.0f, 0.0f, -light->getMaximumRadius() * (1.0f + SCALE_EXPANSION * 0.5f));  
-                geometryCache->renderCone(expandedRadius * glm::tan(light->getSpotAngle()),
-                    expandedRadius, 32, 1);
+                coneParam.w = 1.0f;
+                batch._glUniform4fv(_spotLightLocations.coneParam, 1, reinterpret_cast< const GLfloat* >(&coneParam));
+
+                Transform model;
+                model.setTranslation(light->getPosition());
+                model.postRotate(light->getOrientation());
+                model.postScale(glm::vec3(expandedRadius, expandedRadius, expandedRadius));
+
+                batch.setModelTransform(model);
+                auto mesh = getSpotLightMesh();
+
+                
+                batch.setIndexBuffer(mesh->getIndexBuffer());
+                batch.setInputBuffer(0, mesh->getVertexBuffer());
+                batch.setInputFormat(mesh->getVertexFormat());
+
+                auto& part = mesh->getPartBuffer().get<model::Mesh::Part>();
+
+                batch.drawIndexed(model::Mesh::topologyToPrimitive(part._topology), part._numIndices, part._startIndex);
             }
-            
-            glPopMatrix();
         }
         _spotLights.clear();
-        
-        _spotLight.release();
     }
     
-    glBindTexture(GL_TEXTURE_2D, 0);
-        
-    glActiveTexture(GL_TEXTURE2);
-    glBindTexture(GL_TEXTURE_2D, 0);
-    
-    glActiveTexture(GL_TEXTURE1);
-    glBindTexture(GL_TEXTURE_2D, 0);
-    
-    glActiveTexture(GL_TEXTURE0);
-    glBindTexture(GL_TEXTURE_2D, 0);
-  //  glDisable(GL_FRAMEBUFFER_SRGB);
-    
+    // Probably not necessary in the long run because the gpu layer would unbound this texture if used as render target
+    batch.setResourceTexture(0, nullptr);
+    batch.setResourceTexture(1, nullptr);
+    batch.setResourceTexture(2, nullptr);
+    batch.setResourceTexture(3, nullptr);
+
+    args->_context->syncCache();
+    args->_context->render(batch);
+
     // End of the Lighting pass
 }
 
 void DeferredLightingEffect::copyBack(RenderArgs* args) {
+    gpu::Batch batch;
     auto textureCache = DependencyManager::get<TextureCache>();
     QSize framebufferSize = textureCache->getFrameBufferSize();
 
     auto freeFBO = DependencyManager::get<GlowEffect>()->getFreeFramebuffer();
 
-    //freeFBO->release();
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+    batch.setFramebuffer(textureCache->getPrimaryFramebuffer());
+    batch.setPipeline(_blitLightBuffer);
+    
+    batch.setResourceTexture(0, freeFBO->getRenderBuffer(0));
 
-    
-    glDisable(GL_CULL_FACE);
-    
-    // now transfer the lit region to the primary fbo
-    glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
-    glColorMask(true, true, true, false);
-    
-    auto primaryFBO = gpu::GLBackend::getFramebufferID(textureCache->getPrimaryFramebuffer());
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, primaryFBO);
+    batch.setProjectionTransform(glm::mat4());
+    batch.setViewTransform(Transform());
 
-    //primaryFBO->bind();
-    
-    glBindTexture(GL_TEXTURE_2D, gpu::GLBackend::getTextureID(freeFBO->getRenderBuffer(0)));
-    glEnable(GL_TEXTURE_2D);
-    
-    glPushMatrix();
-    glLoadIdentity();
-    
-    glMatrixMode(GL_PROJECTION);
-    glPushMatrix();
-    glLoadIdentity();
-    
     int viewport[4];
     glGetIntegerv(GL_VIEWPORT, viewport);
     const int VIEWPORT_X_INDEX = 0;
@@ -547,21 +568,19 @@ void DeferredLightingEffect::copyBack(RenderArgs* args) {
     float tMin = viewport[VIEWPORT_Y_INDEX] / (float)framebufferSize.height();
     float tHeight = viewport[VIEWPORT_HEIGHT_INDEX] / (float)framebufferSize.height();
 
-    renderFullscreenQuad(sMin, sMin + sWidth, tMin, tMin + tHeight);
-    
-    glBindTexture(GL_TEXTURE_2D, 0);
-    glDisable(GL_TEXTURE_2D);
-    
-    glColorMask(true, true, true, true);
-    glEnable(GL_LIGHTING);
-    glEnable(GL_COLOR_MATERIAL);
-    glEnable(GL_DEPTH_TEST);
-    glDepthMask(true);
-    
-    glPopMatrix();
-    
-    glMatrixMode(GL_MODELVIEW);
-    glPopMatrix();
+    Transform model;
+    model.setTranslation(glm::vec3(sMin, tMin, 0.0));
+    model.setScale(glm::vec3(sWidth, tHeight, 1.0));
+    batch.setModelTransform(model);
+
+
+    batch.setViewportTransform(glm::ivec4(viewport[0], viewport[1], viewport[2], viewport[3]));
+
+    batch.draw(gpu::TRIANGLE_STRIP, 4);
+
+
+    args->_context->syncCache();
+    args->_context->render(batch);
 }
 
 void DeferredLightingEffect::setupTransparent(RenderArgs* args, int lightBufferUnit) {
@@ -569,67 +588,62 @@ void DeferredLightingEffect::setupTransparent(RenderArgs* args, int lightBufferU
     args->_batch->setUniformBuffer(lightBufferUnit, globalLight->getSchemaBuffer());
 }
 
-void DeferredLightingEffect::loadLightProgram(const char* fragSource, bool limited, ProgramObject& program, LightLocations& locations) {
-    program.addShaderFromSourceCode(QGLShader::Vertex, (limited ? deferred_light_limited_vert : deferred_light_vert));
-    program.addShaderFromSourceCode(QGLShader::Fragment, fragSource);
-    program.link();
+void DeferredLightingEffect::loadLightProgram(const char* vertSource, const char* fragSource, bool lightVolume, gpu::PipelinePointer& pipeline, LightLocations& locations) {
+    auto VS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(vertSource)));
+    auto PS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(fragSource)));
     
-    program.bind();
-    program.setUniformValue("diffuseMap", 0);
-    program.setUniformValue("normalMap", 1);
-    program.setUniformValue("specularMap", 2);
-    program.setUniformValue("depthMap", 3);
-    program.setUniformValue("shadowMap", 4);
-    program.setUniformValue("skyboxMap", 5);
-    locations.shadowDistances = program.uniformLocation("shadowDistances");
-    locations.shadowScale = program.uniformLocation("shadowScale");
-    locations.nearLocation = program.uniformLocation("near");
-    locations.depthScale = program.uniformLocation("depthScale");
-    locations.depthTexCoordOffset = program.uniformLocation("depthTexCoordOffset");
-    locations.depthTexCoordScale = program.uniformLocation("depthTexCoordScale");
-    locations.radius = program.uniformLocation("radius");
-    locations.ambientSphere = program.uniformLocation("ambientSphere.L00");
-    locations.invViewMat = program.uniformLocation("invViewMat");
+    gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(VS, PS));
 
-    GLint loc = -1;
-
-#if (GPU_FEATURE_PROFILE == GPU_CORE)
+    gpu::Shader::BindingSet slotBindings;
+    slotBindings.insert(gpu::Shader::Binding(std::string("diffuseMap"), 0));
+    slotBindings.insert(gpu::Shader::Binding(std::string("normalMap"), 1));
+    slotBindings.insert(gpu::Shader::Binding(std::string("specularMap"), 2));
+    slotBindings.insert(gpu::Shader::Binding(std::string("depthMap"), 3));
+    slotBindings.insert(gpu::Shader::Binding(std::string("shadowMap"), 4));
+    slotBindings.insert(gpu::Shader::Binding(std::string("skyboxMap"), 5));
     const GLint LIGHT_GPU_SLOT = 3;
-    loc = glGetUniformBlockIndex(program.programId(), "lightBuffer");
-    if (loc >= 0) {
-        glUniformBlockBinding(program.programId(), loc, LIGHT_GPU_SLOT);
-        locations.lightBufferUnit = LIGHT_GPU_SLOT;
-    } else {
-        locations.lightBufferUnit = -1;
-    }
-#else
-    loc = program.uniformLocation("lightBuffer");
-    if (loc >= 0) {
-        locations.lightBufferUnit = loc;
-    } else {
-        locations.lightBufferUnit = -1;
-    }
-#endif
+    slotBindings.insert(gpu::Shader::Binding(std::string("lightBuffer"), LIGHT_GPU_SLOT));
+    const GLint ATMOSPHERE_GPU_SLOT = 4;
+    slotBindings.insert(gpu::Shader::Binding(std::string("atmosphereBufferUnit"), ATMOSPHERE_GPU_SLOT));
+
+    gpu::Shader::makeProgram(*program, slotBindings);
+
+    locations.shadowDistances = program->getUniforms().findLocation("shadowDistances");
+    locations.shadowScale = program->getUniforms().findLocation("shadowScale");
+    locations.nearLocation = program->getUniforms().findLocation("near");
+    locations.depthScale = program->getUniforms().findLocation("depthScale");
+    locations.depthTexCoordOffset = program->getUniforms().findLocation("depthTexCoordOffset");
+    locations.depthTexCoordScale = program->getUniforms().findLocation("depthTexCoordScale");
+    locations.radius = program->getUniforms().findLocation("radius");
+    locations.ambientSphere = program->getUniforms().findLocation("ambientSphere.L00");
+    locations.invViewMat = program->getUniforms().findLocation("invViewMat");
+    locations.texcoordMat = program->getUniforms().findLocation("texcoordMat");
+    locations.coneParam = program->getUniforms().findLocation("coneParam");
 
 #if (GPU_FEATURE_PROFILE == GPU_CORE)
-    const GLint ATMOSPHERE_GPU_SLOT = 4;
-    loc = glGetUniformBlockIndex(program.programId(), "atmosphereBufferUnit");
-    if (loc >= 0) {
-        glUniformBlockBinding(program.programId(), loc, ATMOSPHERE_GPU_SLOT);
-        locations.atmosphereBufferUnit = ATMOSPHERE_GPU_SLOT;
-    } else {
-        locations.atmosphereBufferUnit = -1;
-    }
+    locations.lightBufferUnit = program->getBuffers().findLocation("lightBuffer");
+    locations.atmosphereBufferUnit = program->getBuffers().findLocation("atmosphereBufferUnit");
 #else
-    loc = program.uniformLocation("atmosphereBufferUnit");
-    if (loc >= 0) {
-        locations.atmosphereBufferUnit = loc;
-    } else {
-        locations.atmosphereBufferUnit = -1;
-    }
+    locations.lightBufferUnit = program->getUniforms().findLocation("lightBuffer");
+    locations.atmosphereBufferUnit = program->getUniforms().findLocation("atmosphereBufferUnit");
 #endif
 
-    program.release();
+    gpu::StatePointer state = gpu::StatePointer(new gpu::State());
+    if (lightVolume) {
+        state->setCullMode(gpu::State::CULL_BACK);
+        
+        // No need for z test since the depth buffer is not bound state->setDepthTest(true, false, gpu::LESS_EQUAL);
+        // TODO: We should bind the true depth buffer both as RT and texture for the depth test
+        // TODO: We should use DepthClamp and avoid changing geometry for inside /outside cases
+        state->setDepthClampEnable(true);
+
+        // additive blending
+        state->setBlendFunction(true, gpu::State::ONE, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
+    } else {
+        state->setCullMode(gpu::State::CULL_BACK);
+    }
+    pipeline.reset(gpu::Pipeline::create(program, state));
+
 }
 
 void DeferredLightingEffect::setAmbientLightMode(int preset) {
@@ -654,3 +668,100 @@ void DeferredLightingEffect::setGlobalLight(const glm::vec3& direction, const gl
 void DeferredLightingEffect::setGlobalSkybox(const model::SkyboxPointer& skybox) {
     _skybox = skybox;
 }
+
+model::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
+    if (!_spotLightMesh) {
+        _spotLightMesh.reset(new model::Mesh());
+
+        int slices = 32;
+        int rings = 3;
+        int vertices = 2 + rings * slices;
+        int originVertex = vertices - 2;
+        int capVertex = vertices - 1;
+        int verticesSize = vertices * 3 * sizeof(float);
+        int indices = 3 * slices * (1 + 1 + 2 * (rings -1));
+        int ringFloatOffset = slices * 3;
+
+
+        GLfloat* vertexData = new GLfloat[verticesSize];
+        GLfloat* vertexRing0 = vertexData;
+        GLfloat* vertexRing1 = vertexRing0 + ringFloatOffset;
+        GLfloat* vertexRing2 = vertexRing1 + ringFloatOffset;
+        
+        for (int i = 0; i < slices; i++) {
+            float theta = TWO_PI * i / slices;
+            auto cosin = glm::vec2(cosf(theta), sinf(theta));
+
+            *(vertexRing0++) = cosin.x;
+            *(vertexRing0++) = cosin.y;
+            *(vertexRing0++) = 0.0f;
+
+            *(vertexRing1++) = cosin.x;
+            *(vertexRing1++) = cosin.y;
+            *(vertexRing1++) = 0.33f;
+
+            *(vertexRing2++) = cosin.x;
+            *(vertexRing2++) = cosin.y;
+            *(vertexRing2++) = 0.66f;
+        }
+        
+        *(vertexRing2++) = 0.0f;
+        *(vertexRing2++) = 0.0f;
+        *(vertexRing2++) = -1.0f;
+        
+        *(vertexRing2++) = 0.0f;
+        *(vertexRing2++) = 0.0f;
+        *(vertexRing2++) = 1.0f;
+        
+        _spotLightMesh->setVertexBuffer(gpu::BufferView(new gpu::Buffer(verticesSize, (gpu::Byte*) vertexData), gpu::Element::VEC3F_XYZ));
+        delete[] vertexData;
+
+        gpu::uint16* indexData = new gpu::uint16[indices];
+        gpu::uint16* index = indexData;
+        for (int i = 0; i < slices; i++) {
+            *(index++) = originVertex;
+            
+            int s0 = i;
+            int s1 = ((i + 1) % slices);
+            *(index++) = s0;
+            *(index++) = s1;
+
+            int s2 = s0 + slices;
+            int s3 = s1 + slices;
+            *(index++) = s1;
+            *(index++) = s0;
+            *(index++) = s2;
+
+            *(index++) = s1;
+            *(index++) = s2;
+            *(index++) = s3;
+
+            int s4 = s2 + slices;
+            int s5 = s3 + slices;
+            *(index++) = s3;
+            *(index++) = s2;
+            *(index++) = s4;
+
+            *(index++) = s3;
+            *(index++) = s4;
+            *(index++) = s5;
+
+
+            *(index++) = s5;
+            *(index++) = s4;
+            *(index++) = capVertex;
+        }
+
+        _spotLightMesh->setIndexBuffer(gpu::BufferView(new gpu::Buffer(sizeof(GLushort) * indices, (gpu::Byte*) indexData), gpu::Element::INDEX_UINT16));
+        delete[] indexData;
+
+        model::Mesh::Part part(0, indices, 0, model::Mesh::TRIANGLES);
+        //DEBUG: model::Mesh::Part part(0, indices, 0, model::Mesh::LINE_STRIP);
+        
+        _spotLightMesh->setPartBuffer(gpu::BufferView(new gpu::Buffer(sizeof(part), (gpu::Byte*) &part), gpu::Element::PART_DRAWCALL));
+
+        _spotLightMesh->makeBufferStream();
+    }
+    return _spotLightMesh;
+}
+
diff --git a/libraries/render-utils/src/DeferredLightingEffect.h b/libraries/render-utils/src/DeferredLightingEffect.h
index 53aac7ee93..2c5ef6bb83 100644
--- a/libraries/render-utils/src/DeferredLightingEffect.h
+++ b/libraries/render-utils/src/DeferredLightingEffect.h
@@ -21,6 +21,7 @@
 
 #include "model/Light.h"
 #include "model/Stage.h"
+#include "model/Geometry.h"
 
 class AbstractViewStateInterface;
 class RenderArgs;
@@ -94,41 +95,49 @@ private:
         int lightBufferUnit;
         int atmosphereBufferUnit;
         int invViewMat;
+        int texcoordMat;
+        int coneParam;
     };
-    
-    static void loadLightProgram(const char* fragSource, bool limited, ProgramObject& program, LightLocations& locations);
+
+    model::MeshPointer _spotLightMesh;
+    model::MeshPointer getSpotLightMesh();
+
+    static void loadLightProgram(const char* vertSource, const char* fragSource, bool lightVolume, gpu::PipelinePointer& program, LightLocations& locations);
+  
     gpu::PipelinePointer getPipeline(SimpleProgramKey config);
     
     gpu::ShaderPointer _simpleShader;
     gpu::ShaderPointer _emissiveShader;
     QHash<SimpleProgramKey, gpu::PipelinePointer> _simplePrograms;
 
-    ProgramObject _directionalSkyboxLight;
+    gpu::PipelinePointer _blitLightBuffer;
+
+    gpu::PipelinePointer _directionalSkyboxLight;
     LightLocations _directionalSkyboxLightLocations;
-    ProgramObject _directionalSkyboxLightShadowMap;
+    gpu::PipelinePointer _directionalSkyboxLightShadowMap;
     LightLocations _directionalSkyboxLightShadowMapLocations;
-    ProgramObject _directionalSkyboxLightCascadedShadowMap;
+    gpu::PipelinePointer _directionalSkyboxLightCascadedShadowMap;
     LightLocations _directionalSkyboxLightCascadedShadowMapLocations;
 
-    ProgramObject _directionalAmbientSphereLight;
+    gpu::PipelinePointer _directionalAmbientSphereLight;
     LightLocations _directionalAmbientSphereLightLocations;
-    ProgramObject _directionalAmbientSphereLightShadowMap;
+    gpu::PipelinePointer _directionalAmbientSphereLightShadowMap;
     LightLocations _directionalAmbientSphereLightShadowMapLocations;
-    ProgramObject _directionalAmbientSphereLightCascadedShadowMap;
+    gpu::PipelinePointer _directionalAmbientSphereLightCascadedShadowMap;
     LightLocations _directionalAmbientSphereLightCascadedShadowMapLocations;
 
-    ProgramObject _directionalLight;
+    gpu::PipelinePointer _directionalLight;
     LightLocations _directionalLightLocations;
-    ProgramObject _directionalLightShadowMap;
+    gpu::PipelinePointer _directionalLightShadowMap;
     LightLocations _directionalLightShadowMapLocations;
-    ProgramObject _directionalLightCascadedShadowMap;
+    gpu::PipelinePointer _directionalLightCascadedShadowMap;
     LightLocations _directionalLightCascadedShadowMapLocations;
 
-    ProgramObject _pointLight;
+    gpu::PipelinePointer _pointLight;
     LightLocations _pointLightLocations;
-    ProgramObject _spotLight;
+    gpu::PipelinePointer _spotLight;
     LightLocations _spotLightLocations;
-    
+
     class PointLight {
     public:
         glm::vec4 position;
diff --git a/libraries/render-utils/src/GeometryCache.cpp b/libraries/render-utils/src/GeometryCache.cpp
index b0e184d224..02e59bfa3a 100644
--- a/libraries/render-utils/src/GeometryCache.cpp
+++ b/libraries/render-utils/src/GeometryCache.cpp
@@ -279,14 +279,21 @@ void GeometryCache::renderSphere(gpu::Batch& batch, float radius, int slices, in
     const int VERTICES_SLOT = 0;
     const int NORMALS_SLOT = 1;
     const int COLOR_SLOT = 2;
-    gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); // 1 for everyone
-    streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
-    streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
-    streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
+    static gpu::Stream::FormatPointer streamFormat;
+    static gpu::Element positionElement, normalElement, colorElement;
+    if (!streamFormat) {
+        streamFormat.reset(new gpu::Stream::Format()); // 1 for everyone
+        streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
+        streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
+        streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
+        positionElement = streamFormat->getAttributes().at(gpu::Stream::POSITION)._element;
+        normalElement = streamFormat->getAttributes().at(gpu::Stream::NORMAL)._element;
+        colorElement = streamFormat->getAttributes().at(gpu::Stream::COLOR)._element;
+    }
 
-    gpu::BufferView verticesView(verticesBuffer, streamFormat->getAttributes().at(gpu::Stream::POSITION)._element);
-    gpu::BufferView normalsView(verticesBuffer, streamFormat->getAttributes().at(gpu::Stream::NORMAL)._element);
-    gpu::BufferView colorView(colorBuffer, streamFormat->getAttributes().at(gpu::Stream::COLOR)._element);
+    gpu::BufferView verticesView(verticesBuffer, positionElement);
+    gpu::BufferView normalsView(verticesBuffer, normalElement);
+    gpu::BufferView colorView(colorBuffer, colorElement);
     
     batch.setInputFormat(streamFormat);
     batch.setInputBuffer(VERTICES_SLOT, verticesView);
@@ -401,7 +408,6 @@ void GeometryCache::renderCone(float base, float height, int slices, int stacks)
     glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 }
 
-
 void GeometryCache::renderGrid(int xDivisions, int yDivisions, const glm::vec4& color) {
     gpu::Batch batch;
     renderGrid(batch, xDivisions, yDivisions, color);
@@ -900,14 +906,21 @@ void GeometryCache::renderSolidCube(gpu::Batch& batch, float size, const glm::ve
     const int VERTICES_SLOT = 0;
     const int NORMALS_SLOT = 1;
     const int COLOR_SLOT = 2;
-    gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); // 1 for everyone
+    static gpu::Stream::FormatPointer streamFormat;
+    static gpu::Element positionElement, normalElement, colorElement;
+    if (!streamFormat) {
+        streamFormat.reset(new gpu::Stream::Format()); // 1 for everyone
+        streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
+        streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
+        streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
+        positionElement = streamFormat->getAttributes().at(gpu::Stream::POSITION)._element;
+        normalElement = streamFormat->getAttributes().at(gpu::Stream::NORMAL)._element;
+        colorElement = streamFormat->getAttributes().at(gpu::Stream::COLOR)._element;
+    }
     
-    streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
-    streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
-    streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
-
-    gpu::BufferView verticesView(verticesBuffer, 0, verticesBuffer->getSize(), VERTEX_STRIDE, streamFormat->getAttributes().at(gpu::Stream::POSITION)._element);
-    gpu::BufferView normalsView(verticesBuffer, NORMALS_OFFSET, verticesBuffer->getSize(), VERTEX_STRIDE, streamFormat->getAttributes().at(gpu::Stream::NORMAL)._element);
+    
+    gpu::BufferView verticesView(verticesBuffer, 0, verticesBuffer->getSize(), VERTEX_STRIDE, positionElement);
+    gpu::BufferView normalsView(verticesBuffer, NORMALS_OFFSET, verticesBuffer->getSize(), VERTEX_STRIDE, normalElement);
     gpu::BufferView colorView(colorBuffer, streamFormat->getAttributes().at(gpu::Stream::COLOR)._element);
     
     batch.setInputFormat(streamFormat);
@@ -987,12 +1000,18 @@ void GeometryCache::renderWireCube(gpu::Batch& batch, float size, const glm::vec
 
     const int VERTICES_SLOT = 0;
     const int COLOR_SLOT = 1;
-    gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); // 1 for everyone
-    streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
-    streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
-    
-    gpu::BufferView verticesView(verticesBuffer, streamFormat->getAttributes().at(gpu::Stream::POSITION)._element);
-    gpu::BufferView colorView(colorBuffer, streamFormat->getAttributes().at(gpu::Stream::COLOR)._element);
+    static gpu::Stream::FormatPointer streamFormat;
+    static gpu::Element positionElement, colorElement;
+    if (!streamFormat) {
+        streamFormat.reset(new gpu::Stream::Format()); // 1 for everyone
+        streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
+        streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
+        positionElement = streamFormat->getAttributes().at(gpu::Stream::POSITION)._element;
+        colorElement = streamFormat->getAttributes().at(gpu::Stream::COLOR)._element;
+    }
+   
+    gpu::BufferView verticesView(verticesBuffer, positionElement);
+    gpu::BufferView colorView(colorBuffer, colorElement);
     
     batch.setInputFormat(streamFormat);
     batch.setInputBuffer(VERTICES_SLOT, verticesView);
diff --git a/libraries/render-utils/src/GeometryCache.h b/libraries/render-utils/src/GeometryCache.h
index f97ab8a773..83891bbf49 100644
--- a/libraries/render-utils/src/GeometryCache.h
+++ b/libraries/render-utils/src/GeometryCache.h
@@ -301,6 +301,7 @@ private:
     };
     
     QHash<IntPair, VerticesIndices> _coneVBOs;
+
     int _nextID;
 
     QHash<int, Vec3PairVec4Pair> _lastRegisteredQuad3DTexture;
diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp
index 03140c4dfb..ce325d23cb 100644
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@@ -2031,10 +2031,10 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
             }
             static bool showDiffuse = true;
             if (showDiffuse && diffuseMap) {
-                batch.setUniformTexture(0, diffuseMap->getGPUTexture());
+                batch.setResourceTexture(0, diffuseMap->getGPUTexture());
             
             } else {
-                batch.setUniformTexture(0, textureCache->getWhiteTexture());
+                batch.setResourceTexture(0, textureCache->getWhiteTexture());
             }
 
             if (locations->texcoordMatrices >= 0) {
@@ -2050,14 +2050,14 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
 
             if (!mesh.tangents.isEmpty()) {                 
                 Texture* normalMap = networkPart.normalTexture.data();
-                batch.setUniformTexture(1, !normalMap ?
+                batch.setResourceTexture(1, !normalMap ?
                     textureCache->getBlueTexture() : normalMap->getGPUTexture());
 
             }
     
             if (locations->specularTextureUnit >= 0) {
                 Texture* specularMap = networkPart.specularTexture.data();
-                batch.setUniformTexture(locations->specularTextureUnit, !specularMap ?
+                batch.setResourceTexture(locations->specularTextureUnit, !specularMap ?
                                             textureCache->getWhiteTexture() : specularMap->getGPUTexture());
             }
 
@@ -2074,7 +2074,7 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
                 GLBATCH(glUniform2f)(locations->emissiveParams, emissiveOffset, emissiveScale);
                 
                 Texture* emissiveMap = networkPart.emissiveTexture.data();
-                batch.setUniformTexture(locations->emissiveTextureUnit, !emissiveMap ?
+                batch.setResourceTexture(locations->emissiveTextureUnit, !emissiveMap ?
                                         textureCache->getWhiteTexture() : emissiveMap->getGPUTexture());
             }
             
diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp
index 4929d4b5ae..dc0de80e42 100755
--- a/libraries/render-utils/src/RenderDeferredTask.cpp
+++ b/libraries/render-utils/src/RenderDeferredTask.cpp
@@ -40,8 +40,9 @@ void ResolveDeferred::run(const SceneContextPointer& sceneContext, const RenderC
 }
 
 RenderDeferredTask::RenderDeferredTask() : Task() {
-    _jobs.push_back(Job(new PrepareDeferred::JobModel("PrepareDeferred")));
     _jobs.push_back(Job(new DrawBackground::JobModel("DrawBackground")));
+
+    _jobs.push_back(Job(new PrepareDeferred::JobModel("PrepareDeferred")));
     _jobs.push_back(Job(new FetchItems::JobModel("FetchOpaque",
         FetchItems(
             [] (const RenderContextPointer& context, int count) {
@@ -75,6 +76,12 @@ RenderDeferredTask::RenderDeferredTask() : Task() {
 
     _jobs.push_back(Job(new DrawOverlay3D::JobModel("DrawOverlay3D")));
     _jobs.push_back(Job(new ResetGLState::JobModel()));
+
+    // Give ourselves 3 frmaes of timer queries
+    _timerQueries.push_back(gpu::QueryPointer(new gpu::Query()));
+    _timerQueries.push_back(gpu::QueryPointer(new gpu::Query()));
+    _timerQueries.push_back(gpu::QueryPointer(new gpu::Query()));
+    _currentTimerQueryIndex = 0;
 }
 
 RenderDeferredTask::~RenderDeferredTask() {
@@ -101,6 +108,7 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend
     for (auto job : _jobs) {
         job.run(sceneContext, renderContext);
     }
+
 };
 
 void DrawOpaqueDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems) {
@@ -235,7 +243,7 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
     batch.setViewTransform(viewMat);
 
     batch.setPipeline(getOpaquePipeline());
-    batch.setUniformTexture(0, args->_whiteTexture);
+    batch.setResourceTexture(0, args->_whiteTexture);
 
     if (!inItems.empty()) {
         batch.clearFramebuffer(gpu::Framebuffer::BUFFER_DEPTH, glm::vec4(), 1.f, 0);
diff --git a/libraries/render-utils/src/RenderDeferredTask.h b/libraries/render-utils/src/RenderDeferredTask.h
index 3d11e97634..4040606c62 100755
--- a/libraries/render-utils/src/RenderDeferredTask.h
+++ b/libraries/render-utils/src/RenderDeferredTask.h
@@ -77,6 +77,9 @@ public:
 
     virtual void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
 
+
+    gpu::Queries _timerQueries;
+    int _currentTimerQueryIndex = 0;
 };
 
 
diff --git a/libraries/render-utils/src/TextRenderer3D.cpp b/libraries/render-utils/src/TextRenderer3D.cpp
index d202d89aba..973cddc4d7 100644
--- a/libraries/render-utils/src/TextRenderer3D.cpp
+++ b/libraries/render-utils/src/TextRenderer3D.cpp
@@ -343,7 +343,7 @@ void Font3D::setupGPU() {
         gpu::StatePointer state = gpu::StatePointer(new gpu::State());
         state->setCullMode(gpu::State::CULL_BACK);
         state->setDepthTest(true, true, gpu::LESS_EQUAL);
-        state->setBlendFunction(false,
+        state->setBlendFunction(true,
                                 gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
                                 gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
         _pipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
@@ -423,7 +423,7 @@ void Font3D::drawString(gpu::Batch& batch, float x, float y, const QString& str,
     
     setupGPU();
     batch.setPipeline(_pipeline);
-    batch.setUniformTexture(_fontLoc, _texture);
+    batch.setResourceTexture(_fontLoc, _texture);
     batch._glUniform1i(_outlineLoc, (effectType == TextRenderer3D::OUTLINE_EFFECT));
     batch._glUniform4fv(_colorLoc, 1, (const GLfloat*)color);
     
diff --git a/libraries/render-utils/src/deferred_light_limited.slv b/libraries/render-utils/src/deferred_light_limited.slv
index e3051d43f7..d57b987b68 100644
--- a/libraries/render-utils/src/deferred_light_limited.slv
+++ b/libraries/render-utils/src/deferred_light_limited.slv
@@ -12,9 +12,19 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+<@include gpu/Transform.slh@>
+
+<$declareStandardTransform()$>
+
+uniform mat4 texcoordMat;
+
 void main(void) {
-    gl_Position = ftransform();
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToClipPos(cam, obj, gl_Vertex, gl_Position)$>;
+
     vec4 projected = gl_Position / gl_Position.w;
-    gl_TexCoord[0] = vec4(dot(projected, gl_ObjectPlaneS[3]) * gl_Position.w,
-        dot(projected, gl_ObjectPlaneT[3]) * gl_Position.w, 0.0, gl_Position.w);
+    gl_TexCoord[0] = vec4(dot(projected, texcoordMat[0]) * gl_Position.w,
+        dot(projected, texcoordMat[1]) * gl_Position.w, 0.0, gl_Position.w);
 }
diff --git a/libraries/render-utils/src/deferred_light_spot.slv b/libraries/render-utils/src/deferred_light_spot.slv
new file mode 100755
index 0000000000..d3ef18fd53
--- /dev/null
+++ b/libraries/render-utils/src/deferred_light_spot.slv
@@ -0,0 +1,47 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  deferred_light_spot.vert
+//  vertex shader
+//
+//  Created by Sam Gateau on 7/8/15.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Transform.slh@>
+
+<$declareStandardTransform()$>
+
+uniform mat4 texcoordMat;
+uniform vec4 coneParam;
+
+void main(void) {
+    vec4 coneVertex = gl_Vertex;
+    if (coneParam.w != 0.0) {
+        if(coneVertex.z >= 0.0) {
+            // Evaluate the true position of the spot volume
+            vec2 dir =  float(coneVertex.z < 0.5f) * (coneParam.xy
+                            +   vec2(coneParam.y, -coneParam.x) * coneParam.z * float(coneVertex.z > 0.0f))
+                     +  float(coneVertex.z > 0.5f) * (vec2(1.0, 0.0)
+                            +   vec2(0.0, coneParam.z) * float(coneVertex.z < 1.0f));
+
+            coneVertex.xy *= dir.y;
+            coneVertex.z = -dir.x;
+        } else {
+            coneVertex.z = 0.0;
+        }
+    }
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToClipPos(cam, obj, coneVertex, gl_Position)$>;
+
+    vec4 projected = gl_Position / gl_Position.w;
+    gl_TexCoord[0] = vec4(dot(projected, texcoordMat[0]) * gl_Position.w,
+        dot(projected, texcoordMat[1]) * gl_Position.w, 0.0, gl_Position.w);
+}
diff --git a/libraries/render-utils/src/sdf_text3D.slf b/libraries/render-utils/src/sdf_text3D.slf
index d9972417ba..425d6f9b08 100644
--- a/libraries/render-utils/src/sdf_text3D.slf
+++ b/libraries/render-utils/src/sdf_text3D.slf
@@ -18,7 +18,7 @@ uniform vec4 Color;
 varying vec4 interpolatedNormal;
 
 const float gamma = 2.2;
-const float smoothing = 64.0;
+const float smoothing = 256.0;
 const float interiorCutoff = 0.8;
 const float outlineExpansion = 0.2;
 
diff --git a/libraries/render-utils/src/spot_light.slf b/libraries/render-utils/src/spot_light.slf
index e6c3938b71..cfb2a6da4b 100644
--- a/libraries/render-utils/src/spot_light.slf
+++ b/libraries/render-utils/src/spot_light.slf
@@ -28,7 +28,7 @@ void main(void) {
     // Grab the fragment data from the uv
     vec2 texCoord = gl_TexCoord[0].st / gl_TexCoord[0].q;
     DeferredFragment frag = unpackDeferredFragment(texCoord);
-      
+
     // Kill if in front of the light volume
     float depth = frag.depthVal;
     if (depth < gl_FragCoord.z) {
diff --git a/libraries/script-engine/src/ScriptEngine.cpp b/libraries/script-engine/src/ScriptEngine.cpp
index be959b9f0c..b1a4677a2c 100644
--- a/libraries/script-engine/src/ScriptEngine.cpp
+++ b/libraries/script-engine/src/ScriptEngine.cpp
@@ -710,7 +710,13 @@ void ScriptEngine::run() {
 
         // since we're in non-threaded mode, call process so that the packets are sent
         if (!entityScriptingInterface->getEntityPacketSender()->isThreaded()) {
-            entityScriptingInterface->getEntityPacketSender()->process();
+            // wait here till the edit packet sender is completely done sending
+            while (entityScriptingInterface->getEntityPacketSender()->hasPacketsToSend()) {
+                entityScriptingInterface->getEntityPacketSender()->process();
+                QCoreApplication::processEvents();
+            }
+        } else {
+            // FIXME - do we need to have a similar "wait here" loop for non-threaded packet senders?
         }
     }
 
diff --git a/libraries/shared/src/BufferParser.h b/libraries/shared/src/BufferParser.h
index 84bde2be31..d60e7127cd 100644
--- a/libraries/shared/src/BufferParser.h
+++ b/libraries/shared/src/BufferParser.h
@@ -44,10 +44,7 @@ public:
 
     template <typename T>
     inline void readFlags(PropertyFlags<T>& result) {
-        // FIXME doing heap allocation
-        QByteArray encoded((const char*)(_data + _offset), remaining());
-        result.decode(encoded);
-        _offset += result.getEncodedLength();
+        _offset += result.decode(_data + _offset, remaining());
     }
 
     template<typename T>
diff --git a/libraries/shared/src/PropertyFlags.h b/libraries/shared/src/PropertyFlags.h
index de05edc076..b0ac9e76d8 100644
--- a/libraries/shared/src/PropertyFlags.h
+++ b/libraries/shared/src/PropertyFlags.h
@@ -25,6 +25,7 @@
 #include <QBitArray>
 #include <QByteArray>
 
+#include "ByteCountCoding.h"
 #include <SharedUtil.h>
 
 template<typename Enum>class PropertyFlags {
@@ -51,7 +52,8 @@ public:
     void setHasProperty(Enum flag, bool value = true);
     bool getHasProperty(Enum flag) const;
     QByteArray encode();
-    void decode(const QByteArray& fromEncoded);
+    size_t decode(const uint8_t* data, size_t length);
+    size_t decode(const QByteArray& fromEncoded);
 
     operator QByteArray() { return encode(); };
 
@@ -193,51 +195,62 @@ template<typename Enum> inline QByteArray PropertyFlags<Enum>::encode() {
     return output;
 }
 
-template<typename Enum> inline void PropertyFlags<Enum>::decode(const QByteArray& fromEncodedBytes) {
-
+template<typename Enum> 
+inline size_t PropertyFlags<Enum>::decode(const uint8_t* data, size_t size) {
     clear(); // we are cleared out!
 
-    // first convert the ByteArray into a BitArray...
-    QBitArray encodedBits;
-    int bitCount = BITS_PER_BYTE * fromEncodedBytes.count();
-    encodedBits.resize(bitCount);
-    
-    for(int byte = 0; byte < fromEncodedBytes.count(); byte++) {
-        char originalByte = fromEncodedBytes.at(byte);
-        for(int bit = 0; bit < BITS_PER_BYTE; bit++) {
-            int shiftBy = BITS_PER_BYTE - (bit + 1);
-            char maskBit = ( 1 << shiftBy);
-            bool bitValue = originalByte & maskBit;
-            encodedBits.setBit(byte * BITS_PER_BYTE + bit, bitValue);
+    size_t bytesConsumed = 0;
+    int bitCount = BITS_IN_BYTE * size;
+
+    int encodedByteCount = 1; // there is at least 1 byte (after the leadBits)
+    int leadBits = 1; // there is always at least 1 lead bit
+    bool inLeadBits = true;
+    int bitAt = 0;
+    int expectedBitCount; // unknown at this point
+    int lastValueBit;
+    for (int byte = 0; byte < size; byte++) {
+        char originalByte = data[byte];
+        bytesConsumed++;
+        unsigned char maskBit = 0x80; // LEFT MOST BIT set
+        for (int bit = 0; bit < BITS_IN_BYTE; bit++) {
+            bool bitIsSet = originalByte & maskBit;
+            // Processing of the lead bits
+            if (inLeadBits) {
+                if (bitIsSet) {
+                    encodedByteCount++;
+                    leadBits++;
+                } else {
+                    inLeadBits = false; // once we hit our first 0, we know we're out of the lead bits
+                    expectedBitCount = (encodedByteCount * BITS_IN_BYTE) - leadBits;
+                    lastValueBit = expectedBitCount + bitAt;
+
+                    // check to see if the remainder of our buffer is sufficient
+                    if (expectedBitCount > (bitCount - leadBits)) {
+                        break;
+                    }
+                }
+            } else {
+                if (bitAt > lastValueBit) {
+                    break;
+                }
+
+                if (bitIsSet) {
+                    setHasProperty(static_cast<Enum>(bitAt - leadBits), true);
+                }
+            }
+            bitAt++;
+            maskBit >>= 1;
         }
-    }
-    
-    // next, read the leading bits to determine the correct number of bytes to decode (may not match the QByteArray)
-    int encodedByteCount = 0;
-    int leadBits = 1;
-    int bitAt;
-    for (bitAt = 0; bitAt < bitCount; bitAt++) {
-        if (encodedBits.at(bitAt)) {
-            encodedByteCount++;
-            leadBits++;
-        } else {
+        if (!inLeadBits && bitAt > lastValueBit) {
             break;
         }
     }
-    encodedByteCount++; // always at least one byte
-    _encodedLength = encodedByteCount;
+    _encodedLength = bytesConsumed;
+    return bytesConsumed;
+}
 
-    int expectedBitCount = encodedByteCount * BITS_PER_BYTE;
-    
-    // Now, keep reading...
-    if (expectedBitCount <= (encodedBits.size() - leadBits)) {
-        int flagsStartAt = bitAt + 1; 
-        for (bitAt = flagsStartAt; bitAt < expectedBitCount; bitAt++) {
-            if (encodedBits.at(bitAt)) {
-                setHasProperty((Enum)(bitAt - flagsStartAt));
-            }
-        }
-    }
+template<typename Enum> inline size_t PropertyFlags<Enum>::decode(const QByteArray& fromEncodedBytes) {
+    return decode(reinterpret_cast<const uint8_t*>(fromEncodedBytes.data()), fromEncodedBytes.size());
 }
 
 template<typename Enum> inline void PropertyFlags<Enum>::debugDumpBits() {
diff --git a/tests/entities/CMakeLists.txt b/tests/entities/CMakeLists.txt
new file mode 100644
index 0000000000..0077549100
--- /dev/null
+++ b/tests/entities/CMakeLists.txt
@@ -0,0 +1,12 @@
+
+set(TARGET_NAME "entities-test")
+
+# This is not a testcase -- just set it up as a regular hifi project
+setup_hifi_project(Network Script)
+
+set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "Tests/manual-tests/")
+
+# link in the shared libraries
+link_hifi_libraries(entities avatars shared octree gpu model fbx networking animation environment)
+
+copy_dlls_beside_windows_executable()
\ No newline at end of file
diff --git a/tests/entities/packet.bin b/tests/entities/packet.bin
new file mode 100644
index 0000000000..295117172d
Binary files /dev/null and b/tests/entities/packet.bin differ
diff --git a/tests/entities/src/main.cpp b/tests/entities/src/main.cpp
new file mode 100644
index 0000000000..8d16d98103
--- /dev/null
+++ b/tests/entities/src/main.cpp
@@ -0,0 +1,165 @@
+//
+//  main.cpp
+//  tests/render-utils/src
+//
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include <QCoreApplication>
+#include <QFile>
+#include <QTimer>
+#include <QElapsedTimer>
+#include <QLoggingCategory>
+#include <QDir>
+#include <ByteCountCoding.h>
+
+#include <PathUtils.h>
+#include <BoxEntityItem.h>
+#include <Octree.h>
+
+const QString& getTestResourceDir() {
+    static QString dir;
+    if (dir.isEmpty()) {
+        QDir path(__FILE__);
+        path.cdUp();
+        dir = path.cleanPath(path.absoluteFilePath("../")) + "/";
+        qDebug() << "Qml Test Path: " << dir;
+    }
+    return dir;
+}
+
+class StopWatch {
+public:
+    void start() {
+        Q_ASSERT(_start == 0);
+        _start = usecTimestampNow();
+    }
+
+    void stop() {
+        Q_ASSERT(_start != 0);
+        _last = usecTimestampNow() - _start;
+        _start = 0;
+        _total += _last;
+        _count++;
+    }
+
+    quint64 getLast() {
+        return _last;
+    }
+
+    quint64 getTotal() {
+        return _total;
+    }
+
+    float getAverage() {
+        return (float)_total / (float)_count;
+    }
+
+    void reset() {
+        _last = _start = _total = _count = 0;
+    }
+
+private:
+    size_t _count{ 0 };
+    quint64 _total{ 0 };
+    quint64 _start{ 0 };
+    quint64 _last{ 0 };
+};
+
+template <typename T>
+void testByteCountCodedStable(const T& value) {
+    ByteCountCoded<T> coder((T)value);
+    auto encoded = coder.encode();
+    auto originalEncodedSize = encoded.size();
+    for (int i = 0; i < 10; ++i) {
+        encoded.append(qrand());
+    }
+    ByteCountCoded<T> decoder;
+    decoder.decode(encoded);
+    Q_ASSERT(decoder.data == coder.data);
+    auto consumed = decoder.decode(encoded.data(), encoded.size());
+    Q_ASSERT(consumed == originalEncodedSize);
+
+}
+
+template <typename T>
+void testByteCountCoded() {
+    testByteCountCodedStable<T>(0);
+    testByteCountCodedStable<T>(1);
+    testByteCountCodedStable<T>(1 << 16);
+    testByteCountCodedStable<T>(std::numeric_limits<T>::max() >> 16);
+    testByteCountCodedStable<T>(std::numeric_limits<T>::max() >> 8);
+    testByteCountCodedStable<T>(std::numeric_limits<T>::max() >> 1);
+    testByteCountCodedStable<T>(std::numeric_limits<T>::max());
+}
+
+void testPropertyFlags(uint32_t value) {
+    EntityPropertyFlags original;
+    original.clear();
+    auto enumSize = sizeof(EntityPropertyList);
+    for (size_t i = 0; i < sizeof(EntityPropertyList) * 8; ++i) {
+        original.setHasProperty((EntityPropertyList)i);
+    }
+    QByteArray encoded = original.encode();
+    auto originalSize = encoded.size();
+    for (size_t i = 0; i < sizeof(EntityPropertyList); ++i) {
+        encoded.append(qrand());
+    }
+
+    EntityPropertyFlags decodeOld, decodeNew;
+    {
+        decodeOld.decode(encoded);
+        Q_ASSERT(decodeOld == original);
+    }
+
+    {
+        auto decodeSize = decodeNew.decode((const uint8_t*)encoded.data(), encoded.size());
+        Q_ASSERT(originalSize == decodeSize);
+        Q_ASSERT(decodeNew == original);
+    }
+}
+
+void testPropertyFlags() {
+    testPropertyFlags(0);
+    testPropertyFlags(1);
+    testPropertyFlags(1 << 16);
+    testPropertyFlags(0xFFFF);
+}
+
+int main(int argc, char** argv) {    
+    QCoreApplication app(argc, argv);
+    {
+        auto start = usecTimestampNow();
+        for (int i = 0; i < 1000; ++i) {
+            testPropertyFlags();
+            testByteCountCoded<quint8>();
+            testByteCountCoded<quint16>();
+            testByteCountCoded<quint32>();
+            testByteCountCoded<quint64>();
+        }
+        auto duration = usecTimestampNow() - start;
+        qDebug() << duration;
+
+    }
+    DependencyManager::set<NodeList>(NodeType::Unassigned);
+
+    QFile file(getTestResourceDir() + "packet.bin");
+    if (!file.open(QIODevice::ReadOnly)) return -1;
+    QByteArray packet = file.readAll();
+    EntityItemPointer item = BoxEntityItem::factory(EntityItemID(), EntityItemProperties());
+    ReadBitstreamToTreeParams params;
+    params.bitstreamVersion = 33;
+
+    auto start = usecTimestampNow();
+    for (int i = 0; i < 1000; ++i) {
+        item->readEntityDataFromBuffer(reinterpret_cast<const unsigned char*>(packet.constData()), packet.size(), params);
+    }
+    float duration = (usecTimestampNow() - start);
+    qDebug() << (duration / 1000.0f);
+    return 0;
+}
+
+#include "main.moc"
diff --git a/tests/shared/src/TransformTests.cpp b/tests/shared/src/TransformTests.cpp
new file mode 100644
index 0000000000..93b0583aa6
--- /dev/null
+++ b/tests/shared/src/TransformTests.cpp
@@ -0,0 +1,84 @@
+//
+// TransformTests.cpp
+// tests/shared/src
+//
+// Copyright 2013-2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include <Transform.h>
+
+#include "TransformTests.h"
+#include "SharedLogging.h"
+
+using namespace glm;
+
+const vec3 xAxis(1.0f, 0.0f, 0.0f);
+const vec3 yAxis(0.0f, 1.0f, 0.0f);
+const vec3 zAxis(0.0f, 0.0f, 1.0f);
+const quat rot90 = angleAxis((float)M_PI / 2.0f, yAxis);
+
+QTEST_MAIN(TransformTests)
+
+const float EPSILON = 0.001f;
+
+void TransformTests::getMatrix() {
+
+    const vec3 t(0.0f, 0.0f, 10.0f);
+
+    // create a matrix that is composed of a PI/2 rotation followed by a small z translation
+    const mat4 m(vec4(rot90 * xAxis, 0.0f),
+                 vec4(rot90 * yAxis, 0.0f),
+                 vec4(rot90 * zAxis, 0.0f),
+                 vec4(vec4(t, 1.0f)));
+
+    // postScale by a mirror about the x axis.
+    const mat4 mirrorX(vec4(-1.0f, 0.0f, 0.0f, 0.0f),
+                       vec4( 0.0f, 1.0f, 0.0f, 0.0f),
+                       vec4( 0.0f, 0.0f, 1.0f, 0.0f),
+                       vec4( 0.0f, 0.0f, 0.0f, 1.0f));
+    const mat4 result_a = m * mirrorX;
+
+    Transform xform;
+    xform.setRotation(rot90);
+    xform.setTranslation(t);
+    xform.postScale(vec3(-1.0f, 1.0f, 1.0f));
+    mat4 result_b;
+    xform.getMatrix(result_b);
+
+    QCOMPARE_WITH_ABS_ERROR(result_a, result_b, EPSILON);
+}
+
+void TransformTests::getInverseMatrix() {
+
+    const vec3 t(0.0f, 0.0f, 10.0f);
+
+    // create a matrix that is composed of a PI/2 rotation followed by a small z translation
+    const mat4 m(vec4(rot90 * xAxis, 0.0f),
+                 vec4(rot90 * yAxis, 0.0f),
+                 vec4(rot90 * zAxis, 0.0f),
+                 vec4(vec4(t, 1.0f)));
+
+    // mirror about the x axis.
+    const mat4 mirrorX(vec4(-1.0f, 0.0f, 0.0f, 0.0f),
+                       vec4( 0.0f, 1.0f, 0.0f, 0.0f),
+                       vec4( 0.0f, 0.0f, 1.0f, 0.0f),
+                       vec4( 0.0f, 0.0f, 0.0f, 1.0f));
+    const mat4 result_a = inverse(m * mirrorX);
+
+    Transform xform;
+    xform.setTranslation(t);
+    xform.setRotation(rot90);
+
+    //
+    // change postScale to preScale and the test will pass...
+    //
+
+    xform.postScale(vec3(-1.0f, 1.0f, 1.0f));
+    mat4 result_b;
+    xform.getInverseMatrix(result_b);
+
+    QCOMPARE_WITH_ABS_ERROR(result_a, result_b, EPSILON);
+}
diff --git a/tests/shared/src/TransformTests.h b/tests/shared/src/TransformTests.h
new file mode 100644
index 0000000000..ab5c8cf144
--- /dev/null
+++ b/tests/shared/src/TransformTests.h
@@ -0,0 +1,52 @@
+//
+// TransformTests.h
+// tests/shared/src
+//
+// Copyright 2013-2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_TransformTests_h
+#define hifi_TransformTests_h
+
+#include <QtTest/QtTest>
+#include <glm/glm.hpp>
+#include <algorithm>
+
+inline float getErrorDifference(const glm::mat4& a, const glm::mat4& b) {
+    float maxDiff = 0;
+    for (int i = 0; i < 4; ++i) {
+        for (int j = 0; j < 4; ++j) {
+            float diff = fabs(a[i][j] - b[i][j]);
+            maxDiff = std::max(diff, maxDiff);
+        }
+    }
+    return maxDiff;
+}
+
+inline QTextStream& operator<< (QTextStream& stream, const glm::mat4& matrix) {
+    stream << "[\n\t\t";
+    stream.setFieldWidth(15);
+    for (int r = 0; r < 4; ++r) {
+        for (int c = 0; c < 4; ++c) {
+            stream << matrix[c][r];
+        }
+        stream << "\n\t\t";
+    }
+    stream.setFieldWidth(0);
+    stream << "]\n\t";   // hacky as hell, but this should work...
+    return stream;
+}
+
+#include <../QTestExtensions.h>
+
+class TransformTests : public QObject {
+    Q_OBJECT
+private slots:
+    void getMatrix();
+    void getInverseMatrix();
+};
+
+#endif // hifi_TransformTests_h