merge upstream/master into andrew/thermonuclear

assignment-client/src/metavoxels/MetavoxelServer.cpp

@@ -311,7 +311,7 @@ MetavoxelPersister::MetavoxelPersister(MetavoxelServer* server) :
 const char* SAVE_FILE = "/resources/metavoxels.dat";
 
 const int FILE_MAGIC = 0xDADAFACE;
-const int FILE_VERSION = 1;
+const int FILE_VERSION = 2;
 
 void MetavoxelPersister::load() {
     QString path = QCoreApplication::applicationDirPath() + SAVE_FILE;

examples/butterflies.js

@@ -13,18 +13,13 @@
 //
 
 
-var numButterflies = 20;
+var numButterflies = 25;
 
 
 function getRandomFloat(min, max) {
     return Math.random() * (max - min) + min;
 }
 
-// Multiply vector by scalar
-function vScalarMult(v, s) {
-    var rval = { x: v.x * s, y: v.y * s, z: v.z * s };
-    return rval;
-}
 
 // Create a random vector with individual lengths between a,b
 function randVector(a, b) {
@@ -32,50 +27,36 @@ function randVector(a, b) {
     return rval;
 }
 
-// Returns a vector which is fraction of the way between a and b
-function vInterpolate(a, b, fraction) {
-    var rval = { x: a.x + (b.x - a.x) * fraction, y: a.y + (b.y - a.y) * fraction, z: a.z + (b.z - a.z) * fraction };
-    return rval;
-}
-
 var startTimeInSeconds = new Date().getTime() / 1000;
 
-var NATURAL_SIZE_OF_BUTTERFLY = { x: 1.76, y: 0.825, z: 0.20 };
-var lifeTime = 600; // lifetime of the butterflies in seconds
-var range = 3.0; // Over what distance in meters do you want the flock to fly around
+var NATURAL_SIZE_OF_BUTTERFLY = { x: 1.0, y: 0.4, z: 0.2 };
+
+var lifeTime = 3600; // One hour lifespan
+var range = 7.0; // Over what distance in meters do you want the flock to fly around
 var frame = 0;
 
-var CHANCE_OF_MOVING = 0.9;
-var BUTTERFLY_GRAVITY = 0;
-var BUTTERFLY_FLAP_SPEED = 0.5;
-var BUTTERFLY_VELOCITY = 0.55;
 var DISTANCE_IN_FRONT_OF_ME = 1.5;
 var DISTANCE_ABOVE_ME = 1.5;
-var flockPosition = Vec3.sum(MyAvatar.position,Vec3.sum(
+var FIXED_LOCATION = false; 
+
+if (!FIXED_LOCATION) {
+    var flockPosition = Vec3.sum(MyAvatar.position,Vec3.sum(
                         Vec3.multiply(Quat.getFront(MyAvatar.orientation), DISTANCE_ABOVE_ME), 
                         Vec3.multiply(Quat.getFront(MyAvatar.orientation), DISTANCE_IN_FRONT_OF_ME)));
-        
+} else {
+    var flockPosition = { x: 4999.6, y: 4986.5, z: 5003.5 };
+}
 
-// set these pitch, yaw, roll to the needed values to orient the model as you want it
-var	pitchInDegrees = 270.0;
-var	yawInDegrees = 0.0;
-var	rollInDegrees = 0.0;
-var	pitchInRadians = pitchInDegrees / 180.0 * Math.PI;
-var	yawInRadians = yawInDegrees / 180.0 * Math.PI;
-var	rollInRadians = rollInDegrees / 180.0 * Math.PI;
-
-var rotation = Quat.fromPitchYawRollDegrees(pitchInDegrees, yawInDegrees, rollInDegrees);//experimental
 	
 // This is our butterfly object
 function defineButterfly(entityID, targetPosition) {
     this.entityID = entityID;
-    this.previousFlapOffset = 0;
     this.targetPosition = targetPosition;
-    this.moving = false;
 }
 
 // Array of butterflies
 var butterflies = [];
+
 function addButterfly() {
     // Decide the size of butterfly 
     var color = { red: 100, green: 100, blue: 100 };
@@ -88,26 +69,24 @@ function addButterfly() {
     size = MINSIZE + Math.random() * RANGESIZE;
     
     var dimensions = Vec3.multiply(NATURAL_SIZE_OF_BUTTERFLY, (size / maxSize));
-	
-    flockPosition = Vec3.sum(MyAvatar.position,Vec3.sum(
-                        Vec3.multiply(Quat.getFront(MyAvatar.orientation), DISTANCE_ABOVE_ME), 
-                        Vec3.multiply(Quat.getFront(MyAvatar.orientation), DISTANCE_IN_FRONT_OF_ME)));
-	
+		
+    var GRAVITY = -0.2;
+    var newFrameRate = 20 + Math.random() * 30;
     var properties = {
         type: "Model",
         lifetime: lifeTime,
         position: Vec3.sum(randVector(-range, range), flockPosition),
-        velocity: { x: 0, y: 0.0, z: 0 },
-        gravity: { x: 0, y: 1.0, z: 0 },
-		damping: 0.1,
+        rotation: Quat.fromPitchYawRollDegrees(-80 + Math.random() * 20, Math.random() * 360.0, 0.0),
+        velocity: { x: 0, y: 0, z: 0 },
+        gravity: { x: 0, y: GRAVITY, z: 0 },
+		damping: 0.9999,
 		dimensions: dimensions,
         color: color,
-		rotation: rotation,
 		animationURL: "https://s3-us-west-1.amazonaws.com/highfidelity-public/models/content/butterfly/butterfly.fbx",
-		animationIsPlaying: true,
+        animationSettings: "{\"firstFrame\":0,\"fps\":" + newFrameRate + ",\"frameIndex\":0,\"hold\":false,\"lastFrame\":10000,\"loop\":true,\"running\":true,\"startAutomatically\":false}",
 		modelURL: "https://s3-us-west-1.amazonaws.com/highfidelity-public/models/content/butterfly/butterfly.fbx"
     };
-    butterflies.push(new defineButterfly(Entities.addEntity(properties), properties.position));
+    butterflies.push(Entities.addEntity(properties));
 }
 
 // Generate the butterflies
@@ -116,117 +95,37 @@ for (var i = 0; i < numButterflies; i++) {
 }
 
 // Main update function
-function updateButterflies(deltaTime) {
-    // Check to see if we've been running long enough that our butterflies are dead
-    var nowTimeInSeconds = new Date().getTime() / 1000;
-    if ((nowTimeInSeconds - startTimeInSeconds) >= lifeTime) {
-        Script.stop();
-        return;
-    }
-  
+function updateButterflies(deltaTime) {  
     frame++;
     // Only update every third frame because we don't need to do it too quickly
     if ((frame % 3) == 0) {
-        flockPosition = Vec3.sum(MyAvatar.position,Vec3.sum(Vec3.multiply(Quat.getFront(MyAvatar.orientation), DISTANCE_ABOVE_ME), 
-                                                            Vec3.multiply(Quat.getFront(MyAvatar.orientation), DISTANCE_IN_FRONT_OF_ME)));
-        
         // Update all the butterflies
+        var CHANCE_OF_IMPULSE = 0.04;
         for (var i = 0; i < numButterflies; i++) {
-            entityID = Entities.identifyEntity(butterflies[i].entityID);
-            butterflies[i].entityID = entityID;
-            var properties = Entities.getEntityProperties(entityID);
-			
-    		if (properties.position.y > flockPosition.y + getRandomFloat(0.0,0.3)){ //0.3  //ceiling
-                properties.gravity.y = - 3.0;
-                properties.damping.y = 1.0;
-                properties.velocity.y = 0;
-                properties.velocity.x = properties.velocity.x;
-                properties.velocity.z = properties.velocity.z;	
-                if (properties.velocity.x < 0.5){ 
-                    butterflies[i].moving = false;
+            if (Math.random() < CHANCE_OF_IMPULSE) {
+                if (!butterflies[i].isKnownID) {
+                    butterflies[i] = Entities.identifyEntity(butterflies[i]);
                 }
-                if (properties.velocity.z < 0.5){ 
-                    butterflies[i].moving = false;
-                }				
-			}
-			
-			if (properties.velocity.y <= -0.2) {
-                properties.velocity.y = 0.22;		
-                properties.velocity.x = properties.velocity.x;
-                properties.velocity.z = properties.velocity.z;
-			}
-			
-			if (properties.position.y < flockPosition.y - getRandomFloat(0.0,0.3)) { //-0.3   // floor
-                properties.velocity.y = 0.9;
-                properties.gravity.y = - 4.0;
-                properties.velocity.x = properties.velocity.x;
-                properties.velocity.z = properties.velocity.z;
-                if (properties.velocity.x < 0.5){ 
-                    butterflies[i].moving = false;
-				}
-                if (properties.velocity.z < 0.5){ 
-                    butterflies[i].moving = false;
-				}			
-			}
-
-
-            // Begin movement by getting a target
-            if (butterflies[i].moving == false) {
-                if (Math.random() < CHANCE_OF_MOVING) {
-                    var targetPosition = Vec3.sum(randVector(-range, range), flockPosition);
-                    if (targetPosition.x < 0) {
-                        targetPosition.x = 0;
-                    }
-                    if (targetPosition.y < 0) {
-                        targetPosition.y = 0;
-                    }
-                    if (targetPosition.z < 0) {
-                        targetPosition.z = 0;
-                    }
-                    if (targetPosition.x > TREE_SCALE) {
-                        targetPosition.x = TREE_SCALE;
-                    }
-                    if (targetPosition.y > TREE_SCALE) {
-                        targetPosition.y = TREE_SCALE;
-                    }
-                    if (targetPosition.z > TREE_SCALE) {
-                        targetPosition.z = TREE_SCALE;
-                    }
-                    butterflies[i].targetPosition = targetPosition;
-                    butterflies[i].moving = true;
+                var properties = Entities.getEntityProperties(butterflies[i]);
+                if (Vec3.length(Vec3.subtract(properties.position, flockPosition)) > range) {
+                    Entities.editEntity(butterflies[i], { position: flockPosition } );
+                } else if (properties.velocity.y < 0.0) {
+                    //  If falling, Create a new direction and impulse
+                    var HORIZ_SCALE = 0.50;
+                    var VERT_SCALE = 0.50;
+                    var newHeading = Math.random() * 360.0;  
+                    var newVelocity = Vec3.multiply(HORIZ_SCALE, Quat.getFront(Quat.fromPitchYawRollDegrees(0.0, newHeading, 0.0))); 
+                    newVelocity.y = (Math.random() + 0.5) * VERT_SCALE;
+                    Entities.editEntity(butterflies[i], { rotation: Quat.fromPitchYawRollDegrees(-80 + Math.random() * 20, newHeading, (Math.random() - 0.5) * 10), 
+                                                    velocity: newVelocity } );
                 }
             }
-			  
-            // If we are moving, move towards the target
-            if (butterflies[i].moving) {	
-			
-				var	holding = properties.velocity.y;
-			
-                var desiredVelocity = Vec3.subtract(butterflies[i].targetPosition, properties.position);
-                desiredVelocity = vScalarMult(Vec3.normalize(desiredVelocity), BUTTERFLY_VELOCITY);
-		   
-				properties.velocity = vInterpolate(properties.velocity, desiredVelocity, 0.5);
-				properties.velocity.y = holding ;
-			
-			
-                // If we are near the target, we should get a new target
-                var halfLargestDimension = Vec3.length(properties.dimensions) / 2.0;
-                if (Vec3.length(Vec3.subtract(properties.position, butterflies[i].targetPosition)) < (halfLargestDimension)) {
-                    butterflies[i].moving = false;
-                }
-				
-				var yawRads = Math.atan2(properties.velocity.z, properties.velocity.x); 
-				yawRads = yawRads + Math.PI / 2.0;
-				var	newOrientation = Quat.fromPitchYawRollRadians(pitchInRadians, yawRads, rollInRadians);
-				properties.rotation = newOrientation;
-			}
-
-            // Use a cosine wave offset to make it look like its flapping.
-            var offset = Math.cos(nowTimeInSeconds * BUTTERFLY_FLAP_SPEED) * (halfLargestDimension);
-            properties.position.y = properties.position.y + (offset - butterflies[i].previousFlapOffset);
-            // Change position relative to previous offset.
-            butterflies[i].previousFlapOffset = offset;
-            Entities.editEntity(entityID, properties);
+        }
+        // Check to see if we've been running long enough that our butterflies are dead
+        var nowTimeInSeconds = new Date().getTime() / 1000;
+        if ((nowTimeInSeconds - startTimeInSeconds) >= lifeTime) {
+            Script.stop();
+            return;
         }
     }
 }
@@ -237,6 +136,6 @@ Script.update.connect(updateButterflies);
 //  Delete our little friends if script is stopped
 Script.scriptEnding.connect(function() {
     for (var i = 0; i < numButterflies; i++) {
-        Entities.deleteEntity(butterflies[i].entityID);
+        Entities.deleteEntity(butterflies[i]);
     }
 });

examples/developerMenuItems.js

@@ -19,14 +19,17 @@ function setupMenus() {
     if (!Menu.menuExists("Developer > Entities")) {
         Menu.addMenu("Developer > Entities");
         Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Display Model Bounds", isCheckable: true, isChecked: false });
+        Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Display Model Triangles", isCheckable: true, isChecked: false });
         Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Display Model Element Bounds", isCheckable: true, isChecked: false });
         Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Display Model Element Children", isCheckable: true, isChecked: false });
-        Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Disable Light Entities", isCheckable: true, isChecked: false });
+        Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Don't Do Precision Picking", isCheckable: true, isChecked: false });
         Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Don't Attempt to Reduce Material Switches", isCheckable: true, isChecked: false });
         Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Don't Attempt Render Entities as Scene", isCheckable: true, isChecked: false });
+        Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Don't Do Precision Picking", isCheckable: true, isChecked: false });
         Menu.addMenu("Developer > Entities > Culling");
         Menu.addMenuItem({ menuName: "Developer > Entities > Culling", menuItemName: "Don't Cull Out Of View Mesh Parts", isCheckable: true, isChecked: false });
         Menu.addMenuItem({ menuName: "Developer > Entities > Culling", menuItemName: "Don't Cull Too Small Mesh Parts", isCheckable: true, isChecked: false });
+        Menu.addMenuItem({ menuName: "Developer > Entities", menuItemName: "Disable Light Entities", isCheckable: true, isChecked: false });
     }
 }
 

examples/editModels.js

@@ -2554,7 +2554,7 @@ function mousePressEvent(event) {
 
         var pickRay = Camera.computePickRay(event.x, event.y);
         Vec3.print("[Mouse] Looking at: ", pickRay.origin);
-        var foundIntersection = Entities.findRayIntersection(pickRay);
+        var foundIntersection = Entities.findRayIntersection(pickRay, true); // we want precision picking here
 
         if(!foundIntersection.accurate) {
             return;

examples/headMove.js

@@ -11,6 +11,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+var gamepads = {};
+
 var debug = false;
 var willMove = false;
 
@@ -19,7 +21,6 @@ var warpPosition = { x: 0, y: 0, z: 0 };
 
 var hipsToEyes;
 var restoreCountdownTimer;
-var headTurningTimer = 0.0;
 
 //  Overlays to show target location 
 
@@ -62,13 +63,6 @@ function restoreCameraState() {
     Camera.mode = oldMode;
 }
 
-function activateWarp() {
-    if (warpActive) return;
-    warpActive = true;
-
-    updateWarp();
-}
-
 var WATCH_AVATAR_DISTANCE = 2.5;
 
 var sound = SoundCache.getSound("http://public.highfidelity.io/sounds/Footsteps/FootstepW2Right-12db.wav");
@@ -132,6 +126,22 @@ function updateWarp() {
     });
 }
 
+function activateWarp() {
+    if (warpActive) return;
+    warpActive = true;
+    movingWithHead = true;
+    hipsToEyes = MyAvatar.getEyePosition().y - MyAvatar.position.y;
+    headStartPosition = MyAvatar.getTrackedHeadPosition();
+    headStartDeltaPitch = MyAvatar.getHeadDeltaPitch();
+    headStartFinalPitch = MyAvatar.getHeadFinalPitch();
+    headStartRoll = MyAvatar.getHeadFinalRoll();
+    headStartYaw = MyAvatar.getHeadFinalYaw();
+    deltaYaw = 0.0;
+    warpPosition = MyAvatar.position;
+    warpPosition.y += hipsToEyes; 
+    updateWarp();
+}
+
 function finishWarp() {
     if (!warpActive) return;
     warpActive = false;
@@ -152,6 +162,9 @@ function finishWarp() {
         cameraPosition = Vec3.subtract(MyAvatar.position, Vec3.multiplyQbyV(Camera.getOrientation(), { x: 0, y: -hipsToEyes, z: -hipsToEyes * WATCH_AVATAR_DISTANCE }));
         Camera.setPosition(cameraPosition);
         playSound();
+        if (watchAvatar) {
+            restoreCountdownTimer = RESTORE_TIME;
+        }
     } 
 }
 
@@ -169,35 +182,11 @@ function update(deltaTime) {
             restoreCountDownTimer = 0.0;
         }
     }
-    var HEAD_TURN_TIME = 0.10;
-    var HEAD_TURN_DEGREES = 4.0; 
-    var HEAD_TURN_START_ANGLE = 45.0;
-    var currentYaw = MyAvatar.getHeadFinalYaw();
-    if (Math.abs(currentYaw) > HEAD_TURN_START_ANGLE) {
-        headTurningTimer += deltaTime;
-        if (headTurningTimer > HEAD_TURN_TIME) {
-            headTurningTimer = 0.0;
-            MyAvatar.orientation = Quat.multiply(Quat.fromPitchYawRollDegrees(0, (currentYaw > 0) ? HEAD_TURN_DEGREES: -HEAD_TURN_DEGREES, 0), 
-                                                 MyAvatar.orientation);
-        }
-    } else {
-        headTurningTimer = 0.0;
-    }
 }
 
 Controller.keyPressEvent.connect(function(event) {
     if (event.text == "SPACE" && !event.isAutoRepeat && !movingWithHead) {
         keyDownTime = 0.0;
-        movingWithHead = true;
-        hipsToEyes = MyAvatar.getEyePosition().y - MyAvatar.position.y;
-        headStartPosition = MyAvatar.getTrackedHeadPosition();
-        headStartDeltaPitch = MyAvatar.getHeadDeltaPitch();
-        headStartFinalPitch = MyAvatar.getHeadFinalPitch();
-        headStartRoll = MyAvatar.getHeadFinalRoll();
-        headStartYaw = MyAvatar.getHeadFinalYaw();
-        deltaYaw = 0.0;
-        warpPosition = MyAvatar.position;
-        warpPosition.y += hipsToEyes; 
         activateWarp();
     }
 });
@@ -223,11 +212,40 @@ Controller.keyReleaseEvent.connect(function(event) {
         }
         timeSinceLastUp = 0.0;
         finishWarp();
-        if (watchAvatar) {
-            restoreCountdownTimer = RESTORE_TIME;
-        }
     }
 });
 
+function reportButtonValue(button, newValue, oldValue) {
+    if (button == Joysticks.BUTTON_FACE_RIGHT) {
+        if (newValue) {
+            activateWarp();
+        } else {
+            finishWarp();
+        }
+    }
+}
+
 Script.update.connect(update);
 
+function addJoystick(gamepad) {
+    gamepad.buttonStateChanged.connect(reportButtonValue);
+
+    gamepads[gamepad.instanceId] = gamepad;
+
+    print("Added gamepad: " + gamepad.name + " (" + gamepad.instanceId + ")");
+}
+
+function removeJoystick(gamepad) {
+    delete gamepads[gamepad.instanceId]
+
+    print("Removed gamepad: " + gamepad.name + " (" + gamepad.instanceId + ")");
+}
+
+var allJoysticks = Joysticks.getAllJoysticks();
+for (var i = 0; i < allJoysticks.length; i++) {
+    addJoystick(allJoysticks[i]);
+}
+
+Joysticks.joystickAdded.connect(addJoystick);
+Joysticks.joystickRemoved.connect(removeJoystick);
+

examples/html/entityProperties.html

@@ -103,13 +103,14 @@
             var elIgnoreForCollisions = document.getElementById("property-ignore-for-collisions");
             var elCollisionsWillMove = document.getElementById("property-collisions-will-move");
             var elLifetime = document.getElementById("property-lifetime");
+            var elScriptURL = document.getElementById("property-script-url");
 
-            var elBoxSection = document.getElementById("box-section");
+            var elBoxSections = document.querySelectorAll(".box-section");
             var elBoxColorRed = document.getElementById("property-box-red");
             var elBoxColorGreen = document.getElementById("property-box-green");
             var elBoxColorBlue = document.getElementById("property-box-blue");
 
-            var elLightSection = document.getElementById('light-section');
+            var elLightSections = document.querySelectorAll(".light-section");
             var elLightSpotLight = document.getElementById("property-light-spot-light");
             var elLightDiffuseRed = document.getElementById("property-light-diffuse-red");
             var elLightDiffuseGreen = document.getElementById("property-light-diffuse-green");
@@ -129,14 +130,14 @@
             var elLightExponent = document.getElementById("property-light-exponent");
             var elLightCutoff = document.getElementById("property-light-cutoff");
 
-            var elModelSection = document.getElementById("model-section");
+            var elModelSections = document.querySelectorAll(".model-section");
             var elModelURL = document.getElementById("property-model-url");
             var elModelAnimationURL = document.getElementById("property-model-animation-url");
             var elModelAnimationPlaying = document.getElementById("property-model-animation-playing");
             var elModelAnimationFPS = document.getElementById("property-model-animation-fps");
             var elModelAnimationFrame = document.getElementById("property-model-animation-frame");
 
-            var elTextSection = document.getElementById("text-section");
+            var elTextSections = document.querySelectorAll(".text-section");
             var elTextText = document.getElementById("property-text-text");
             var elTextLineHeight = document.getElementById("property-text-line-height");
             var elTextTextColorRed = document.getElementById("property-text-text-color-red");
@@ -160,102 +161,120 @@
                             elLocked.checked = properties.locked;
 
                             if (properties.locked) {
-                                disableChildren(document.getElementById("properties"), 'input');
+                                disableChildren(document.getElementById("properties-table"), 'input');
                                 elLocked.removeAttribute('disabled');
                             } else {
-                                enableChildren(document.getElementById("properties"), 'input');
+                                enableChildren(document.getElementById("properties-table"), 'input');
+                            }
 
-                                elVisible.checked = properties.visible;
+                            elVisible.checked = properties.visible;
 
-                                elPositionX.value = properties.position.x.toFixed(2);
-                                elPositionY.value = properties.position.y.toFixed(2);
-                                elPositionZ.value = properties.position.z.toFixed(2);
+                            elPositionX.value = properties.position.x.toFixed(2);
+                            elPositionY.value = properties.position.y.toFixed(2);
+                            elPositionZ.value = properties.position.z.toFixed(2);
 
-                                elDimensionsX.value = properties.dimensions.x.toFixed(2);
-                                elDimensionsY.value = properties.dimensions.y.toFixed(2);
-                                elDimensionsZ.value = properties.dimensions.z.toFixed(2);
+                            elDimensionsX.value = properties.dimensions.x.toFixed(2);
+                            elDimensionsY.value = properties.dimensions.y.toFixed(2);
+                            elDimensionsZ.value = properties.dimensions.z.toFixed(2);
 
-                                elRegistrationX.value = properties.registrationPoint.x.toFixed(2);
-                                elRegistrationY.value = properties.registrationPoint.y.toFixed(2);
-                                elRegistrationZ.value = properties.registrationPoint.z.toFixed(2);
+                            elRegistrationX.value = properties.registrationPoint.x.toFixed(2);
+                            elRegistrationY.value = properties.registrationPoint.y.toFixed(2);
+                            elRegistrationZ.value = properties.registrationPoint.z.toFixed(2);
 
-                                elLinearVelocityX.value = properties.velocity.x.toFixed(2);
-                                elLinearVelocityY.value = properties.velocity.y.toFixed(2);
-                                elLinearVelocityZ.value = properties.velocity.z.toFixed(2);
-                                elLinearDamping.value = properties.damping.toFixed(2);
+                            elLinearVelocityX.value = properties.velocity.x.toFixed(2);
+                            elLinearVelocityY.value = properties.velocity.y.toFixed(2);
+                            elLinearVelocityZ.value = properties.velocity.z.toFixed(2);
+                            elLinearDamping.value = properties.damping.toFixed(2);
 
-                                elAngularVelocityX.value = properties.angularVelocity.x.toFixed(2);
-                                elAngularVelocityY.value = properties.angularVelocity.y.toFixed(2);
-                                elAngularVelocityZ.value = properties.angularVelocity.z.toFixed(2);
-                                elAngularDamping.value = properties.angularDamping.toFixed(2);
+                            elAngularVelocityX.value = properties.angularVelocity.x.toFixed(2);
+                            elAngularVelocityY.value = properties.angularVelocity.y.toFixed(2);
+                            elAngularVelocityZ.value = properties.angularVelocity.z.toFixed(2);
+                            elAngularDamping.value = properties.angularDamping.toFixed(2);
 
-                                elGravityX.value = properties.gravity.x.toFixed(2);
-                                elGravityY.value = properties.gravity.y.toFixed(2);
-                                elGravityZ.value = properties.gravity.z.toFixed(2);
+                            elGravityX.value = properties.gravity.x.toFixed(2);
+                            elGravityY.value = properties.gravity.y.toFixed(2);
+                            elGravityZ.value = properties.gravity.z.toFixed(2);
 
-                                elMass.value = properties.mass.toFixed(2);
-                                elIgnoreForCollisions.checked = properties.ignoreForCollisions;
-                                elCollisionsWillMove.checked = properties.collisionsWillMove;
-                                elLifetime.value = properties.lifetime;
+                            elMass.value = properties.mass.toFixed(2);
+                            elIgnoreForCollisions.checked = properties.ignoreForCollisions;
+                            elCollisionsWillMove.checked = properties.collisionsWillMove;
+                            elLifetime.value = properties.lifetime;
+                            elScriptURL.value = properties.script;
 
-                                if (properties.type != "Box") {
-                                    elBoxSection.style.display = 'none';
-                                } else {
-                                    elBoxSection.style.display = 'block';
-
-                                    elBoxColorRed.value = properties.color.red;
-                                    elBoxColorGreen.value = properties.color.green;
-                                    elBoxColorBlue.value = properties.color.blue;
+                            if (properties.type != "Box") {
+                                for (var i = 0; i < elBoxSections.length; i++) {
+                                    elBoxSections[i].style.display = 'none';
+                                }
+                            } else {
+                                for (var i = 0; i < elBoxSections.length; i++) {
+                                    elBoxSections[i].style.display = 'table-row';
                                 }
 
-                                if (properties.type != "Model") {
-                                    elModelSection.style.display = 'none';
-                                } else {
-                                    elModelSection.style.display = 'block';
-                                    elModelURL.value = properties.modelURL; 
-                                    elModelAnimationURL.value = properties.animationURL;
-                                    elModelAnimationPlaying.checked = properties.animationIsPlaying;
-                                    elModelAnimationFPS.value = properties.animationFPS;
+                                elBoxColorRed.value = properties.color.red;
+                                elBoxColorGreen.value = properties.color.green;
+                                elBoxColorBlue.value = properties.color.blue;
+                            }
+
+                            if (properties.type != "Model") {
+                                for (var i = 0; i < elModelSections.length; i++) {
+                                    elModelSections[i].style.display = 'none';
+                                }
+                            } else {
+                                for (var i = 0; i < elModelSections.length; i++) {
+                                    elModelSections[i].style.display = 'table-row';
                                 }
 
-                                if (properties.type != "Text") {
-                                    elTextSection.style.display = 'none';
-                                } else {
-                                    elTextSection.style.display = 'block';
+                                elModelURL.value = properties.modelURL;
+                                elModelAnimationURL.value = properties.animationURL;
+                                elModelAnimationPlaying.checked = properties.animationIsPlaying;
+                                elModelAnimationFPS.value = properties.animationFPS;
+                            }
 
-                                    elTextText.value = properties.text; 
-                                    elTextLineHeight.value = properties.lineHeight;
-                                    elTextTextColorRed.value = properties.textColor.red;
-                                    elTextTextColorGreen.value = properties.textColor.green;
-                                    elTextTextColorBlue.value = properties.textColor.blue;
-                                    elTextBackgroundColorRed.value = properties.backgroundColor.red;
-                                    elTextBackgroundColorGreen.value = properties.backgroundColor.green;
-                                    elTextBackgroundColorBlue.value = properties.backgroundColor.blue;
+                            if (properties.type != "Text") {
+                                for (var i = 0; i < elTextSections.length; i++) {
+                                    elTextSections[i].style.display = 'none';
+                                }
+                            } else {
+                                for (var i = 0; i < elTextSections.length; i++) {
+                                    elTextSections[i].style.display = 'table-row';
                                 }
 
-                                if (properties.type != "Light") {
-                                    elLightSection.style.display = 'none';
-                                } else {
-                                    elLightSection.style.display = 'block';
+                                elTextText.value = properties.text;
+                                elTextLineHeight.value = properties.lineHeight;
+                                elTextTextColorRed.value = properties.textColor.red;
+                                elTextTextColorGreen.value = properties.textColor.green;
+                                elTextTextColorBlue.value = properties.textColor.blue;
+                                elTextBackgroundColorRed.value = properties.backgroundColor.red;
+                                elTextBackgroundColorGreen.value = properties.backgroundColor.green;
+                                elTextBackgroundColorBlue.value = properties.backgroundColor.blue;
+                            }
 
-                                    elLightDiffuseRed.value = properties.diffuseColor.red;
-                                    elLightDiffuseGreen.value = properties.diffuseColor.green;
-                                    elLightDiffuseBlue.value = properties.diffuseColor.blue;
-
-                                    elLightAmbientRed.value = properties.ambientColor.red;
-                                    elLightAmbientGreen.value = properties.ambientColor.green;
-                                    elLightAmbientBlue.value = properties.ambientColor.blue;
-
-                                    elLightSpecularRed.value = properties.specularColor.red;
-                                    elLightSpecularGreen.value = properties.specularColor.green;
-                                    elLightSpecularBlue.value = properties.specularColor.blue;
-
-                                    elLightConstantAttenuation.value = properties.constantAttenuation;
-                                    elLightLinearAttenuation.value = properties.linearAttenuation;
-                                    elLightQuadraticAttenuation.value = properties.quadraticAttenuation;
-                                    elLightExponent.value = properties.exponent;
-                                    elLightCutoff.value = properties.cutoff;
+                            if (properties.type != "Light") {
+                                for (var i = 0; i < elLightSections.length; i++) {
+                                    elLightSections[i].style.display = 'none';
                                 }
+                            } else {
+                                for (var i = 0; i < elLightSections.length; i++) {
+                                    elLightSections[i].style.display = 'table-row';
+                                }
+
+                                elLightDiffuseRed.value = properties.diffuseColor.red;
+                                elLightDiffuseGreen.value = properties.diffuseColor.green;
+                                elLightDiffuseBlue.value = properties.diffuseColor.blue;
+
+                                elLightAmbientRed.value = properties.ambientColor.red;
+                                elLightAmbientGreen.value = properties.ambientColor.green;
+                                elLightAmbientBlue.value = properties.ambientColor.blue;
+
+                                elLightSpecularRed.value = properties.specularColor.red;
+                                elLightSpecularGreen.value = properties.specularColor.green;
+                                elLightSpecularBlue.value = properties.specularColor.blue;
+
+                                elLightConstantAttenuation.value = properties.constantAttenuation;
+                                elLightLinearAttenuation.value = properties.linearAttenuation;
+                                elLightQuadraticAttenuation.value = properties.quadraticAttenuation;
+                                elLightExponent.value = properties.exponent;
+                                elLightCutoff.value = properties.cutoff;
                             }
                         }
                     }
@@ -307,6 +326,7 @@
             elIgnoreForCollisions.addEventListener('change', createEmitCheckedPropertyUpdateFunction('ignoreForCollisions'));
             elCollisionsWillMove.addEventListener('change', createEmitCheckedPropertyUpdateFunction('collisionsWillMove'));
             elLifetime.addEventListener('change', createEmitNumberPropertyUpdateFunction('lifetime'));
+            elScriptURL.addEventListener('change', createEmitTextPropertyUpdateFunction('script'));
 
             var boxColorChangeFunction = createEmitColorPropertyUpdateFunction(
                 'color', elBoxColorRed, elBoxColorGreen, elBoxColorBlue);
@@ -345,7 +365,7 @@
             elModelAnimationPlaying.addEventListener('change', createEmitCheckedPropertyUpdateFunction('animationIsPlaying'));
             elModelAnimationFPS.addEventListener('change', createEmitNumberPropertyUpdateFunction('animationFPS'));
             elModelAnimationFrame.addEventListener('change', createEmitNumberPropertyUpdateFunction('animationFrameIndex'));
-            
+
             elTextText.addEventListener('change', createEmitTextPropertyUpdateFunction('text'));
             elTextLineHeight.addEventListener('change', createEmitNumberPropertyUpdateFunction('lineHeight'));
 
@@ -361,6 +381,50 @@
             elTextBackgroundColorGreen.addEventListener('change', textBackgroundColorChangeFunction);
             elTextBackgroundColorBlue.addEventListener('change', textBackgroundColorChangeFunction);
 
+
+            var resizing = false;
+            var startX = 0;
+            var originalWidth = 0;
+            var resizeHandleWidth = 10;
+
+            var col1 = document.querySelector("#col-label");
+
+            document.body.addEventListener('mousemove', function(event) {
+                if (resizing) {
+                    var dX = event.x - startX;
+                    col1.style.width = (originalWidth + dX) + "px";
+                }
+            });
+            document.body.addEventListener('mouseup', function(event) {
+                resizing = false;
+            });
+            document.body.addEventListener('mouseleave', function(event) {
+                resizing = false;
+            });
+            var els = document.querySelectorAll("#properties-table td");
+            for (var i = 0; i < els.length; i++) {
+                var el = els[i];
+                el.addEventListener('mousemove', function(event) {
+                    if (!resizing) {
+                        var distance = this.offsetWidth - event.offsetX;
+                        if (distance < resizeHandleWidth) {
+                            document.body.style.cursor = "ew-resize";
+                        } else {
+                            document.body.style.cursor = "initial";
+                        }
+                    }
+                });
+                el.addEventListener('mousedown', function(event) {
+                    var distance = this.offsetWidth - event.offsetX;
+                    if (distance < resizeHandleWidth) {
+                        startX = event.x;
+                        originalWidth = this.offsetWidth;
+                        resizing = true;
+                        target = this;
+                    }
+                });
+            }
+
         }
     </script>
 </head>
@@ -368,272 +432,267 @@
     <div class="section-header">
         <label>Entity Properties</label>
     </div>
-    <div id="properties" class="grid-section">
-        <div class="property-section">
-            <label>Type</label>
-            <span>
-                <label id="property-type"></input>
-            </span>
-        </div>
-
-        <div class="property-section">
-            <label>Locked</label>
-            <span>
+    <table id="properties-table">
+        <colgroup>
+            <col id="col-label">
+            <col>
+        </colgroup>
+        <tr>
+            <td class="label">
+                Type
+            </td>
+            <td>
+                <label id="property-type"></label>
+            </td>
+        </tr>
+        <tr>
+            <td class="label">Locked</td>
+            <td>
                 <input type='checkbox' id="property-locked">
-            </span>
-        </div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Visible</label>
-            <span>
+        <tr>
+            <td class="label">Visible</td>
+            <td>
                 <input type='checkbox' id="property-visible">
-            </span>
-        </div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Position</label>
-            <span>
-                X <input class="coord" type='number' id="property-pos-x"></input>
-                Y <input class="coord" type='number' id="property-pos-y"></input>
-                Z <input class="coord" type='number' id="property-pos-z"></input>
-            </span>
-        </div>
+        <tr>
+            <td class="label">Position</td>
+            <td>
+                <div class="input-area">X <input class="coord" type='number' id="property-pos-x"></input></div>
+                <div class="input-area">Y <input class="coord" type='number' id="property-pos-y"></input></div>
+                <div class="input-area">Z <input class="coord" type='number' id="property-pos-z"></input></div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Registration</label>
-            <span>
-                X <input class="coord" type='number' id="property-reg-x"></input>
-                Y <input class="coord" type='number' id="property-reg-y"></input>
-                Z <input class="coord" type='number' id="property-reg-z"></input>
-            </span>
-        </div>
+        <tr>
+            <td class="label">Registration</td>
+            <td>
+                <div class="input-area">X <input class="coord" type='number' id="property-reg-x"></input></div>
+                <div class="input-area">Y <input class="coord" type='number' id="property-reg-y"></input></div>
+                <div class="input-area">Z <input class="coord" type='number' id="property-reg-z"></input></div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Width</label>
-            <span>
-                <input class="coord" type='number' id="property-dim-x"></input>
-            </span>
-        </div>
-        <div class="property-section">
-            <label>Height</label>
-            <span>
-                <input class="coord" type='number' id="property-dim-y"></input>
-            </span>
-        </div>
-        <div class="property-section">
-            <label>Depth</label>
-            <span>
-                <input class="coord" type='number' id="property-dim-z"></input>
-            </span>
-        </div>
+        <tr>
+            <td class="label">Dimensions</td>
+            <td>
+                <div class="input-area">X <input class="coord" type='number' id="property-dim-x"></input></div>
+                <div class="input-area">Y <input class="coord" type='number' id="property-dim-y"></input></div>
+                <div class="input-area">Z <input class="coord" type='number' id="property-dim-z"></input></div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Linear</label>
-            <span>
-                X <input class="coord" type='number' id="property-lvel-x"></input>
-                Y <input class="coord" type='number' id="property-lvel-y"></input>
-                Z <input class="coord" type='number' id="property-lvel-z"></input>
-            </span>
-        </div>
-        <div class="property-section">
-            <label>Linear Damping</label>
-            <span>
+        <tr>
+            <td class="label">Linear Velocity</td>
+            <td>
+                <div class="input-area">X <input class="coord" type='number' id="property-lvel-x"></input></div>
+                <div class="input-area">Y <input class="coord" type='number' id="property-lvel-y"></input></div>
+                <div class="input-area">Z <input class="coord" type='number' id="property-lvel-z"></input></div>
+            </td>
+        </tr>
+        <tr>
+            <td class="label">Linear Damping</td>
+            <td>
                 <input class="coord" type='number' id="property-ldamping"></input>
-            </span>
-        </div>
-        <div class="property-section">
-            <label>Angular</label>
-            <span>
-                Pitch <input class="coord" type='number' id="property-avel-x"></input>
-                Roll <input class="coord" type='number' id="property-avel-z"></input>
-                Yaw <input class="coord" type='number' id="property-avel-y"></input>
-            </span>
-        </div>
-        <div class="property-section">
-            <label>Angular Damping</label>
-            <span>
+            </td>
+        </tr>
+        <tr>
+            <td class="label">Angular Velocity</td>
+            <td>
+                <div class="input-area">Pitch <input class="coord" type='number' id="property-avel-x"></input></div>
+                <div class="input-area">Yaw <input class="coord" type='number' id="property-avel-y"></input></div>
+                <div class="input-area">Roll <input class="coord" type='number' id="property-avel-z"></input></div>
+            </td>
+        </tr>
+        <tr>
+            <td class="label">Angular Damping</td>
+            <td>
                 <input class="coord" type='number' id="property-adamping"></input>
-            </span>
-        </div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Gravity</label>
-            <span>
-                X <input class="coord" type='number' id="property-grav-x"></input>
-                Y <input class="coord" type='number' id="property-grav-y"></input>
-                Z <input class="coord" type='number' id="property-grav-z"></input>
-            </span>
-        </div>
+        <tr>
+            <td class="label">Gravity</td>
+            <td>
+                <div class="input-area">X <input class="coord" type='number' id="property-grav-x"></input></div>
+                <div class="input-area">Y <input class="coord" type='number' id="property-grav-y"></input></div>
+                <div class="input-area">Z <input class="coord" type='number' id="property-grav-z"></input></div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Mass</label>
-            <span>
+        <tr>
+            <td class="label">Mass</td>
+            <td>
                 <input type='number' id="property-mass"></input>
-            </span>
-        </div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Ignore For Collisions</label>
-            <span>
+        <tr>
+            <td class="label">Ignore For Collisions</td>
+            <td>
                 <input type='checkbox' id="property-ignore-for-collisions"></input>
-            </span>
-        </div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Collisions Will Move</label>
-            <span>
+        <tr>
+            <td class="label">Collisions Will Move</td>
+            <td>
                 <input type='checkbox' id="property-collisions-will-move"></input>
-            </span>
-        </div>
+            </td>
+        </tr>
 
-        <div class="property-section">
-            <label>Lifetime</label>
-            <span>
+        <tr>
+            <td class="label">Lifetime</td>
+            <td>
                 <input type='number' id="property-lifetime"></input>
-            </span>
-        </div>
+            </td>
+        </tr>
+
+        <tr>
+            <td class="label">Script URL</td>
+            <td>
+                <input id="property-script-url"></input>
+            </td>
+        </tr>
 
 
-        <div id="box-section" class="multi-property-section">
-            <div class="property-section">
-                <label>Color</label>
-                <span>
-                    Red <input class="coord" type='number' id="property-box-red"></input>
-                    Green <input class="coord" type='number' id="property-box-green"></input>
-                    Blue <input class="coord" type='number' id="property-box-blue"></input>
-                </span>
-            </div>
-        </div>
+        <tr class="box-section">
+            <td class="label">Color</td>
+            <td>
+                <div class="input-area">R <input class="coord" type='number' id="property-box-red"></input></div>
+                <div class="input-area">G <input class="coord" type='number' id="property-box-green"></input></div>
+                <div class="input-area">B <input class="coord" type='number' id="property-box-blue"></input></div>
+            </td>
+        </tr>
 
 
-        <div id="model-section" class="multi-property-section">
-            <div class="property-section">
-                <label>Model URL</label>
-                <span>
-                    <input type="text" id="property-model-url"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Animation URL</label>
-                <span>
-                    <input type="text" id="property-model-animation-url"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Animation Playing</label>
-                <span>
-                    <input type='checkbox' id="property-model-animation-playing">
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Animation FPS</label>
-                <span>
-                    <input class="coord" type='number' id="property-model-animation-fps"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Animation Frame</label>
-                <span>
-                    <input class="coord" type='number' id="property-model-animation-frame"></input>
-                </span>
-            </div>
-        </div>
 
-        <div id="text-section" class="multi-property-section">
-            <div class="property-section">
-                <label>Text</label>
-                <span>
-                    <input type="text" id="property-text-text"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Line Height</label>
-                <span>
-                    <input class="coord" type='number' id="property-text-line-height"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Text Color</label>
-                <span>
-                    Red <input class="coord" type='number' id="property-text-text-color-red"></input>
-                    Green <input class="coord" type='number' id="property-text-text-color-green"></input>
-                    Blue <input class="coord" type='number' id="property-text-text-color-blue"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Background Color</label>
-                <span>
-                    Red <input class="coord" type='number' id="property-text-background-color-red"></input>
-                    Green <input class="coord" type='number' id="property-text-background-color-green"></input>
-                    Blue <input class="coord" type='number' id="property-text-background-color-blue"></input>
-                </span>
-            </div>
-        </div>
+        <tr class="model-section">
+            <td class="label">Model URL</td>
+            <td>
+                <input type="text" id="property-model-url"></input>
+            </td>
+        </tr>
+        <tr class="model-section">
+            <td class="label">Animation URL</td>
+            <td>
+                <input type="text" id="property-model-animation-url"></input>
+            </td>
+        </tr>
+        <tr class="model-section">
+            <td class="label">Animation Playing</td>
+            <td>
+                <input type='checkbox' id="property-model-animation-playing">
+            </td>
+        </tr>
+        <tr class="model-section">
+            <td class="label">Animation FPS</td>
+            <td>
+                <input class="coord" type='number' id="property-model-animation-fps"></input>
+            </td>
+        </tr>
+        <tr class="model-section">
+            <td class="label">Animation Frame</td>
+            <td>
+                <input class="coord" type='number' id="property-model-animation-frame"></input>
+            </td>
+        </tr>
 
 
-        <div id="light-section" class="multi-property-section">
-            <div class="property-section">
-                <label>Spot Light</label>
-                <span>
-                    <input type='checkbox' id="property-light-spot-light">
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Diffuse</label>
-                <span>
-                    Red <input class="coord" type='number' id="property-light-diffuse-red"></input>
-                    Green <input class="coord" type='number' id="property-light-diffuse-green"></input>
-                    Blue <input class="coord" type='number' id="property-light-diffuse-blue"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Ambient</label>
-                <span>
-                    Red <input class="coord" type='number' id="property-light-ambient-red"></input>
-                    Green <input class="coord" type='number' id="property-light-ambient-green"></input>
-                    Blue <input class="coord" type='number' id="property-light-ambient-blue"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Specular</label>
-                <span>
-                    Red <input class="coord" type='number' id="property-light-specular-red"></input>
-                    Green <input class="coord" type='number' id="property-light-specular-green"></input>
-                    Blue <input class="coord" type='number' id="property-light-specular-blue"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Constant Attenuation</label>
-                <span>
-                    <input class="coord" type='number' id="property-light-constant-attenuation"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Linear Attenuation</label>
-                <span>
-                    <input class="coord" type='number' id="property-light-linear-attenuation"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Quadratic Attenuation</label>
-                <span>
-                    <input class="coord" type='number' id="property-light-quadratic-attenuation"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Exponent</label>
-                <span>
-                    <input class="coord" type='number' id="property-light-exponent"></input>
-                </span>
-            </div>
-            <div class="property-section">
-                <label>Cutoff (degrees)</label>
-                <span>
-                    <input class="coord" type='number' id="property-light-cutoff"></input>
-                </span>
-            </div>
-        </div>
-    </div>
+        <tr class="text-section">
+            <td class="label">Text</td>
+            <td>
+                <input type="text" id="property-text-text"></input>
+            </td>
+        </tr>
+        <tr class="text-section">
+            <td class="label">Line Height</td>
+            <td>
+                <input class="coord" type='number' id="property-text-line-height"></input>
+            </td>
+        </tr>
+        <tr class="text-section">
+            <td class="label">Text Color</td>
+            <td>
+                <div class="input-area">R <input class="coord" type='number' id="property-text-text-color-red"></input></div>
+                <div class="input-area">G <input class="coord" type='number' id="property-text-text-color-green"></input></div>
+                <div class="input-area">B <input class="coord" type='number' id="property-text-text-color-blue"></input></div>
+            </td>
+        </tr>
+        <tr class="text-section">
+            <td class="label">Background Color</td>
+            <td>
+                <div class="input-area">R <input class="coord" type='number' id="property-text-background-color-red"></input></div>
+                <div class="input-area">G <input class="coord" type='number' id="property-text-background-color-green"></input></div>
+                <div class="input-area">B <input class="coord" type='number' id="property-text-background-color-blue"></input></div>
+            </td>
+        </tr>
+
+        <tr class="light-section">
+            <td class="label">Spot Light</td>
+            <td>
+                <input type='checkbox' id="property-light-spot-light">
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Diffuse</td>
+            <td>
+                <div class="input-area">R <input class="coord" type='number' id="property-light-diffuse-red"></input></div>
+                <div class="input-area">G <input class="coord" type='number' id="property-light-diffuse-green"></input></div>
+                <div class="input-area">B <input class="coord" type='number' id="property-light-diffuse-blue"></input></div>
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Ambient</td>
+            <td>
+                <div class="input-area">R <input class="coord" type='number' id="property-light-ambient-red"></input></div>
+                <div class="input-area">G <input class="coord" type='number' id="property-light-ambient-green"></input></div>
+                <div class="input-area">B <input class="coord" type='number' id="property-light-ambient-blue"></input></div>
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Specular</td>
+            <td>
+                <div class="input-area">R <input class="coord" type='number' id="property-light-specular-red"></input></div>
+                <div class="input-area">G <input class="coord" type='number' id="property-light-specular-green"></input></div>
+                <div class="input-area">B <input class="coord" type='number' id="property-light-specular-blue"></input></div>
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Constant Attenuation</td>
+            <td>
+                <input class="coord" type='number' id="property-light-constant-attenuation"></input>
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Linear Attenuation</td>
+            <td>
+                <input class="coord" type='number' id="property-light-linear-attenuation"></input>
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Quadratic Attenuation</td>
+            <td>
+                <input class="coord" type='number' id="property-light-quadratic-attenuation"></input>
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Exponent</td>
+            <td>
+                <input class="coord" type='number' id="property-light-exponent"></input>
+            </td>
+        </tr>
+        <tr class="light-section">
+            <td class="label">Cutoff (degrees)</td>
+            <td>
+                <input class="coord" type='number' id="property-light-cutoff"></input>
+            </td>
+        </tr>
+    </table>
 
 </body>
 </html>

examples/html/style.css

@@ -17,15 +17,6 @@ body {
     user-select: none;
 }
 
-input {
-    line-height: 2;
-}
-
-.input-left {
-    display: inline-block;
-    width: 20px;
-}
-
 .color-box {
     display: inline-block;
     width: 20px;
@@ -63,7 +54,6 @@ input {
 
 .property-section label {
     font-weight: bold;
-    vertical-align: middle;
 }
 
 .property-section span {
@@ -89,9 +79,10 @@ input[type=button] {
     font-size: .9em;
 }
 
-input.coord {
-    width: 6em;
-    height: 2em;
+input {
+    padding: 2px;
+    border: 1px solid #999;
+    background-color: #eee;
 }
 
 table#entity-table {
@@ -105,7 +96,7 @@ table#entity-table {
     cursor: pointer;
 }
 
-tr.selected {
+#entity-table tr.selected {
     background-color: #AAA;
 }
 
@@ -130,3 +121,48 @@ th#entity-type {
 
 th#entity-url {
 }
+
+
+div.input-area {
+    display: inline-block;
+}
+
+input {
+}
+
+
+
+table#properties-table {
+    border: none;
+    border-collapse: collapse;
+    width: 100%;
+    background-color: #efefef;
+    font-family: Arial;
+    font-size: 12px;
+    table-layout: fixed;
+}
+
+#properties-table tr {
+    border-bottom: 1px solid #e5e5e5;
+}
+
+#properties-table td.label {
+    padding-right: 10px;
+    border-right: 1px solid #999;
+    text-align: right;
+    font-weight: bold;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+
+    vertical-align: middle;
+    height: 1.2em;
+}
+
+#properties-table td {
+    padding: 5px 0px 5px 10px;
+}
+
+col#col-label {
+    width: 130px;
+}

examples/libraries/entitySelectionTool.js

@@ -1772,17 +1772,27 @@ SelectionDisplay = (function () {
                 var centerToZero = Vec3.subtract(center, zero);
                 var centerToIntersect = Vec3.subtract(center, result.intersection);
                 var angleFromZero = Vec3.orientedAngle(centerToZero, centerToIntersect, rotationNormal);
-                
                 var distanceFromCenter = Vec3.distance(center, result.intersection);
                 var snapToInner = distanceFromCenter < innerRadius;
                 var snapAngle = snapToInner ? innerSnapAngle : 1.0;
-                angleFromZero = Math.floor(angleFromZero / snapAngle) * snapAngle;
-                
+
                 // for debugging
                 if (debug) {
                     Vec3.print("    result.intersection:",result.intersection);
                     Overlays.editOverlay(rotateCurrentOverlay, { visible: true, start: center,  end: result.intersection });
+                    Vec3.print("    centerToZero:", centerToZero);
+                    Vec3.print("    centerToIntersect:", centerToIntersect);
+                    Vec3.print("    rotationNormal:", rotationNormal);
                     print("    angleFromZero:" + angleFromZero);
+                    print("    distanceFromCenter:" + distanceFromCenter);
+                    print("    snapAngle:" + snapAngle);
+                }
+                
+                angleFromZero = Math.floor(angleFromZero / snapAngle) * snapAngle;
+                
+                // for debugging
+                if (debug) {
+                    print("    angleFromZero:" + angleFromZero + " --- after snap");
                 }
 
                 var yawChange = Quat.fromVec3Degrees({ x: 0, y: angleFromZero, z: 0 });

examples/newEditEntities.js

@@ -465,7 +465,7 @@ function rayPlaneIntersection(pickRay, point, normal) {
 function findClickedEntity(event) {
     var pickRay = Camera.computePickRay(event.x, event.y);
 
-    var foundIntersection = Entities.findRayIntersection(pickRay);
+    var foundIntersection = Entities.findRayIntersection(pickRay, true); // want precision picking
 
     if (!foundIntersection.accurate) {
         return null;

examples/orbitingSound.js

@@ -0,0 +1,45 @@
+//
+//  orbitingSound.js
+//  examples
+//
+//  Created by Philip Rosedale on December 4, 2014
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  An object playing a sound appears and circles you, changing brightness with the audio playing.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+var RADIUS = 2.0;
+var orbitCenter = Vec3.sum(Camera.position, Vec3.multiply(Quat.getFront(Camera.getOrientation()), RADIUS));
+var time = 0;
+var SPEED = 1.0;
+var currentPosition = { x: 0, y: 0, z: 0 };
+var trailingLoudness = 0.0;
+
+var soundClip = SoundCache.getSound("https://s3.amazonaws.com/hifi-public/sounds/Tabla+Loops/Tabla1.wav");
+
+var properties = { 
+        type: "Box",
+        position: orbitCenter, 
+        dimensions: { x: 0.25, y: 0.25, z: 0.25 },
+        color: { red: 100, green: 0, blue : 0 }
+    };
+
+var objectId = Entities.addEntity(properties);
+var sound = Audio.playSound(soundClip, { position: orbitCenter, loop: true, volume: 0.5 });
+
+function update(deltaTime) { 
+    time += deltaTime; 
+    currentPosition = { x: orbitCenter.x + Math.cos(time * SPEED) * RADIUS, y: orbitCenter.y, z: orbitCenter.z + Math.sin(time * SPEED) * RADIUS };
+    trailingLoudness = 0.9 * trailingLoudness + 0.1 * Audio.getLoudness(sound);
+    Entities.editEntity( objectId, { position: currentPosition, color: { red: Math.min(trailingLoudness * 2000, 255), green: 0, blue: 0 } } );
+    Audio.setInjectorOptions(sound, { position: currentPosition });
+}
+
+Script.scriptEnding.connect(function() {
+    Entities.deleteEntity(objectId);
+    Audio.stopInjector(sound);
+});
+
+Script.update.connect(update);

examples/virtualKeyboard.js

@@ -0,0 +1,598 @@
+//
+//  virtualKeyboard.js
+//  examples
+//
+//  Created by Thijs Wenker on 11/18/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Control a virtual keyboard using your favorite HMD.
+//  Usage: Enable VR-mode and go to First person mode,
+//  look at the key that you would like to press, and press the spacebar on your "REAL" keyboard.
+//
+//  leased some code from newEditEntities.js for Text Entity example
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+Script.include("libraries/globals.js");
+
+const KBD_UPPERCASE_DEFAULT = 0;
+const KBD_LOWERCASE_DEFAULT = 1;
+const KBD_UPPERCASE_HOVER   = 2;
+const KBD_LOWERCASE_HOVER   = 3;
+const KBD_BACKGROUND        = 4;
+
+const KEYBOARD_URL = HIFI_PUBLIC_BUCKET + "images/keyboard.svg";
+const CURSOR_URL = HIFI_PUBLIC_BUCKET + "images/cursor.svg";
+
+const SPACEBAR_CHARCODE = 32;
+
+const KEYBOARD_WIDTH  = 1174.7;
+const KEYBOARD_HEIGHT = 434.1;
+
+const CURSOR_WIDTH = 33.9;
+const CURSOR_HEIGHT = 33.9;
+
+// VIEW_ANGLE can be adjusted to your likings, the smaller the faster movement.
+// Try setting it to 60 if it goes too fast for you.
+const VIEW_ANGLE = 40.0;
+const VIEW_ANGLE_BY_TWO = VIEW_ANGLE / 2;
+
+const SPAWN_DISTANCE = 1;
+const DEFAULT_TEXT_DIMENSION_Z = 0.02;
+
+const BOUND_X = 0;
+const BOUND_Y = 1;
+const BOUND_W = 2;
+const BOUND_H = 3;
+
+const KEY_STATE_LOWER = 0;
+const KEY_STATE_UPPER = 1;
+
+const TEXT_MARGIN_TOP = 0.15;
+const TEXT_MARGIN_LEFT = 0.15;
+const TEXT_MARGIN_RIGHT = 0.17;
+const TEXT_MARGIN_BOTTOM = 0.17;
+
+var windowDimensions = Controller.getViewportDimensions();
+var cursor = null;
+var keyboard = new Keyboard();
+var textFontSize = 9;
+var text = null;
+var textText = "";
+var textSizeMeasureOverlay = Overlays.addOverlay("text3d", {visible: false});
+
+function appendChar(char) {
+    textText += char;
+    updateTextOverlay();
+    Overlays.editOverlay(text, {text: textText});
+}
+
+function deleteChar() {
+    if (textText.length > 0) {
+        textText = textText.substring(0, textText.length - 1);
+        updateTextOverlay();
+    }
+}
+
+function updateTextOverlay() {
+    var textLines = textText.split("\n");
+    var maxLineWidth = 0;
+    for (textLine in textLines) {
+        var lineWidth = Overlays.textWidth(text, textLines[textLine]);
+        if (lineWidth > maxLineWidth) {
+            maxLineWidth = lineWidth;
+        }
+    }
+    var suggestedFontSize = (windowDimensions.x / maxLineWidth) * textFontSize * 0.90;
+    var maxFontSize = 190 / textLines.length;
+    textFontSize = (suggestedFontSize > maxFontSize) ? maxFontSize : suggestedFontSize;
+    var topMargin = (250 - (textFontSize * textLines.length)) / 4;
+    Overlays.editOverlay(text, {text: textText, font: {size: textFontSize}, topMargin: topMargin});
+    var maxLineWidth = 0;
+    for (textLine in textLines) {
+        var lineWidth = Overlays.textWidth(text, textLines[textLine]);
+        if (lineWidth > maxLineWidth) {
+            maxLineWidth = lineWidth;
+        }
+    }
+    Overlays.editOverlay(text, {leftMargin: (windowDimensions.x - maxLineWidth) / 2});
+}
+
+keyboard.onKeyPress = function(event) {
+    if (event.event == 'keypress') {
+        appendChar(event.char);
+    } else if (event.event == 'enter') {
+        appendChar("\n");
+    }
+};
+
+keyboard.onKeyRelease = function(event) {
+    print("Key release event test");
+    // you can cancel a key by releasing its focusing before releasing it
+    if (event.focus) {
+        if (event.event == 'delete') {
+           deleteChar();
+        } else if (event.event == 'submit') {
+           print(textText);
+
+           var position = Vec3.sum(MyAvatar.position, Vec3.multiply(Quat.getFront(MyAvatar.orientation), SPAWN_DISTANCE));
+
+           var textLines = textText.split("\n");
+           var maxLineWidth = 0;
+           for (textLine in textLines) {
+               var lineWidth = Overlays.textWidth(textSizeMeasureOverlay, textLines[textLine]);
+               if (lineWidth > maxLineWidth) {
+                   maxLineWidth = lineWidth;
+               }
+           }
+           var usernameLine = "--" + GlobalServices.myUsername;
+           var usernameWidth = Overlays.textWidth(textSizeMeasureOverlay, usernameLine);
+           if (maxLineWidth < usernameWidth) {
+               maxLineWidth = usernameWidth;
+           } else {
+               var spaceableWidth = maxLineWidth - usernameWidth;
+               var spaceWidth = Overlays.textWidth(textSizeMeasureOverlay, " ");
+               var numberOfSpaces = Math.floor(spaceableWidth / spaceWidth);
+               for (var i = 0; i < numberOfSpaces; i++) {
+                   usernameLine = " " + usernameLine;
+               }
+           }
+           var dimension_x = maxLineWidth + TEXT_MARGIN_RIGHT + TEXT_MARGIN_LEFT;
+           if (position.x > 0 && position.y > 0 && position.z > 0) {
+               Entities.addEntity({ 
+                   type: "Text",
+                   rotation: MyAvatar.orientation,
+                   position: position,
+                   dimensions: { x: dimension_x, y: (textLines.length + 1) * 0.14 + TEXT_MARGIN_TOP + TEXT_MARGIN_BOTTOM, z: DEFAULT_TEXT_DIMENSION_Z },
+                   backgroundColor: { red: 0, green: 0, blue: 0 },
+                   textColor: { red: 255, green: 255, blue: 255 },
+                   text: textText + "\n" + usernameLine
+               });
+           }
+           textText = "";
+           updateTextOverlay();
+        }
+    }
+};
+
+keyboard.onFullyLoaded = function() {
+    print("Virtual-keyboard fully loaded.");
+    var dimensions = Controller.getViewportDimensions();
+    text = Overlays.addOverlay("text", {
+         x: 0,
+         y: dimensions.y - keyboard.height() - 260,
+         width: dimensions.x,
+         height: 250,
+         backgroundColor: { red: 255, green: 255, blue: 255},
+         color: { red: 0, green: 0, blue: 0},
+         topMargin: 5,
+         leftMargin: 0,
+         font: {size: textFontSize},
+         text: "",
+         alpha: 0.8
+    });
+    updateTextOverlay();
+    // the cursor is being loaded after the keyboard, else it will be on the background of the keyboard 
+    cursor = new Cursor();
+    cursor.onUpdate = function(position) {
+        keyboard.setFocusPosition(position.x, position.y);
+    };
+};
+
+function KeyboardKey(keyboard, keyProperties) {
+    var tthis = this;
+    this._focus = false;
+    this._beingPressed = false;
+    this.event = keyProperties.event != undefined ?
+        keyProperties.event : 'keypress';
+    this.bounds = keyProperties.bounds;
+    this.states = keyProperties.states;
+    this.keyboard = keyboard;
+    this.keyState = keyProperties.keyState != undefined ? keyProperties.keyState : KBD_LOWERCASE_DEFAULT;
+    // one overlay per bound vector [this.bounds]
+    this.overlays = [];
+    this.getKeyEvent = function() {
+        if (tthis.event == 'keypress') {
+            var state = tthis.states[(tthis.keyboard.shift ? 1 : 2) % tthis.states.length];
+            return {key: state.charCode, char: state.char, event: tthis.event, focus: tthis._focus};
+        }
+        return {event: tthis.event, focus: tthis._focus};
+    };
+    this.containsCoord = function(x, y) {
+        for (var i = 0; i < this.bounds.length; i++) {
+             if (x >= this.bounds[i][BOUND_X] &&
+                 x <= (this.bounds[i][BOUND_X] + this.bounds[i][BOUND_W]) &&
+                 y >= this.bounds[i][BOUND_Y] &&
+                 y <= (this.bounds[i][BOUND_Y] + this.bounds[i][BOUND_H]))
+             {
+                 return true;
+             }
+        }
+        return false;
+    };
+    this.updateState = function() {
+        tthis.setState(eval('KBD_' + (tthis.keyboard.shift ? 'UPPERCASE' : 'LOWERCASE') + '_' + (tthis._focus ? 'HOVER' : 'DEFAULT')));
+    };
+    this.updateColor = function() {
+        var colorIntensity = this._beingPressed ? 128 : 255;
+        for (var i = 0; i < tthis.bounds.length; i++) {
+             Overlays.editOverlay(tthis.overlays[i], 
+                 {color: {red: colorIntensity, green: colorIntensity, blue: colorIntensity}}
+             );
+        }
+    };
+    this.press = function() {
+        tthis._beingPressed = true;
+        tthis.updateColor();
+    };
+    this.release = function() {
+        tthis._beingPressed = false;
+        tthis.updateColor();
+    };
+    this.blur = function() {
+        tthis._focus = false;
+        tthis.updateState();
+    };
+    this.focus = function() {
+        tthis._focus = true;
+        tthis.updateState();
+    };
+    this.setState = function(state) {
+        tthis.keyState = state;
+        for (var i = 0; i < tthis.bounds.length; i++) {
+             Overlays.editOverlay(tthis.overlays[i], {
+                 subImage: {width: tthis.bounds[i][BOUND_W], height: tthis.bounds[i][BOUND_H], x: tthis.bounds[i][BOUND_X], y: (KEYBOARD_HEIGHT * tthis.keyState) + tthis.bounds[i][BOUND_Y]}
+             });
+        }
+    };
+    this.rescale = function() {
+        for (var i = 0; i < tthis.bounds.length; i++) {
+             Overlays.editOverlay(tthis.overlays[i], {
+                 x: tthis.keyboard.getX() + tthis.bounds[i][BOUND_X] * keyboard.scale,
+                 y: tthis.keyboard.getY() + tthis.bounds[i][BOUND_Y] * keyboard.scale,
+                 width: this.bounds[i][BOUND_W] * keyboard.scale,
+                 height: this.bounds[i][BOUND_H] * keyboard.scale
+             });
+        }
+    };
+    this.remove = function() {
+        for (var i = 0; i < this.overlays.length; i++) {
+             Overlays.deleteOverlay(this.overlays[i]);
+        }
+    };
+    this.isLoaded = function() {
+        for (var i = 0; i < this.overlays.length; i++) {
+             if (!Overlays.isLoaded(this.overlays[i])) {
+                 return false;
+             }
+        }
+        return true;
+    };
+    for (var i = 0; i < this.bounds.length; i++) {
+        var newOverlay = Overlays.cloneOverlay(this.keyboard.background);
+        Overlays.editOverlay(newOverlay, {
+            x: this.keyboard.getX() + this.bounds[i][BOUND_X] * keyboard.scale,
+            y: this.keyboard.getY() + this.bounds[i][BOUND_Y] * keyboard.scale,
+            width: this.bounds[i][BOUND_W] * keyboard.scale,
+            height: this.bounds[i][BOUND_H] * keyboard.scale,
+            subImage: {width: this.bounds[i][BOUND_W], height: this.bounds[i][BOUND_H], x: this.bounds[i][BOUND_X], y: (KEYBOARD_HEIGHT * this.keyState) + this.bounds[i][BOUND_Y]},
+            alpha: 1
+        });
+        this.overlays.push(newOverlay);
+    }
+}
+
+function Keyboard() {
+    var tthis = this;
+    this.focussed_key = -1;
+    this.scale = windowDimensions.x / KEYBOARD_WIDTH;
+    this.shift = false;
+    this.width = function() {
+        return KEYBOARD_WIDTH * tthis.scale;
+    };
+    this.height = function() {
+        return KEYBOARD_HEIGHT * tthis.scale;
+    };
+    this.getX = function() {
+        return (windowDimensions.x / 2) - (this.width() / 2);
+    };
+    this.getY = function() {
+        return windowDimensions.y - this.height();
+    };
+    this.background = Overlays.addOverlay("image", {
+        x: this.getX(),
+        y: this.getY(),
+        width: this.width(),
+        height: this.height(),
+        subImage: {width: KEYBOARD_WIDTH, height: KEYBOARD_HEIGHT, y: KEYBOARD_HEIGHT * KBD_BACKGROUND},
+        imageURL: KEYBOARD_URL,
+        alpha: 1
+    });
+    this.rescale = function() {
+        this.scale = windowDimensions.x / KEYBOARD_WIDTH;
+        Overlays.editOverlay(tthis.background, {
+            x: this.getX(),
+            y: this.getY(),
+            width: this.width(),
+            height: this.height()
+        });
+        for (var i = 0; i < tthis.keys.length; i++) {
+            tthis.keys[i].rescale();
+        }
+    };
+
+    this.setFocusPosition = function(x, y) {
+        // set to local unscaled position
+        var localx = (x - tthis.getX()) / tthis.scale;
+        var localy = (y - tthis.getY()) / tthis.scale;
+        var new_focus_key = -1;
+        if (localx >= 0 && localy >= 0 && localx <= KEYBOARD_WIDTH && localy <= KEYBOARD_HEIGHT) {
+            for (var i = 0; i < tthis.keys.length; i++) {
+                if (tthis.keys[i].containsCoord(localx, localy)) {
+                    new_focus_key = i;
+                    break;
+                }
+            }
+        }
+        if (new_focus_key != tthis.focussed_key) {
+            if (tthis.focussed_key != -1) {
+                tthis.keys[tthis.focussed_key].blur();
+            }
+            tthis.focussed_key = new_focus_key;
+            if (tthis.focussed_key != -1) {
+                tthis.keys[tthis.focussed_key].focus();
+            }
+        }
+        return tthis;
+    };
+
+    this.pressFocussedKey = function() {
+        if (tthis.focussed_key != -1) {
+            if (tthis.keys[tthis.focussed_key].event == 'shift') {
+                tthis.toggleShift();
+            } else {
+                tthis.keys[tthis.focussed_key].press();
+            }
+            if (this.onKeyPress != null) {
+                this.onKeyPress(tthis.keys[tthis.focussed_key].getKeyEvent());
+            }
+        }
+
+        return tthis;
+    };
+    
+    this.releaseKeys = function() {
+        for (var i = 0; i < tthis.keys.length; i++) {
+             if (tthis.keys[i]._beingPressed) {
+                 if (tthis.keys[i].event != 'shift') {
+                     tthis.keys[i].release();
+                 }
+                 if (this.onKeyRelease != null) {
+                     this.onKeyRelease(tthis.keys[i].getKeyEvent());
+                 }
+             }
+        }
+    };
+
+    this.toggleShift = function() {
+        tthis.shift = !tthis.shift;
+        for (var i = 0; i < tthis.keys.length; i++) {
+             tthis.keys[i].updateState();
+             if (tthis.keys[i].event == 'shift') {
+                 if (tthis.shift) {
+                     tthis.keys[i].press();
+                     continue;
+                 }
+                 tthis.keys[i].release();
+             }
+        }
+    };
+
+    this.getFocussedKey = function() {
+        if (tthis.focussed_key == -1) {
+            return null;
+        }
+        return tthis.keys[tthis.focussed_key];
+    };
+
+    this.remove = function() {
+        Overlays.deleteOverlay(this.background);
+        for (var i = 0; i < this.keys.length; i++) {
+            this.keys[i].remove();
+        }
+    };
+
+    this.onKeyPress = null;
+    this.onKeyRelease = null;
+    this.onSubmit = null;
+    this.onFullyLoaded = null;
+
+    this.keys = [];
+    //
+    // keyProperties contains the key data
+    //
+    // coords [[x,y,w,h],[x,y,w,h]]
+    // states array of 1 or 2 objects [lowercase, uppercase] each object contains a charCode and a char
+    var keyProperties = [
+        {bounds: [[12, 12, 65, 52]], states: [{charCode: 126, char: '~'}]},
+        {bounds: [[84, 12, 65, 52]], states: [{charCode: 33, char: '!'}]},
+        {bounds: [[156, 12, 65, 52]], states: [{charCode: 64, char: '@'}]},
+        {bounds: [[228, 12, 65, 52]], states: [{charCode: 35, char: '#'}]},
+        {bounds: [[300, 12, 65, 52]], states: [{charCode: 36, char: '$'}]},
+        {bounds: [[372, 12, 65, 52]], states: [{charCode: 37, char: '%'}]},
+        {bounds: [[445, 12, 65, 52]], states: [{charCode: 94, char: '^'}]},
+        {bounds: [[517, 12, 65, 52]], states: [{charCode: 38, char: '&'}]},
+        {bounds: [[589, 12, 65, 52]], states: [{charCode: 42, char: '*'}]},
+        {bounds: [[662, 12, 65, 52]], states: [{charCode: 40, char: '('}]},
+        {bounds: [[734, 12, 65, 52]], states: [{charCode: 41, char: ')'}]},
+        {bounds: [[806, 12, 65, 52]], states: [{charCode: 95, char: '_'}]},
+        {bounds: [[881, 12, 65, 52]], states: [{charCode: 123, char: '{'}]},
+        {bounds: [[953, 12, 65, 52]], states: [{charCode: 125, char: '}'}]},
+        {bounds: [[1025, 12, 65, 52]], states: [{charCode: 60, char: '<'}]},
+        {bounds: [[1097, 12, 65, 52]], states: [{charCode: 62, char: '>'}]},
+
+        {bounds: [[12, 71, 65, 63]], states: [{charCode: 96, char: '`'}]},
+        {bounds: [[84, 71, 65, 63]], states: [{charCode: 49, char: '1'}]},
+        {bounds: [[156, 71, 65, 63]], states: [{charCode: 50, char: '2'}]},
+        {bounds: [[228, 71, 65, 63]], states: [{charCode: 51, char: '3'}]},
+        {bounds: [[300, 71, 65, 63]], states: [{charCode: 52, char: '4'}]},
+        {bounds: [[372, 71, 65, 63]], states: [{charCode: 53, char: '5'}]},
+        {bounds: [[445, 71, 65, 63]], states: [{charCode: 54, char: '6'}]},
+        {bounds: [[517, 71, 65, 63]], states: [{charCode: 55, char: '7'}]},
+        {bounds: [[589, 71, 65, 63]], states: [{charCode: 56, char: '8'}]},
+        {bounds: [[661, 71, 65, 63]], states: [{charCode: 57, char: '9'}]},
+        {bounds: [[733, 71, 65, 63]], states: [{charCode: 48, char: '0'}]},
+        {bounds: [[806, 71, 65, 63]], states: [{charCode: 45, char: '-'}]},
+        {bounds: [[880, 71, 65, 63]], states: [{charCode: 61, char: '='}]},
+        {bounds: [[953, 71, 65, 63]], states: [{charCode: 43, char: '+'}]},
+        {bounds: [[1024, 71, 139, 63]], event: 'delete'},
+
+        // enter key has 2 bounds and one state
+        {bounds: [[11, 143, 98, 71], [11, 213, 121, 62]], event: 'enter'},
+
+        {bounds: [[118, 142, 64, 63]], states: [{charCode: 113, char: 'q'}, {charCode: 81, char: 'Q'}]},
+        {bounds: [[190, 142, 64, 63]], states: [{charCode: 119, char: 'w'}, {charCode: 87, char: 'W'}]},
+        {bounds: [[262, 142, 64, 63]], states: [{charCode: 101, char: 'e'}, {charCode: 69, char: 'E'}]},
+        {bounds: [[334, 142, 64, 63]], states: [{charCode: 114, char: 'r'}, {charCode: 82, char: 'R'}]},
+        {bounds: [[407, 142, 64, 63]], states: [{charCode: 116, char: 't'}, {charCode: 84, char: 'T'}]},
+        {bounds: [[479, 142, 64, 63]], states: [{charCode: 121, char: 'y'}, {charCode: 89, char: 'Y'}]},
+        {bounds: [[551, 142, 65, 63]], states: [{charCode: 117, char: 'u'}, {charCode: 85, char: 'U'}]},
+        {bounds: [[623, 142, 65, 63]], states: [{charCode: 105, char: 'i'}, {charCode: 73, char: 'I'}]},
+        {bounds: [[695, 142, 65, 63]], states: [{charCode: 111, char: 'o'}, {charCode: 79, char: 'O'}]},
+        {bounds: [[768, 142, 64, 63]], states: [{charCode: 112, char: 'p'}, {charCode: 80, char: 'P'}]},
+        {bounds: [[840, 142, 64, 63]], states: [{charCode: 91, char: '['}]},
+        {bounds: [[912, 142, 65, 63]], states: [{charCode: 93, char: ']'}]},
+        {bounds: [[984, 142, 65, 63]], states: [{charCode: 92, char: '\\'}]},
+        {bounds: [[1055, 142, 65, 63]], states: [{charCode: 124, char: '|'}]},
+        
+        {bounds: [[1126, 143, 35, 72], [1008, 214, 153, 62]], event: 'enter'},
+
+        {bounds: [[140, 213, 65, 63]], states: [{charCode: 97, char: 'a'}, {charCode: 65, char: 'A'}]},
+        {bounds: [[211, 213, 64, 63]], states: [{charCode: 115, char: 's'}, {charCode: 83, char: 'S'}]},
+        {bounds: [[283, 213, 65, 63]], states: [{charCode: 100, char: 'd'}, {charCode: 68, char: 'D'}]},
+        {bounds: [[355, 213, 65, 63]], states: [{charCode: 102, char: 'f'}, {charCode: 70, char: 'F'}]},
+        {bounds: [[428, 213, 64, 63]], states: [{charCode: 103, char: 'g'}, {charCode: 71, char: 'G'}]},
+        {bounds: [[500, 213, 64, 63]], states: [{charCode: 104, char: 'h'}, {charCode: 72, char: 'H'}]},
+        {bounds: [[572, 213, 65, 63]], states: [{charCode: 106, char: 'j'}, {charCode: 74, char: 'J'}]},
+        {bounds: [[644, 213, 65, 63]], states: [{charCode: 107, char: 'k'}, {charCode: 75, char: 'K'}]},
+        {bounds: [[716, 213, 65, 63]], states: [{charCode: 108, char: 'l'}, {charCode: 76, char: 'L'}]},
+        {bounds: [[789, 213, 64, 63]], states: [{charCode: 59, char: ';'}]},
+        {bounds: [[861, 213, 64, 63]], states: [{charCode: 39, char: '\''}]},
+        {bounds: [[934, 213, 65, 63]], states: [{charCode: 58, char: ':'}]},
+
+        {bounds: [[12, 283, 157, 63]], event: 'shift'},
+
+        {bounds: [[176, 283, 65, 63]], states: [{charCode: 122, char: 'z'}, {charCode: 90, char: 'Z'}]},
+        {bounds: [[249, 283, 64, 63]], states: [{charCode: 120, char: 'x'}, {charCode: 88, char: 'X'}]},
+        {bounds: [[321, 283, 64, 63]], states: [{charCode: 99, char: 'c'}, {charCode: 67, char: 'C'}]},
+        {bounds: [[393, 283, 64, 63]], states: [{charCode: 118, char: 'v'}, {charCode: 86, char: 'V'}]},
+        {bounds: [[465, 283, 65, 63]], states: [{charCode: 98, char: 'b'}, {charCode: 66, char: 'B'}]},
+        {bounds: [[537, 283, 65, 63]], states: [{charCode: 110, char: 'n'}, {charCode: 78, char: 'N'}]},
+        {bounds: [[610, 283, 64, 63]], states: [{charCode: 109, char: 'm'}, {charCode: 77, char: 'M'}]},
+        {bounds: [[682, 283, 64, 63]], states: [{charCode: 44, char: ','}]},
+        {bounds: [[754, 283, 65, 63]], states: [{charCode: 46, char: '.'}]},
+        {bounds: [[826, 283, 65, 63]], states: [{charCode: 47, char: '/'}]},
+        {bounds: [[899, 283, 64, 63]], states: [{charCode: 63, char: '?'}]},
+
+        {bounds: [[972, 283, 190, 63]], event: 'shift'},
+
+        {bounds: [[249, 355, 573, 67]], states: [{charCode: 32, char: ' '}]},
+
+        {bounds: [[899, 355, 263, 67]], event: 'submit'}
+    ];
+
+    this.keyboardTextureLoaded = function() {
+        if (Overlays.isLoaded(tthis.background)) {
+            Script.clearInterval(tthis.keyboardTextureLoaded_timer);
+            for (var i = 0; i < keyProperties.length; i++) {
+                tthis.keys.push(new KeyboardKey(tthis, keyProperties[i]));
+            }
+            if (keyboard.onFullyLoaded != null) {
+                tthis.onFullyLoaded();
+            }
+        }
+    };
+    this.keyboardTextureLoaded_timer = Script.setInterval(this.keyboardTextureLoaded, 250);
+}
+
+function Cursor() {
+    var tthis = this;
+    this.x = windowDimensions.x / 2;
+    this.y = windowDimensions.y / 2;
+    this.overlay = Overlays.addOverlay("image", {
+        x: this.x,
+        y: this.y,
+        width: CURSOR_WIDTH,
+        height: CURSOR_HEIGHT,
+        imageURL: CURSOR_URL,
+        alpha: 1
+    });
+    this.remove = function() {
+        Overlays.deleteOverlay(this.overlay);
+    };
+    this.getPosition = function() {
+        return {x: tthis.getX(), y: tthis.getY()};
+    };
+    this.getX = function() {
+        return tthis.x;
+    };
+    this.getY = function() {
+        return tthis.y;
+    };
+    this.onUpdate = null;
+    this.update = function() {
+        var newWindowDimensions = Controller.getViewportDimensions();
+        if (newWindowDimensions.x != windowDimensions.x || newWindowDimensions.y != windowDimensions.y) {
+            windowDimensions = newWindowDimensions;
+            keyboard.rescale();
+            Overlays.editOverlay(text, {
+                y: windowDimensions.y - keyboard.height() - 260,
+                width: windowDimensions.x
+            });
+        }
+        var editobject = {};
+        if (MyAvatar.getHeadFinalYaw() <= VIEW_ANGLE_BY_TWO && MyAvatar.getHeadFinalYaw() >= -1 * VIEW_ANGLE_BY_TWO) {
+             angle = ((-1 * MyAvatar.getHeadFinalYaw()) + VIEW_ANGLE_BY_TWO) / VIEW_ANGLE;
+             tthis.x = angle * windowDimensions.x;
+             editobject.x = tthis.x - (CURSOR_WIDTH / 2);
+        }
+        if (MyAvatar.getHeadFinalPitch() <= VIEW_ANGLE_BY_TWO && MyAvatar.getHeadFinalPitch() >= -1 * VIEW_ANGLE_BY_TWO) {
+             angle = ((-1 * MyAvatar.getHeadFinalPitch()) + VIEW_ANGLE_BY_TWO) / VIEW_ANGLE;
+             tthis.y = angle * windowDimensions.y;
+             editobject.y = tthis.y - (CURSOR_HEIGHT / 2);
+        }
+        if (Object.keys(editobject).length > 0) {
+            Overlays.editOverlay(tthis.overlay, editobject);
+            if (tthis.onUpdate != null) {
+                tthis.onUpdate(tthis.getPosition());
+            } 
+        }
+    };
+    Script.update.connect(this.update);
+}
+
+function keyPressEvent(event) {
+    if (event.key === SPACEBAR_CHARCODE) {
+        keyboard.pressFocussedKey();
+    }
+}
+
+function keyReleaseEvent(event) {
+    if (event.key === SPACEBAR_CHARCODE) {
+        keyboard.releaseKeys();
+    }
+}
+
+function scriptEnding() {
+    keyboard.remove();
+    cursor.remove();
+    Overlays.deleteOverlay(text);
+    Overlays.deleteOverlay(textSizeMeasureOverlay);
+    Controller.releaseKeyEvents({key: SPACEBAR_CHARCODE});
+}
+Controller.captureKeyEvents({key: SPACEBAR_CHARCODE});
+Controller.keyPressEvent.connect(keyPressEvent);
+Controller.keyReleaseEvent.connect(keyReleaseEvent);
+Script.scriptEnding.connect(scriptEnding);

interface/CMakeLists.txt

@@ -107,7 +107,7 @@ endif()
 add_executable(${TARGET_NAME} MACOSX_BUNDLE ${INTERFACE_SRCS} ${QM})
 
 # link required hifi libraries
-link_hifi_libraries(shared octree voxels fbx metavoxels networking entities avatars audio animation script-engine physics)
+link_hifi_libraries(shared octree voxels gpu fbx metavoxels networking entities avatars audio animation script-engine physics)
 
 # find any optional and required libraries
 find_package(ZLIB REQUIRED)

interface/src/Application.cpp

@@ -165,8 +165,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
         _scaleMirror(1.0f),
         _rotateMirror(0.0f),
         _raiseMirror(0.0f),
-        _mouseX(0),
-        _mouseY(0),
         _lastMouseMove(usecTimestampNow()),
         _lastMouseMoveWasSimulated(false),
         _mouseHidden(false),
@@ -1132,7 +1130,7 @@ void Application::keyPressEvent(QKeyEvent* event) {
                 if (!event->isAutoRepeat()) {
                     // this starts an HFActionEvent
                     HFActionEvent startActionEvent(HFActionEvent::startType(),
-                                                   _viewFrustum.computePickRay(0.5f, 0.5f));
+                                                   _myCamera.computeViewPickRay(0.5f, 0.5f));
                     sendEvent(this, &startActionEvent);
                 }
                 
@@ -1223,7 +1221,7 @@ void Application::keyReleaseEvent(QKeyEvent* event) {
         case Qt::Key_Space: {
             if (!event->isAutoRepeat()) {
                 // this ends the HFActionEvent
-                HFActionEvent endActionEvent(HFActionEvent::endType(), _viewFrustum.computePickRay(0.5f, 0.5f));
+                HFActionEvent endActionEvent(HFActionEvent::endType(), _myCamera.computeViewPickRay(0.5f, 0.5f));
                 sendEvent(this, &endActionEvent);
             }
             
@@ -1254,7 +1252,6 @@ void Application::focusOutEvent(QFocusEvent* event) {
 }
 
 void Application::mouseMoveEvent(QMouseEvent* event, unsigned int deviceID) {
-
     bool showMouse = true;
 
     // Used by application overlay to determine how to draw cursor(s)
@@ -1283,13 +1280,9 @@ void Application::mouseMoveEvent(QMouseEvent* event, unsigned int deviceID) {
         _mouseHidden = false;
         _seenMouseMove = true;
     }
-
-    _mouseX = event->x();
-    _mouseY = event->y();
 }
 
 void Application::mousePressEvent(QMouseEvent* event, unsigned int deviceID) {
-
     if (!_aboutToQuit) {
         _entities.mousePressEvent(event, deviceID);
     }
@@ -1304,20 +1297,20 @@ void Application::mousePressEvent(QMouseEvent* event, unsigned int deviceID) {
 
     if (activeWindow() == _window) {
         if (event->button() == Qt::LeftButton) {
-            _mouseX = event->x();
-            _mouseY = event->y();
-            _mouseDragStartedX = _mouseX;
-            _mouseDragStartedY = _mouseY;
+            _mouseDragStartedX = getTrueMouseX();
+            _mouseDragStartedY = getTrueMouseY();
             _mousePressed = true;
-
-            if (_audio.mousePressEvent(_mouseX, _mouseY)) {
-                // stop propagation
-                return;
-            }
-
-            if (_rearMirrorTools->mousePressEvent(_mouseX, _mouseY)) {
-                // stop propagation
-                return;
+            
+            if (mouseOnScreen()) {
+                if (_audio.mousePressEvent(getMouseX(), getMouseY())) {
+                    // stop propagation
+                    return;
+                }
+                
+                if (_rearMirrorTools->mousePressEvent(getMouseX(), getMouseY())) {
+                    // stop propagation
+                    return;
+                }
             }
             
             // nobody handled this - make it an action event on the _window object
@@ -1346,15 +1339,14 @@ void Application::mouseReleaseEvent(QMouseEvent* event, unsigned int deviceID) {
 
     if (activeWindow() == _window) {
         if (event->button() == Qt::LeftButton) {
-            _mouseX = event->x();
-            _mouseY = event->y();
             _mousePressed = false;
             
-            checkBandwidthMeterClick();
-            if (Menu::getInstance()->isOptionChecked(MenuOption::Stats)) {
+            if (Menu::getInstance()->isOptionChecked(MenuOption::Stats) && mouseOnScreen()) {
                 // let's set horizontal offset to give stats some margin to mirror
                 int horizontalOffset = MIRROR_VIEW_WIDTH;
-                Stats::getInstance()->checkClick(_mouseX, _mouseY, _mouseDragStartedX, _mouseDragStartedY, horizontalOffset);
+                Stats::getInstance()->checkClick(getMouseX(), getMouseY(),
+                                                 getMouseDragStartedX(), getMouseDragStartedY(), horizontalOffset);
+                checkBandwidthMeterClick();
             }
             
             // fire an action end event
@@ -1547,13 +1539,13 @@ void Application::idle() {
 
 void Application::checkBandwidthMeterClick() {
     // ... to be called upon button release
-
     if (Menu::getInstance()->isOptionChecked(MenuOption::Bandwidth) &&
         Menu::getInstance()->isOptionChecked(MenuOption::Stats) &&
         Menu::getInstance()->isOptionChecked(MenuOption::UserInterface) &&
-        glm::compMax(glm::abs(glm::ivec2(_mouseX - _mouseDragStartedX, _mouseY - _mouseDragStartedY)))
-            <= BANDWIDTH_METER_CLICK_MAX_DRAG_LENGTH
-            && _bandwidthMeter.isWithinArea(_mouseX, _mouseY, _glWidget->width(), _glWidget->height())) {
+        glm::compMax(glm::abs(glm::ivec2(getMouseX() - getMouseDragStartedX(),
+                                         getMouseY() - getMouseDragStartedY())))
+        <= BANDWIDTH_METER_CLICK_MAX_DRAG_LENGTH
+        && _bandwidthMeter.isWithinArea(getMouseX(), getMouseY(), _glWidget->width(), _glWidget->height())) {
 
         // The bandwidth meter is visible, the click didn't get dragged too far and
         // we actually hit the bandwidth meter
@@ -1667,6 +1659,48 @@ glm::vec3 Application::getMouseVoxelWorldCoordinates(const VoxelDetail& mouseVox
         (mouseVoxel.z + mouseVoxel.s / 2.0f) * TREE_SCALE);
 }
 
+bool Application::mouseOnScreen() const {
+    if (OculusManager::isConnected()) {
+        return getMouseX() >= 0 && getMouseX() <= _glWidget->getDeviceWidth() &&
+               getMouseY() >= 0 && getMouseY() <= _glWidget->getDeviceHeight();
+    }
+    return true;
+}
+
+int Application::getMouseX() const {
+    if (OculusManager::isConnected()) {
+        glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseX(), getTrueMouseY()));
+        return pos.x;
+    }
+    return getTrueMouseX();
+}
+
+int Application::getMouseY() const {
+    if (OculusManager::isConnected()) {
+        glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseX(), getTrueMouseY()));
+        return pos.y;
+    }
+    return getTrueMouseY();
+}
+
+int Application::getMouseDragStartedX() const {
+    if (OculusManager::isConnected()) {
+        glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseDragStartedX(),
+                                                                      getTrueMouseDragStartedY()));
+        return pos.x;
+    }
+    return getTrueMouseDragStartedX();
+}
+
+int Application::getMouseDragStartedY() const {
+    if (OculusManager::isConnected()) {
+        glm::vec2 pos = _applicationOverlay.screenToOverlay(glm::vec2(getTrueMouseDragStartedX(),
+                                                                      getTrueMouseDragStartedY()));
+        return pos.y;
+    }
+    return getTrueMouseDragStartedY();
+}
+
 FaceTracker* Application::getActiveFaceTracker() {
     return (_dde.isActive() ? static_cast<FaceTracker*>(&_dde) :
             (_faceshift.isActive() ? static_cast<FaceTracker*>(&_faceshift) :
@@ -1897,10 +1931,6 @@ void Application::init() {
     _voxelShader.init();
     _pointShader.init();
 
-    _mouseX = _glWidget->width() / 2;
-    _mouseY = _glWidget->height() / 2;
-    QCursor::setPos(_mouseX, _mouseY);
-
     // TODO: move _myAvatar out of Application. Move relevant code to MyAvataar or AvatarManager
     _avatarManager.init();
     _myCamera.setMode(CAMERA_MODE_FIRST_PERSON);
@@ -2077,11 +2107,13 @@ void Application::updateMouseRay() {
     // if the mouse pointer isn't visible, act like it's at the center of the screen
     float x = 0.5f, y = 0.5f;
     if (!_mouseHidden) {
-        x = _mouseX / (float)_glWidget->width();
-        y = _mouseY / (float)_glWidget->height();
+        x = getTrueMouseX() / (float)_glWidget->width();
+        y = getTrueMouseY() / (float)_glWidget->height();
     }
-    _viewFrustum.computePickRay(x, y, _mouseRayOrigin, _mouseRayDirection);
-
+    PickRay pickRay = _myCamera.computeViewPickRay(x, y);
+    _mouseRayOrigin = pickRay.origin;
+    _mouseRayDirection = pickRay.direction;
+    
     // adjust for mirroring
     if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {
         glm::vec3 mouseRayOffset = _mouseRayOrigin - _viewFrustum.getPosition();
@@ -2310,7 +2342,20 @@ void Application::update(float deltaTime) {
         _prioVR.update(deltaTime);
 
     }
-
+    
+    static QCursor cursor;
+    if (OculusManager::isConnected() &&
+        Menu::getInstance()->isOptionChecked(MenuOption::EnableVRMode)){
+        if (_window->cursor().shape() != Qt::BlankCursor) {
+            qDebug() << "Hiding cursor" << _window->cursor().shape();
+            cursor = _window->cursor();
+            _window->setCursor(QCursor(Qt::BlankCursor));
+        }
+    } else if(_window->cursor().shape() == Qt::BlankCursor) {
+        qDebug() << "Showing cursor" << _window->cursor().shape();
+        _window->setCursor(cursor);
+    }
+    
     // Dispatch input events
     _controllerScriptingInterface.updateInputControllers();
 
@@ -2910,7 +2955,7 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly, RenderAr
     // transform by eye offset
 
     // load the view frustum
-    loadViewFrustum(whichCamera, _viewFrustum);
+    loadViewFrustum(whichCamera, _displayViewFrustum);
 
     // flip x if in mirror mode (also requires reversing winding order for backface culling)
     if (whichCamera.getMode() == CAMERA_MODE_MIRROR) {
@@ -3184,7 +3229,7 @@ void Application::computeOffAxisFrustum(float& left, float& right, float& bottom
     float& farVal, glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const {
 
     // allow 3DTV/Oculus to override parameters from camera
-    _viewFrustum.computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
+    _displayViewFrustum.computeOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
     if (OculusManager::isConnected()) {
         OculusManager::overrideOffAxisFrustum(left, right, bottom, top, nearVal, farVal, nearClipPlane, farClipPlane);
     
@@ -3513,9 +3558,6 @@ void Application::deleteVoxelAt(const VoxelDetail& voxel) {
 }
 
 void Application::resetSensors() {
-    _mouseX = _glWidget->width() / 2;
-    _mouseY = _glWidget->height() / 2;
-
     _faceshift.reset();
     _visage.reset();
     _dde.reset();
@@ -3528,7 +3570,7 @@ void Application::resetSensors() {
     QScreen* currentScreen = _window->windowHandle()->screen();
     QWindow* mainWindow = _window->windowHandle();
     QPoint windowCenter = mainWindow->geometry().center();
-    QCursor::setPos(currentScreen, windowCenter);
+    _glWidget->cursor().setPos(currentScreen, windowCenter);
     
     _myAvatar->reset();
 

interface/src/Application.h

@@ -196,6 +196,7 @@ public:
     const AudioReflector* getAudioReflector() const { return &_audioReflector; }
     Camera* getCamera() { return &_myCamera; }
     ViewFrustum* getViewFrustum() { return &_viewFrustum; }
+    ViewFrustum* getDisplayViewFrustum() { return &_displayViewFrustum; }
     ViewFrustum* getShadowViewFrustum() { return &_shadowViewFrustum; }
     VoxelImporter* getVoxelImporter() { return &_voxelImporter; }
     VoxelSystem* getVoxels() { return &_voxels; }
@@ -213,8 +214,15 @@ public:
     bool isMouseHidden() const { return _mouseHidden; }
     const glm::vec3& getMouseRayOrigin() const { return _mouseRayOrigin; }
     const glm::vec3& getMouseRayDirection() const { return _mouseRayDirection; }
-    int getMouseX() const { return _mouseX; }
-    int getMouseY() const { return _mouseY; }
+    bool mouseOnScreen() const;
+    int getMouseX() const;
+    int getMouseY() const;
+    int getTrueMouseX() const { return _glWidget->mapFromGlobal(QCursor::pos()).x(); }
+    int getTrueMouseY() const { return _glWidget->mapFromGlobal(QCursor::pos()).y(); }
+    int getMouseDragStartedX() const;
+    int getMouseDragStartedY() const;
+    int getTrueMouseDragStartedX() const { return _mouseDragStartedX; }
+    int getTrueMouseDragStartedY() const { return _mouseDragStartedY; }
     bool getLastMouseMoveWasSimulated() const { return _lastMouseMoveWasSimulated;; }
     Faceshift* getFaceshift() { return &_faceshift; }
     Visage* getVisage() { return &_visage; }
@@ -517,6 +525,7 @@ private:
 
     ViewFrustum _viewFrustum; // current state of view frustum, perspective, orientation, etc.
     ViewFrustum _lastQueriedViewFrustum; /// last view frustum used to query octree servers (voxels)
+    ViewFrustum _displayViewFrustum;
     ViewFrustum _shadowViewFrustum;
     quint64 _lastQueriedTime;
 
@@ -554,8 +563,6 @@ private:
 
     Environment _environment;
 
-    int _mouseX;
-    int _mouseY;
     int _mouseDragStartedX;
     int _mouseDragStartedY;
     quint64 _lastMouseMove;

interface/src/Camera.cpp

@@ -97,20 +97,17 @@ void Camera::setFarClip(float f) {
 PickRay Camera::computePickRay(float x, float y) {
     float screenWidth = Application::getInstance()->getGLWidget()->width();
     float screenHeight = Application::getInstance()->getGLWidget()->height();
-    PickRay result;
-    if (OculusManager::isConnected()) {
-        result.origin = getPosition();
-        Application::getInstance()->getApplicationOverlay().computeOculusPickRay(x / screenWidth, y / screenHeight, result.direction);
-    } else {
-        Application::getInstance()->getViewFrustum()->computePickRay(x / screenWidth, y / screenHeight,
-                                                                     result.origin, result.direction);
-    }
-    return result;
+    
+    return computeViewPickRay(x / screenWidth, y / screenHeight);
 }
 
 PickRay Camera::computeViewPickRay(float xRatio, float yRatio) {
     PickRay result;
-    Application::getInstance()->getViewFrustum()->computePickRay(xRatio, yRatio, result.origin, result.direction);
+    if (OculusManager::isConnected()) {
+        Application::getInstance()->getApplicationOverlay().computeOculusPickRay(xRatio, yRatio, result.origin, result.direction);
+    } else {
+        Application::getInstance()->getViewFrustum()->computePickRay(xRatio, yRatio, result.origin, result.direction);
+    }
     return result;
 }
 

interface/src/Menu.h

@@ -367,6 +367,7 @@ namespace MenuOption {
     const QString DontCullTooSmallMeshParts = "Don't Cull Too Small Mesh Parts";
     const QString DontReduceMaterialSwitches = "Don't Attempt to Reduce Material Switches";
     const QString DontRenderEntitiesAsScene = "Don't Render Entities as Scene";
+    const QString DontDoPrecisionPicking = "Don't Do Precision Picking";
     const QString DecreaseAvatarSize = "Decrease Avatar Size";
     const QString DecreaseVoxelSize = "Decrease Voxel Size";
     const QString DisableActivityLogger = "Disable Activity Logger";
@@ -378,6 +379,7 @@ namespace MenuOption {
     const QString DisplayHandTargets = "Show Hand Targets";
     const QString DisplayHermiteData = "Display Hermite Data";
     const QString DisplayModelBounds = "Display Model Bounds";
+    const QString DisplayModelTriangles = "Display Model Triangles";
     const QString DisplayModelElementChildProxies = "Display Model Element Children";
     const QString DisplayModelElementProxy = "Display Model Element Bounds";
     const QString DisplayTimingDetails = "Display Timing Details";

interface/src/MetavoxelSystem.cpp

@@ -21,6 +21,7 @@
 
 #include <glm/gtx/transform.hpp>
 
+#include <GeometryUtil.h>
 #include <SharedUtil.h>
 
 #include <MetavoxelMessages.h>
@@ -192,7 +193,7 @@ static const float EIGHT_BIT_MAXIMUM_RECIPROCAL = 1.0f / EIGHT_BIT_MAXIMUM;
 
 void MetavoxelSystem::render() {
     // update the frustum
-    ViewFrustum* viewFrustum = Application::getInstance()->getViewFrustum();
+    ViewFrustum* viewFrustum = Application::getInstance()->getDisplayViewFrustum();
     _frustum.set(viewFrustum->getFarTopLeft(), viewFrustum->getFarTopRight(), viewFrustum->getFarBottomLeft(),
         viewFrustum->getFarBottomRight(), viewFrustum->getNearTopLeft(), viewFrustum->getNearTopRight(),
         viewFrustum->getNearBottomLeft(), viewFrustum->getNearBottomRight());
@@ -461,6 +462,34 @@ void MetavoxelSystem::render() {
         _voxelBaseBatches.clear();
     }
     
+    if (!_hermiteBatches.isEmpty() && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHermiteData)) {
+        Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers(true, true);
+        
+        glEnableClientState(GL_VERTEX_ARRAY);
+        
+        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
+        glNormal3f(0.0f, 1.0f, 0.0f);
+        
+        Application::getInstance()->getDeferredLightingEffect()->bindSimpleProgram();
+        
+        foreach (const HermiteBatch& batch, _hermiteBatches) {
+            batch.vertexBuffer->bind();
+            
+            glVertexPointer(3, GL_FLOAT, 0, 0);
+            
+            glDrawArrays(GL_LINES, 0, batch.vertexCount);
+            
+            batch.vertexBuffer->release();
+        }
+        
+        Application::getInstance()->getDeferredLightingEffect()->releaseSimpleProgram();
+        
+        glDisableClientState(GL_VERTEX_ARRAY);
+        
+        Application::getInstance()->getTextureCache()->setPrimaryDrawBuffers(true, false);
+    }
+    _hermiteBatches.clear();
+    
     // give external parties a chance to join in
     emit rendering();
 }
@@ -550,10 +579,53 @@ void MetavoxelSystem::setVoxelMaterial(const SharedObjectPointer& spanner, const
     applyMaterialEdit(edit, true);
 }
 
-class SpannerCursorRenderVisitor : public SpannerVisitor {
+void MetavoxelSystem::deleteTextures(int heightTextureID, int colorTextureID, int materialTextureID) const {
+    glDeleteTextures(1, (const GLuint*)&heightTextureID);
+    glDeleteTextures(1, (const GLuint*)&colorTextureID);
+    glDeleteTextures(1, (const GLuint*)&materialTextureID);
+}
+
+class SpannerRenderVisitor : public SpannerVisitor {
 public:
     
-    SpannerCursorRenderVisitor(const Box& bounds);
+    SpannerRenderVisitor(const MetavoxelLOD& lod);
+    
+    virtual int visit(MetavoxelInfo& info);
+    virtual bool visit(Spanner* spanner);
+
+protected:
+    
+    int _containmentDepth;
+};
+
+SpannerRenderVisitor::SpannerRenderVisitor(const MetavoxelLOD& lod) :
+    SpannerVisitor(QVector<AttributePointer>() << AttributeRegistry::getInstance()->getSpannersAttribute(),
+        QVector<AttributePointer>(), QVector<AttributePointer>(), lod,
+        encodeOrder(Application::getInstance()->getViewFrustum()->getDirection())),
+    _containmentDepth(INT_MAX) {
+}
+
+int SpannerRenderVisitor::visit(MetavoxelInfo& info) {
+    if (_containmentDepth >= _depth) {
+        Frustum::IntersectionType intersection = Application::getInstance()->getMetavoxels()->getFrustum().getIntersectionType(
+            info.getBounds());
+        if (intersection == Frustum::NO_INTERSECTION) {
+            return STOP_RECURSION;
+        }
+        _containmentDepth = (intersection == Frustum::CONTAINS_INTERSECTION) ? _depth : INT_MAX;
+    }
+    return SpannerVisitor::visit(info);
+}
+
+bool SpannerRenderVisitor::visit(Spanner* spanner) {
+    spanner->getRenderer()->render(_lod, _containmentDepth <= _depth);
+    return true;
+}
+
+class SpannerCursorRenderVisitor : public SpannerRenderVisitor {
+public:
+    
+    SpannerCursorRenderVisitor(const MetavoxelLOD& lod, const Box& bounds);
     
     virtual bool visit(Spanner* spanner);
     
@@ -564,20 +636,20 @@ private:
     Box _bounds;
 };
 
-SpannerCursorRenderVisitor::SpannerCursorRenderVisitor(const Box& bounds) :
-    SpannerVisitor(QVector<AttributePointer>() << AttributeRegistry::getInstance()->getSpannersAttribute()),
+SpannerCursorRenderVisitor::SpannerCursorRenderVisitor(const MetavoxelLOD& lod, const Box& bounds) :
+    SpannerRenderVisitor(lod),
     _bounds(bounds) {
 }
 
 bool SpannerCursorRenderVisitor::visit(Spanner* spanner) {
     if (spanner->isHeightfield()) {
-        spanner->getRenderer()->render(true);
+         spanner->getRenderer()->render(_lod, _containmentDepth <= _depth, true);
     }
     return true;
 }
 
 int SpannerCursorRenderVisitor::visit(MetavoxelInfo& info) {
-    return info.getBounds().intersects(_bounds) ? SpannerVisitor::visit(info) : STOP_RECURSION;
+    return info.getBounds().intersects(_bounds) ? SpannerRenderVisitor::visit(info) : STOP_RECURSION;
 }
 
 void MetavoxelSystem::renderHeightfieldCursor(const glm::vec3& position, float radius) {
@@ -604,7 +676,7 @@ void MetavoxelSystem::renderHeightfieldCursor(const glm::vec3& position, float r
     glActiveTexture(GL_TEXTURE0);
     
     glm::vec3 extents(radius, radius, radius);
-    SpannerCursorRenderVisitor visitor(Box(position - extents, position + extents));
+    SpannerCursorRenderVisitor visitor(getLOD(), Box(position - extents, position + extents));
     guide(visitor);
     
     _heightfieldCursorProgram.release();
@@ -678,7 +750,7 @@ void MetavoxelSystem::renderVoxelCursor(const glm::vec3& position, float radius)
     
     _heightfieldCursorProgram.bind();
     
-    SpannerCursorRenderVisitor spannerVisitor(bounds);
+    SpannerCursorRenderVisitor spannerVisitor(getLOD(), bounds);
     guide(spannerVisitor);
     
     _heightfieldCursorProgram.release();
@@ -1024,30 +1096,6 @@ VoxelBuffer::VoxelBuffer(const QVector<VoxelPoint>& vertices, const QVector<int>
     _materials(materials) {
 }
 
-static bool findRayTriangleIntersection(const glm::vec3& origin, const glm::vec3& direction,
-        const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2, float& distance) {
-    glm::vec3 firstSide = v0 - v1;
-    glm::vec3 secondSide = v2 - v1;
-    glm::vec3 normal = glm::cross(secondSide, firstSide);
-    float dividend = glm::dot(normal, v1) - glm::dot(origin, normal);
-    if (dividend > 0.0f) {
-        return false; // origin below plane
-    }
-    float divisor = glm::dot(normal, direction);
-    if (divisor > -EPSILON) {
-        return false;
-    }
-    float t = dividend / divisor;
-    glm::vec3 point = origin + direction * t;
-    if (glm::dot(normal, glm::cross(point - v1, firstSide)) > 0.0f &&
-            glm::dot(normal, glm::cross(secondSide, point - v1)) > 0.0f &&
-            glm::dot(normal, glm::cross(point - v0, v2 - v0)) > 0.0f) {
-        distance = t;
-        return true;
-    }
-    return false;
-}
-
 bool VoxelBuffer::findFirstRayIntersection(const glm::vec3& entry, const glm::vec3& origin,
         const glm::vec3& direction, float& distance) const {
     float highest = _size - 1.0f;
@@ -1192,31 +1240,18 @@ void VoxelBuffer::render(bool cursor) {
         }
     }
     
-    if (_hermiteCount > 0 && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHermiteData)) {
+    if (_hermiteCount > 0) {
         if (!_hermiteBuffer.isCreated()) {
             _hermiteBuffer.create();
             _hermiteBuffer.bind();
-            _hermiteBuffer.allocate(_hermite.constData(), _hermite.size() * sizeof(glm::vec3));
+            _hermiteBuffer.allocate(_hermite.constData(), _hermite.size() * sizeof(glm::vec3));    
+            _hermiteBuffer.release();
             _hermite.clear();
-        
-        } else {
-            _hermiteBuffer.bind();
         }
-        
-        glVertexPointer(3, GL_FLOAT, 0, 0);
-        
-        Application::getInstance()->getDeferredLightingEffect()->getSimpleProgram().bind();
-        
-        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
-        glNormal3f(0.0f, 1.0f, 0.0f);
-        
-        glLineWidth(1.0f);
-        
-        glDrawArrays(GL_LINES, 0, _hermiteCount);
-        
-        Application::getInstance()->getDeferredLightingEffect()->getSimpleProgram().release();
-        
-        _hermiteBuffer.release();
+        HermiteBatch hermiteBatch;
+        hermiteBatch.vertexBuffer = &_hermiteBuffer;
+        hermiteBatch.vertexCount = _hermiteCount;
+        Application::getInstance()->getMetavoxels()->addHermiteBatch(hermiteBatch);
     }
 }
 
@@ -1880,43 +1915,6 @@ void DefaultMetavoxelRendererImplementation::simulate(MetavoxelData& data, float
     data.guide(spannerSimulateVisitor);
 }
 
-class SpannerRenderVisitor : public SpannerVisitor {
-public:
-    
-    SpannerRenderVisitor(const MetavoxelLOD& lod);
-    
-    virtual int visit(MetavoxelInfo& info);
-    virtual bool visit(Spanner* spanner);
-
-private:
-    
-    int _containmentDepth;
-};
-
-SpannerRenderVisitor::SpannerRenderVisitor(const MetavoxelLOD& lod) :
-    SpannerVisitor(QVector<AttributePointer>() << AttributeRegistry::getInstance()->getSpannersAttribute(),
-        QVector<AttributePointer>(), QVector<AttributePointer>(), lod,
-        encodeOrder(Application::getInstance()->getViewFrustum()->getDirection())),
-    _containmentDepth(INT_MAX) {
-}
-
-int SpannerRenderVisitor::visit(MetavoxelInfo& info) {
-    if (_containmentDepth >= _depth) {
-        Frustum::IntersectionType intersection = Application::getInstance()->getMetavoxels()->getFrustum().getIntersectionType(
-            info.getBounds());
-        if (intersection == Frustum::NO_INTERSECTION) {
-            return STOP_RECURSION;
-        }
-        _containmentDepth = (intersection == Frustum::CONTAINS_INTERSECTION) ? _depth : INT_MAX;
-    }
-    return SpannerVisitor::visit(info);
-}
-
-bool SpannerRenderVisitor::visit(Spanner* spanner) {
-    spanner->getRenderer()->render();
-    return true;
-}
-
 class BufferRenderVisitor : public MetavoxelVisitor {
 public:
     
@@ -1932,7 +1930,7 @@ private:
 
 BufferRenderVisitor::BufferRenderVisitor(const AttributePointer& attribute) :
     MetavoxelVisitor(QVector<AttributePointer>() << attribute),
-    _order(encodeOrder(Application::getInstance()->getViewFrustum()->getDirection())),
+    _order(encodeOrder(Application::getInstance()->getDisplayViewFrustum()->getDirection())),
     _containmentDepth(INT_MAX) {
 }
 
@@ -1970,7 +1968,7 @@ SphereRenderer::SphereRenderer() {
 }
 
 
-void SphereRenderer::render(bool cursor) {
+void SphereRenderer::render(const MetavoxelLOD& lod, bool contained, bool cursor) {
     Sphere* sphere = static_cast<Sphere*>(_spanner);
     const QColor& color = sphere->getColor();
     glColor4f(color.redF(), color.greenF(), color.blueF(), color.alphaF());
@@ -1990,7 +1988,7 @@ void SphereRenderer::render(bool cursor) {
 CuboidRenderer::CuboidRenderer() {
 }
 
-void CuboidRenderer::render(bool cursor) {
+void CuboidRenderer::render(const MetavoxelLOD& lod, bool contained, bool cursor) {
     Cuboid* cuboid = static_cast<Cuboid*>(_spanner);
     const QColor& color = cuboid->getColor();
     glColor4f(color.redF(), color.greenF(), color.blueF(), color.alphaF());
@@ -2041,7 +2039,7 @@ void StaticModelRenderer::simulate(float deltaTime) {
     _model->simulate(deltaTime);
 }
 
-void StaticModelRenderer::render(bool cursor) {
+void StaticModelRenderer::render(const MetavoxelLOD& lod, bool contained, bool cursor) {
     _model->render();
 }
 
@@ -2073,57 +2071,66 @@ void StaticModelRenderer::applyURL(const QUrl& url) {
 }
 
 HeightfieldRenderer::HeightfieldRenderer() {
-    glGenTextures(1, &_heightTextureID);
-    glBindTexture(GL_TEXTURE_2D, _heightTextureID);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-        
-    glGenTextures(1, &_colorTextureID);
-    glBindTexture(GL_TEXTURE_2D, _colorTextureID);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    
-    glGenTextures(1, &_materialTextureID);
-    glBindTexture(GL_TEXTURE_2D, _materialTextureID);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    
-    glBindTexture(GL_TEXTURE_2D, 0);
 }
 
-HeightfieldRenderer::~HeightfieldRenderer() {
-    glDeleteTextures(1, &_heightTextureID);
-    glDeleteTextures(1, &_colorTextureID);
-    glDeleteTextures(1, &_materialTextureID);
-}
+const int X_MAXIMUM_FLAG = 1;
+const int Y_MAXIMUM_FLAG = 2;
 
-void HeightfieldRenderer::init(Spanner* spanner) {
-    SpannerRenderer::init(spanner);
-    
-    Heightfield* heightfield = static_cast<Heightfield*>(spanner);
-    applyHeight(heightfield->getHeight());
-    applyColor(heightfield->getColor());
-    applyMaterial(heightfield->getMaterial());
-    
-    connect(heightfield, &Heightfield::heightChanged, this, &HeightfieldRenderer::applyHeight);
-    connect(heightfield, &Heightfield::colorChanged, this, &HeightfieldRenderer::applyColor);
-    connect(heightfield, &Heightfield::materialChanged, this, &HeightfieldRenderer::applyMaterial);
-}
-
-void HeightfieldRenderer::render(bool cursor) {
-    // create the buffer objects lazily
-    Heightfield* heightfield = static_cast<Heightfield*>(_spanner);
-    if (!heightfield->getHeight()) {
+static void renderNode(const HeightfieldNodePointer& node, Heightfield* heightfield, const MetavoxelLOD& lod,
+        const glm::vec2& minimum, float size, bool contained, bool cursor) {
+    const glm::quat& rotation = heightfield->getRotation();
+    glm::vec3 scale(heightfield->getScale() * size, heightfield->getScale() * heightfield->getAspectY(),
+        heightfield->getScale() * heightfield->getAspectZ() * size);
+    glm::vec3 translation = heightfield->getTranslation() + rotation * glm::vec3(minimum.x * heightfield->getScale(),
+        0.0f, minimum.y * heightfield->getScale() * heightfield->getAspectZ());
+    if (!contained) {
+        Frustum::IntersectionType type = Application::getInstance()->getMetavoxels()->getFrustum().getIntersectionType(
+            glm::translate(translation) * glm::mat4_cast(rotation) * Box(glm::vec3(), scale));
+        if (type == Frustum::NO_INTERSECTION) {
+            return;
+        }
+        if (type == Frustum::CONTAINS_INTERSECTION) {
+            contained = true;
+        }
+    }
+    if (!node->isLeaf() && lod.shouldSubdivide(minimum, size)) {
+        float nextSize = size * 0.5f;
+        for (int i = 0; i < HeightfieldNode::CHILD_COUNT; i++) {
+            renderNode(node->getChild(i), heightfield, lod, minimum + glm::vec2(i & X_MAXIMUM_FLAG ? nextSize : 0.0f,
+                i & Y_MAXIMUM_FLAG ? nextSize : 0.0f), nextSize, contained, cursor);
+        }
         return;
     }
-    int width = heightfield->getHeight()->getWidth();
-    int height = heightfield->getHeight()->getContents().size() / width;
-    
+    HeightfieldNodeRenderer* renderer = static_cast<HeightfieldNodeRenderer*>(node->getRenderer());
+    if (!renderer) {
+        node->setRenderer(renderer = new HeightfieldNodeRenderer());
+    }
+    renderer->render(node, translation, rotation, scale, cursor);
+}
+
+void HeightfieldRenderer::render(const MetavoxelLOD& lod, bool contained, bool cursor) {
+    Heightfield* heightfield = static_cast<Heightfield*>(_spanner);
+    renderNode(heightfield->getRoot(), heightfield, heightfield->transformLOD(lod), glm::vec2(), 1.0f, contained, cursor);
+}
+
+HeightfieldNodeRenderer::HeightfieldNodeRenderer() :
+    _heightTextureID(0),
+    _colorTextureID(0),
+    _materialTextureID(0) {
+}
+
+HeightfieldNodeRenderer::~HeightfieldNodeRenderer() {
+    QMetaObject::invokeMethod(Application::getInstance()->getMetavoxels(), "deleteTextures", Q_ARG(int, _heightTextureID),
+        Q_ARG(int, _colorTextureID), Q_ARG(int, _materialTextureID));
+}
+
+void HeightfieldNodeRenderer::render(const HeightfieldNodePointer& node, const glm::vec3& translation,
+        const glm::quat& rotation, const glm::vec3& scale, bool cursor) {
+    if (!node->getHeight()) {
+        return;
+    }
+    int width = node->getHeight()->getWidth();
+    int height = node->getHeight()->getContents().size() / width;
     int innerWidth = width - 2 * HeightfieldHeight::HEIGHT_BORDER;
     int innerHeight = height - 2 * HeightfieldHeight::HEIGHT_BORDER;
     int vertexCount = width * height;
@@ -2180,17 +2187,71 @@ void HeightfieldRenderer::render(bool cursor) {
         bufferPair.second.allocate(indices.constData(), indexCount * sizeof(int));
         bufferPair.second.release();
     }
+    if (_heightTextureID == 0) {
+        glGenTextures(1, &_heightTextureID);
+        glBindTexture(GL_TEXTURE_2D, _heightTextureID);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+        const QVector<quint16>& heightContents = node->getHeight()->getContents();
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_R16, width, height, 0,
+            GL_RED, GL_UNSIGNED_SHORT, heightContents.constData());
+    
+        glGenTextures(1, &_colorTextureID);
+        glBindTexture(GL_TEXTURE_2D, _colorTextureID);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        if (node->getColor()) {
+            const QByteArray& contents = node->getColor()->getContents();
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, node->getColor()->getWidth(),
+                contents.size() / (node->getColor()->getWidth() * DataBlock::COLOR_BYTES),
+                0, GL_RGB, GL_UNSIGNED_BYTE, contents.constData());
+            
+        } else {
+            const quint8 WHITE_COLOR[] = { 255, 255, 255 };
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, WHITE_COLOR);
+        }
+        
+        glGenTextures(1, &_materialTextureID);
+        glBindTexture(GL_TEXTURE_2D, _materialTextureID);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        if (node->getMaterial()) {
+            const QByteArray& contents = node->getMaterial()->getContents();
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, node->getMaterial()->getWidth(),
+                contents.size() / node->getMaterial()->getWidth(),
+                0, GL_RED, GL_UNSIGNED_BYTE, contents.constData());
+                
+            const QVector<SharedObjectPointer>& materials = node->getMaterial()->getMaterials();
+            _networkTextures.resize(materials.size());
+            for (int i = 0; i < materials.size(); i++) {
+                const SharedObjectPointer& material = materials.at(i);
+                if (material) {
+                    _networkTextures[i] = Application::getInstance()->getTextureCache()->getTexture(
+                        static_cast<MaterialObject*>(material.data())->getDiffuse(), SPLAT_TEXTURE);
+                }
+            }
+        } else {
+            const quint8 ZERO_VALUE = 0;
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, 1, 1, 0, GL_RED, GL_UNSIGNED_BYTE, &ZERO_VALUE);
+        }
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
     
-    float xScale = heightfield->getScale(), zScale = xScale * heightfield->getAspectZ();
     if (cursor) {
         bufferPair.first.bind();
         bufferPair.second.bind();
     
         glPushMatrix();
-        glTranslatef(heightfield->getTranslation().x, heightfield->getTranslation().y, heightfield->getTranslation().z);
-        glm::vec3 axis = glm::axis(heightfield->getRotation());
-        glRotatef(glm::degrees(glm::angle(heightfield->getRotation())), axis.x, axis.y, axis.z);
-        glScalef(xScale, xScale * heightfield->getAspectY(), zScale);
+        glTranslatef(translation.x, translation.y, translation.z);
+        glm::vec3 axis = glm::axis(rotation);
+        glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
+        glScalef(scale.x, scale.y, scale.z);
         
         HeightfieldPoint* point = 0;
         glVertexPointer(3, GL_FLOAT, sizeof(HeightfieldPoint), &point->vertex);
@@ -2208,13 +2269,12 @@ void HeightfieldRenderer::render(bool cursor) {
         bufferPair.second.release();
         return;
     }
-    
     HeightfieldBaseLayerBatch baseBatch;
     baseBatch.vertexBuffer = &bufferPair.first;
     baseBatch.indexBuffer = &bufferPair.second;
-    baseBatch.translation = heightfield->getTranslation();
-    baseBatch.rotation = heightfield->getRotation();
-    baseBatch.scale = glm::vec3(xScale, xScale * heightfield->getAspectY(), zScale);
+    baseBatch.translation = translation;
+    baseBatch.rotation = rotation;
+    baseBatch.scale = scale;
     baseBatch.vertexCount = vertexCount;
     baseBatch.indexCount = indexCount;
     baseBatch.heightTextureID = _heightTextureID;
@@ -2223,13 +2283,13 @@ void HeightfieldRenderer::render(bool cursor) {
     baseBatch.colorScale = glm::vec2((float)width / innerWidth, (float)height / innerHeight);
     Application::getInstance()->getMetavoxels()->addHeightfieldBaseBatch(baseBatch);    
     
-    if (heightfield->getMaterial() && !_networkTextures.isEmpty()) {
+    if (!_networkTextures.isEmpty()) {
         HeightfieldSplatBatch splatBatch;
         splatBatch.vertexBuffer = &bufferPair.first;
         splatBatch.indexBuffer = &bufferPair.second;
-        splatBatch.translation = heightfield->getTranslation();
-        splatBatch.rotation = heightfield->getRotation();
-        splatBatch.scale = glm::vec3(xScale, xScale * heightfield->getAspectY(), zScale);
+        splatBatch.translation = translation;
+        splatBatch.rotation = rotation;
+        splatBatch.scale = scale;
         splatBatch.vertexCount = vertexCount;
         splatBatch.indexCount = indexCount;
         splatBatch.heightTextureID = _heightTextureID;
@@ -2237,10 +2297,10 @@ void HeightfieldRenderer::render(bool cursor) {
         splatBatch.materialTextureID = _materialTextureID;
         splatBatch.textureScale = glm::vec2((float)width / innerWidth, (float)height / innerHeight);
         splatBatch.splatTextureOffset = glm::vec2(
-            glm::dot(heightfield->getTranslation(), heightfield->getRotation() * glm::vec3(1.0f, 0.0f, 0.0f)) / xScale,
-            glm::dot(heightfield->getTranslation(), heightfield->getRotation() * glm::vec3(0.0f, 0.0f, 1.0f)) / zScale);
+            glm::dot(translation, rotation * glm::vec3(1.0f, 0.0f, 0.0f)) / scale.x,
+            glm::dot(translation, rotation * glm::vec3(0.0f, 0.0f, 1.0f)) / scale.z);
         
-        const QVector<SharedObjectPointer>& materials = heightfield->getMaterial()->getMaterials();
+        const QVector<SharedObjectPointer>& materials = node->getMaterial()->getMaterials();
         for (int i = 0; i < materials.size(); i += SPLAT_COUNT) {
             for (int j = 0; j < SPLAT_COUNT; j++) {
                 int index = i + j;
@@ -2248,8 +2308,8 @@ void HeightfieldRenderer::render(bool cursor) {
                     const NetworkTexturePointer& texture = _networkTextures.at(index);
                     if (texture) {
                         MaterialObject* material = static_cast<MaterialObject*>(materials.at(index).data());
-                        splatBatch.splatTextureScalesS[j] = xScale / material->getScaleS();
-                        splatBatch.splatTextureScalesT[j] = zScale / material->getScaleT();
+                        splatBatch.splatTextureScalesS[j] = scale.x / material->getScaleS();
+                        splatBatch.splatTextureScalesT[j] = scale.z / material->getScaleT();
                         splatBatch.splatTextureIDs[j] = texture->getID();
                         
                     } else {
@@ -2265,62 +2325,5 @@ void HeightfieldRenderer::render(bool cursor) {
     }
 }
 
-void HeightfieldRenderer::applyHeight(const HeightfieldHeightPointer& height) {
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glBindTexture(GL_TEXTURE_2D, _heightTextureID);
-    if (height) {
-        const QVector<quint16>& contents = height->getContents();
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_R16, height->getWidth(), contents.size() / height->getWidth(), 0,
-            GL_RED, GL_UNSIGNED_SHORT, contents.constData());
-        
-    } else {
-        const quint16 ZERO_VALUE = 0;
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_R16, 1, 1, 0, GL_RED, GL_UNSIGNED_SHORT, &ZERO_VALUE);
-    }
-    glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-void HeightfieldRenderer::applyColor(const HeightfieldColorPointer& color) {
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glBindTexture(GL_TEXTURE_2D, _colorTextureID);
-    if (color) {
-        const QByteArray& contents = color->getContents();
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, color->getWidth(),
-            contents.size() / (color->getWidth() * DataBlock::COLOR_BYTES), 0, GL_RGB, GL_UNSIGNED_BYTE, contents.constData());
-        
-    } else {
-        const quint8 WHITE_COLOR[] = { 255, 255, 255 };
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, WHITE_COLOR);
-    }
-    glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-void HeightfieldRenderer::applyMaterial(const HeightfieldMaterialPointer& material) {
-    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-    glBindTexture(GL_TEXTURE_2D, _materialTextureID);
-    if (material) {
-        const QByteArray& contents = material->getContents();
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, material->getWidth(), contents.size() / material->getWidth(), 0,
-            GL_RED, GL_UNSIGNED_BYTE, contents.constData());
-            
-        const QVector<SharedObjectPointer>& materials = material->getMaterials();
-        _networkTextures.resize(materials.size());
-        for (int i = 0; i < materials.size(); i++) {
-            const SharedObjectPointer& material = materials.at(i);
-            if (material) {
-                _networkTextures[i] = Application::getInstance()->getTextureCache()->getTexture(
-                    static_cast<MaterialObject*>(material.data())->getDiffuse(), SPLAT_TEXTURE);
-            } else {
-                _networkTextures[i].clear();
-            }
-        }
-    } else {
-        const quint8 ZERO_VALUE = 0;
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, 1, 1, 0, GL_RED, GL_UNSIGNED_BYTE, &ZERO_VALUE);
-        _networkTextures.clear();
-    }
-    glBindTexture(GL_TEXTURE_2D, 0);
-}
-
-QHash<HeightfieldRenderer::IntPair, HeightfieldRenderer::BufferPair> HeightfieldRenderer::_bufferPairs;
+QHash<HeightfieldNodeRenderer::IntPair, HeightfieldNodeRenderer::BufferPair> HeightfieldNodeRenderer::_bufferPairs;
 

interface/src/MetavoxelSystem.h

@@ -25,6 +25,7 @@
 
 class HeightfieldBaseLayerBatch;
 class HeightfieldSplatBatch;
+class HermiteBatch;
 class Model;
 class VoxelBatch;
 class VoxelSplatBatch;
@@ -88,6 +89,10 @@ public:
     void addVoxelBaseBatch(const VoxelBatch& batch) { _voxelBaseBatches.append(batch); }
     void addVoxelSplatBatch(const VoxelSplatBatch& batch) { _voxelSplatBatches.append(batch); }
     
+    void addHermiteBatch(const HermiteBatch& batch) { _hermiteBatches.append(batch); }
+
+    Q_INVOKABLE void deleteTextures(int heightTextureID, int colorTextureID, int materialTextureID) const;
+        
 signals:
 
     void rendering();
@@ -120,6 +125,7 @@ private:
     QVector<HeightfieldSplatBatch> _heightfieldSplatBatches;
     QVector<VoxelBatch> _voxelBaseBatches;
     QVector<VoxelSplatBatch> _voxelSplatBatches;
+    QVector<HermiteBatch> _hermiteBatches;
     
     ProgramObject _baseHeightfieldProgram;
     int _baseHeightScaleLocation;
@@ -211,6 +217,13 @@ public:
     int materialIndex;
 };
 
+/// A batch containing Hermite data for debugging.
+class HermiteBatch {
+public:
+    QOpenGLBuffer* vertexBuffer;
+    int vertexCount;
+};
+
 /// Generic abstract base class for objects that handle a signal.
 class SignalHandler : public QObject {
     Q_OBJECT
@@ -380,7 +393,7 @@ public:
     
     Q_INVOKABLE SphereRenderer();
     
-    virtual void render(bool cursor = false);
+    virtual void render(const MetavoxelLOD& lod = MetavoxelLOD(), bool contained = false, bool cursor = false);
 };
 
 /// Renders cuboids.
@@ -391,7 +404,7 @@ public:
     
     Q_INVOKABLE CuboidRenderer();
     
-    virtual void render(bool cursor = false);
+    virtual void render(const MetavoxelLOD& lod = MetavoxelLOD(), bool contained = false, bool cursor = false);
 };
 
 /// Renders static models.
@@ -404,7 +417,7 @@ public:
     
     virtual void init(Spanner* spanner);
     virtual void simulate(float deltaTime);
-    virtual void render(bool cursor = false);
+    virtual void render(const MetavoxelLOD& lod = MetavoxelLOD(), bool contained = false, bool cursor = false);
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance) const;
 
 private slots:
@@ -426,26 +439,29 @@ class HeightfieldRenderer : public SpannerRenderer {
 public:
     
     Q_INVOKABLE HeightfieldRenderer();
-    virtual ~HeightfieldRenderer();
     
-    virtual void init(Spanner* spanner);
-    virtual void render(bool cursor = false);
-
-private slots:
-
-    void applyHeight(const HeightfieldHeightPointer& height);
-    void applyColor(const HeightfieldColorPointer& color);
-    void applyMaterial(const HeightfieldMaterialPointer& material);
+    virtual void render(const MetavoxelLOD& lod = MetavoxelLOD(), bool contained = false, bool cursor = false);
+};
 
+/// Renders a single quadtree node.
+class HeightfieldNodeRenderer : public AbstractHeightfieldNodeRenderer {
+public:
+    
+    HeightfieldNodeRenderer();
+    virtual ~HeightfieldNodeRenderer();
+    
+    void render(const HeightfieldNodePointer& node, const glm::vec3& translation,
+        const glm::quat& rotation, const glm::vec3& scale, bool cursor);
+    
 private:
-    
+
     GLuint _heightTextureID;
     GLuint _colorTextureID;
     GLuint _materialTextureID;
     QVector<NetworkTexturePointer> _networkTextures;
     
-    typedef QPair<int, int> IntPair;
-    typedef QPair<QOpenGLBuffer, QOpenGLBuffer> BufferPair;    
+    typedef QPair<int, int> IntPair;    
+    typedef QPair<QOpenGLBuffer, QOpenGLBuffer> BufferPair;
     static QHash<IntPair, BufferPair> _bufferPairs;
 };
 

interface/src/avatar/AvatarManager.cpp

@@ -68,10 +68,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
     PerformanceWarning warn(showWarnings, "Application::updateAvatars()");
 
     PerformanceTimer perfTimer("otherAvatars");
-    Application* applicationInstance = Application::getInstance();
-    glm::vec3 mouseOrigin = applicationInstance->getMouseRayOrigin();
-    glm::vec3 mouseDirection = applicationInstance->getMouseRayDirection();
-
+    
     // simulate avatars
     AvatarHash::iterator avatarIterator = _avatarHash.begin();
     while (avatarIterator != _avatarHash.end()) {

interface/src/devices/SixenseManager.cpp

@@ -540,8 +540,6 @@ void SixenseManager::emulateMouse(PalmData* palm, int index) {
     //a magnification window was clicked on
     int clickX = pos.x();
     int clickY = pos.y();
-    //Checks for magnification window click
-    application->getApplicationOverlay().getClickLocation(clickX, clickY);
     //Set pos to the new click location, which may be the same if no magnification window is open
     pos.setX(clickX);
     pos.setY(clickY);

interface/src/entities/EntityTreeRenderer.cpp

@@ -635,22 +635,12 @@ void EntityTreeRenderer::deleteReleasedModels() {
 }
 
 PickRay EntityTreeRenderer::computePickRay(float x, float y) {
-    float screenWidth = Application::getInstance()->getGLWidget()->width();
-    float screenHeight = Application::getInstance()->getGLWidget()->height();
-    PickRay result;
-    if (OculusManager::isConnected()) {
-        Camera* camera = Application::getInstance()->getCamera();
-        result.origin = camera->getPosition();
-        Application::getInstance()->getApplicationOverlay().computeOculusPickRay(x / screenWidth, y / screenHeight, result.direction);
-    } else {
-        ViewFrustum* viewFrustum = Application::getInstance()->getViewFrustum();
-        viewFrustum->computePickRay(x / screenWidth, y / screenHeight, result.origin, result.direction);
-    }
-    return result;
+    return Application::getInstance()->getCamera()->computePickRay(x, y);
 }
 
 
-RayToEntityIntersectionResult EntityTreeRenderer::findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType) {
+RayToEntityIntersectionResult EntityTreeRenderer::findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType, 
+                                                                                    bool precisionPicking) {
     RayToEntityIntersectionResult result;
     if (_tree) {
         EntityTree* entityTree = static_cast<EntityTree*>(_tree);
@@ -658,7 +648,8 @@ RayToEntityIntersectionResult EntityTreeRenderer::findRayIntersectionWorker(cons
         OctreeElement* element;
         EntityItem* intersectedEntity = NULL;
         result.intersects = entityTree->findRayIntersection(ray.origin, ray.direction, element, result.distance, result.face, 
-                                                                (void**)&intersectedEntity, lockType, &result.accurate);
+                                                                (void**)&intersectedEntity, lockType, &result.accurate, 
+                                                                precisionPicking);
         if (result.intersects && intersectedEntity) {
             result.entityID = intersectedEntity->getEntityItemID();
             result.properties = intersectedEntity->getProperties();
@@ -710,7 +701,9 @@ QScriptValueList EntityTreeRenderer::createEntityArgs(const EntityItemID& entity
 void EntityTreeRenderer::mousePressEvent(QMouseEvent* event, unsigned int deviceID) {
     PerformanceTimer perfTimer("EntityTreeRenderer::mousePressEvent");
     PickRay ray = computePickRay(event->x(), event->y());
-    RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::Lock);
+    
+    bool precisionPicking = !Menu::getInstance()->isOptionChecked(MenuOption::DontDoPrecisionPicking);
+    RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::Lock, precisionPicking);
     if (rayPickResult.intersects) {
         //qDebug() << "mousePressEvent over entity:" << rayPickResult.entityID;
         emit mousePressOnEntity(rayPickResult.entityID, MouseEvent(*event, deviceID));
@@ -734,7 +727,8 @@ void EntityTreeRenderer::mousePressEvent(QMouseEvent* event, unsigned int device
 void EntityTreeRenderer::mouseReleaseEvent(QMouseEvent* event, unsigned int deviceID) {
     PerformanceTimer perfTimer("EntityTreeRenderer::mouseReleaseEvent");
     PickRay ray = computePickRay(event->x(), event->y());
-    RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::Lock);
+    bool precisionPicking = !Menu::getInstance()->isOptionChecked(MenuOption::DontDoPrecisionPicking);
+    RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::Lock, precisionPicking);
     if (rayPickResult.intersects) {
         //qDebug() << "mouseReleaseEvent over entity:" << rayPickResult.entityID;
         emit mouseReleaseOnEntity(rayPickResult.entityID, MouseEvent(*event, deviceID));
@@ -768,7 +762,9 @@ void EntityTreeRenderer::mouseMoveEvent(QMouseEvent* event, unsigned int deviceI
     PerformanceTimer perfTimer("EntityTreeRenderer::mouseMoveEvent");
 
     PickRay ray = computePickRay(event->x(), event->y());
-    RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::TryLock);
+    
+    bool precisionPicking = false; // for mouse moves we do not do precision picking
+    RayToEntityIntersectionResult rayPickResult = findRayIntersectionWorker(ray, Octree::TryLock, precisionPicking);
     if (rayPickResult.intersects) {
         QScriptValueList entityScriptArgs = createMouseEventArgs(rayPickResult.entityID, event, deviceID);
 

interface/src/entities/EntityTreeRenderer.h

@@ -117,7 +117,8 @@ private:
     QList<Model*> _releasedModels;
     void renderProxies(const EntityItem* entity, RenderArgs* args);
     PickRay computePickRay(float x, float y);
-    RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType);
+    RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType, 
+                                                                bool precisionPicking);
 
     EntityItemID _currentHoverOverEntityID;
     EntityItemID _currentClickingOnEntityID;

interface/src/entities/RenderableLightEntityItem.cpp

@@ -93,7 +93,7 @@ void RenderableLightEntityItem::render(RenderArgs* args) {
 
 bool RenderableLightEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) const {
+                         void** intersectedObject, bool precisionPicking) const {
                          
     // TODO: this isn't really correct because we don't know if we actually live in the main tree of the applications's
     // EntityTreeRenderer. But we probably do. Technically we could be on the clipboard and someone might be trying to

interface/src/entities/RenderableLightEntityItem.h

@@ -37,7 +37,7 @@ public:
     virtual bool supportsDetailedRayIntersection() const { return true; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) const;
+                         void** intersectedObject, bool precisionPicking) const;
 };
 
 

interface/src/entities/RenderableModelEntityItem.cpp

@@ -173,10 +173,18 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
                     // is significantly more expensive. Is there a way to call this that doesn't cost us as much? 
                     PerformanceTimer perfTimer("model->render");
                     bool dontRenderAsScene = Menu::getInstance()->isOptionChecked(MenuOption::DontRenderEntitiesAsScene);
-                    if (dontRenderAsScene) {
-                        _model->render(alpha, modelRenderMode, args);
-                    } else {
-                        _model->renderInScene(alpha, args);
+                    bool displayModelTriangles = Menu::getInstance()->isOptionChecked(MenuOption::DisplayModelTriangles);
+                    bool rendered = false;
+                    if (displayModelTriangles) {
+                        rendered = _model->renderTriangleProxies();
+                    }
+                    
+                    if (!rendered) {
+                        if (dontRenderAsScene) {
+                            _model->render(alpha, modelRenderMode, args);
+                        } else {
+                            _model->renderInScene(alpha, args);
+                        }
                     }
                 } else {
                     // if we couldn't get a model, then just draw a cube
@@ -257,7 +265,26 @@ EntityItemProperties RenderableModelEntityItem::getProperties() const {
     return properties;
 }
 
-
-
+bool RenderableModelEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+                         bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
+                         void** intersectedObject, bool precisionPicking) const {
+
+    glm::vec3 originInMeters = origin * (float)TREE_SCALE;
+    QString extraInfo;
+    float localDistance;
+    
+    //qDebug() << "RenderableModelEntityItem::findDetailedRayIntersection() precisionPicking:" << precisionPicking;
+    
+    bool intersectsModel = _model->findRayIntersectionAgainstSubMeshes(originInMeters, direction, 
+                                            localDistance, face, extraInfo, precisionPicking);
+    
+    if (intersectsModel) {
+        // NOTE: findRayIntersectionAgainstSubMeshes() does work in meters, but we're expected to return
+        // results in tree scale.
+        distance = localDistance / (float)TREE_SCALE;
+    }
+
+    return intersectsModel; // we only got here if we intersected our non-aabox                         
+}
 
 

interface/src/entities/RenderableModelEntityItem.h

@@ -51,6 +51,11 @@ public:
     virtual void somethingChangedNotification() { _needsInitialSimulation = true; }
 
     virtual void render(RenderArgs* args);
+    virtual bool supportsDetailedRayIntersection() const { return true; }
+    virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
+                         bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
+                         void** intersectedObject, bool precisionPicking) const;
+
     Model* getModel(EntityTreeRenderer* renderer);
 
     bool needsToCallUpdate() const;

interface/src/renderer/DeferredLightingEffect.cpp

@@ -232,8 +232,8 @@ void DeferredLightingEffect::render() {
     // enlarge the scales slightly to account for tesselation
     const float SCALE_EXPANSION = 0.05f;
     
-    const glm::vec3& eyePoint = Application::getInstance()->getViewFrustum()->getPosition();
-    float nearRadius = glm::distance(eyePoint, Application::getInstance()->getViewFrustum()->getNearTopLeft());
+    const glm::vec3& eyePoint = Application::getInstance()->getDisplayViewFrustum()->getPosition();
+    float nearRadius = glm::distance(eyePoint, Application::getInstance()->getDisplayViewFrustum()->getNearTopLeft());
     
     if (!_pointLights.isEmpty()) {
         _pointLight.bind();

interface/src/renderer/GeometryCache.cpp

@@ -829,28 +829,44 @@ void GeometryReader::run() {
         return;
     }
     try {
-        std::string urlname = _url.path().toLower().toStdString();
-        FBXGeometry fbxgeo;
-        if (_url.path().toLower().endsWith(".svo")) {
-            fbxgeo = readSVO(_reply->readAll());
-        } else {
-            bool grabLightmaps = true;
-            float lightmapLevel = 1.0f;
-            // HACK: For monday 12/01/2014 we need to kill lighmaps loading in starchamber...
-            if (_url.path().toLower().endsWith("loungev4_11-18.fbx")) {
-                grabLightmaps = false;
-            } else if (_url.path().toLower().endsWith("apt8_reboot.fbx")) {
-                lightmapLevel = 4.0f;
-            } else if (_url.path().toLower().endsWith("palaceoforinthilian4.fbx")) {
-                lightmapLevel = 3.5f;
-            }
-            fbxgeo = readFBX(_reply->readAll(), _mapping, grabLightmaps, lightmapLevel);
+        if (!_reply) {
+            throw QString("Reply is NULL ?!");
         }
-        QMetaObject::invokeMethod(geometry.data(), "setGeometry", Q_ARG(const FBXGeometry&, fbxgeo));
+        std::string urlname = _url.path().toLower().toStdString();
+        bool urlValid = true;
+        urlValid &= !urlname.empty();
+        urlValid &= !_url.path().isEmpty();
+        urlValid &= _url.path().toLower().endsWith(".fbx")
+                    || _url.path().toLower().endsWith(".svo");
 
+        if (urlValid) {
+            // Let's read the binaries from the network
+            QByteArray fileBinary = _reply->readAll();
+            if (fileBinary.isEmpty() || fileBinary.isNull()) {
+                throw QString("Read File binary is empty?!");
+            }
+
+            FBXGeometry fbxgeo;
+            if (_url.path().toLower().endsWith(".svo")) {
+                fbxgeo = readSVO(fileBinary);
+            } else if (_url.path().toLower().endsWith(".fbx")) {
+                bool grabLightmaps = true;
+                float lightmapLevel = 1.0f;
+                // HACK: For monday 12/01/2014 we need to kill lighmaps loading in starchamber...
+                if (_url.path().toLower().endsWith("loungev4_11-18.fbx")) {
+                    grabLightmaps = false;
+                } else if (_url.path().toLower().endsWith("apt8_reboot.fbx")) {
+                    lightmapLevel = 4.0f;
+                } else if (_url.path().toLower().endsWith("palaceoforinthilian4.fbx")) {
+                    lightmapLevel = 3.5f;
+                }
+                fbxgeo = readFBX(fileBinary, _mapping, grabLightmaps, lightmapLevel);
+            }
+            QMetaObject::invokeMethod(geometry.data(), "setGeometry", Q_ARG(const FBXGeometry&, fbxgeo));
+        } else {
+            throw QString("url is invalid");
+        }
 
-      //      _url.path().toLower().endsWith(".svo") ? readSVO(_reply->readAll()) : readFBX(_reply->readAll(), _mapping)));
-        
     } catch (const QString& error) {
         qDebug() << "Error reading " << _url << ": " << error;
         QMetaObject::invokeMethod(geometry.data(), "finishedLoading", Q_ARG(bool, false));

interface/src/renderer/Model.cpp

@@ -54,6 +54,7 @@ Model::Model(QObject* parent) :
     _blendNumber(0),
     _appliedBlendNumber(0),
     _calculatedMeshBoxesValid(false),
+    _calculatedMeshTrianglesValid(false),
     _meshGroupsKnown(false) {
     
     // we may have been created in the network thread, but we live in the main thread
@@ -269,7 +270,7 @@ void Model::init() {
         _program.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() + "shaders/model.vert");
         _program.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() + "shaders/model.frag");
         _program.link();
-        
+
         initProgram(_program, _locations);
         
         _normalMapProgram.addShaderFromSourceFile(QGLShader::Vertex,
@@ -515,8 +516,61 @@ void Model::setJointStates(QVector<JointState> states) {
     _boundingRadius = radius;
 }
 
-bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const glm::vec3& direction,
-                                                        float& distance, BoxFace& face, QString& extraInfo) const {
+bool Model::renderTriangleProxies() {
+    if (!isActive()) {
+        return false;
+    }
+    if (_calculatedMeshTrianglesValid) {
+        int color = 0;
+        foreach (const QVector<Triangle>& meshTriangles, _calculatedMeshTriangles) {
+            switch(color) {
+                case  0: glColor3ub(  0,   0, 255); break;
+                case  1: glColor3ub(  0, 255,   0); break;
+                case  2: glColor3ub(  0, 255, 255); break;
+                case  3: glColor3ub(255,   0,   0); break;
+                case  4: glColor3ub(255,   0, 255); break;
+                case  5: glColor3ub(255, 255,   0); break;
+                case  6: glColor3ub(  0,   0, 128); break;
+                case  7: glColor3ub(  0, 128,   0); break;
+                case  8: glColor3ub(  0, 128, 128); break;
+                case  9: glColor3ub(128,   0,   0); break;
+                case 10: glColor3ub(128,   0, 128); break;
+                case 11: glColor3ub(128, 128,   0); break;
+                case 12: glColor3ub(128, 128, 255); break;
+                case 13: glColor3ub(128, 255, 128); break;
+                case 14: glColor3ub(128, 255, 255); break;
+                case 15: glColor3ub(255, 128, 128); break;
+                case 16: glColor3ub(255, 128, 255); break;
+                case 17: glColor3ub(255, 255, 128); break;
+                default: glColor3ub(255,255, 255); break;
+            }
+            
+            if (_calculatedMeshBoxes.size() > color) {
+                const AABox& box = _calculatedMeshBoxes[color];
+                glm::vec3 center = box.calcCenter();
+                glm::vec3 dimensions = box.getDimensions();
+                glPushMatrix();
+                    glTranslatef(center.x, center.y, center.z);
+                    glScalef(dimensions.x, dimensions.y, dimensions.z);
+                    Application::getInstance()->getDeferredLightingEffect()->renderWireCube(1.0f);
+                glPopMatrix();
+            }
+
+            glBegin(GL_TRIANGLES);
+            foreach (const Triangle& triangle, meshTriangles) {
+                glVertex3f( triangle.v0.x,  triangle.v0.y,  triangle.v0.z); 
+                glVertex3f( triangle.v1.x,  triangle.v1.y,  triangle.v1.z); 
+                glVertex3f( triangle.v2.x,  triangle.v2.y,  triangle.v2.z); 
+            }
+            glEnd();
+            color++;
+        }
+    }
+    return _calculatedMeshTrianglesValid;
+}
+
+bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const glm::vec3& direction, float& distance, 
+                                                    BoxFace& face, QString& extraInfo, bool pickAgainstTriangles) {
 
     bool intersectedSomething = false;
 
@@ -524,7 +578,7 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g
     if (!isActive()) {
         return intersectedSomething;
     }
-
+    
     // extents is the entity relative, scaled, centered extents of the entity
     glm::vec3 position = _translation;
     glm::mat4 rotation = glm::mat4_cast(_rotation);
@@ -535,35 +589,70 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g
     Extents modelExtents = getMeshExtents(); // NOTE: unrotated
     
     glm::vec3 dimensions = modelExtents.maximum - modelExtents.minimum;
-    glm::vec3 corner = dimensions * -0.5f; // since we're going to do the ray picking in the model frame of reference
-    AABox overlayFrameBox(corner, dimensions);
+    glm::vec3 corner = -(dimensions * _registrationPoint); // since we're going to do the ray picking in the model frame of reference
+    AABox modelFrameBox(corner, dimensions);
 
     glm::vec3 modelFrameOrigin = glm::vec3(worldToModelMatrix * glm::vec4(origin, 1.0f));
     glm::vec3 modelFrameDirection = glm::vec3(worldToModelMatrix * glm::vec4(direction, 0.0f));
 
     // we can use the AABox's ray intersection by mapping our origin and direction into the model frame
     // and testing intersection there.
-    if (overlayFrameBox.findRayIntersection(modelFrameOrigin, modelFrameDirection, distance, face)) {
+    if (modelFrameBox.findRayIntersection(modelFrameOrigin, modelFrameDirection, distance, face)) {
 
         float bestDistance = std::numeric_limits<float>::max();
+        float bestTriangleDistance = std::numeric_limits<float>::max();
+        bool someTriangleHit = false;
+
         float distanceToSubMesh;
         BoxFace subMeshFace;
         int subMeshIndex = 0;
-    
+
+        const FBXGeometry& geometry = _geometry->getFBXGeometry();
+
         // If we hit the models box, then consider the submeshes...
         foreach(const AABox& subMeshBox, _calculatedMeshBoxes) {
-            const FBXGeometry& geometry = _geometry->getFBXGeometry();
 
             if (subMeshBox.findRayIntersection(origin, direction, distanceToSubMesh, subMeshFace)) {
                 if (distanceToSubMesh < bestDistance) {
-                    bestDistance = distanceToSubMesh;
-                    intersectedSomething = true;
-                    face = subMeshFace;
-                    extraInfo = geometry.getModelNameOfMesh(subMeshIndex);
+                    if (pickAgainstTriangles) {
+                        someTriangleHit = false;
+                        if (!_calculatedMeshTrianglesValid) {
+                            recalculateMeshBoxes(pickAgainstTriangles);
+                        }
+                        // check our triangles here....
+                        const QVector<Triangle>& meshTriangles = _calculatedMeshTriangles[subMeshIndex];
+                        int t = 0;
+                        foreach (const Triangle& triangle, meshTriangles) {
+                            t++;
+                        
+                            float thisTriangleDistance;
+                            if (findRayTriangleIntersection(origin, direction, triangle, thisTriangleDistance)) {
+                                if (thisTriangleDistance < bestDistance) {
+                                    bestTriangleDistance = thisTriangleDistance;
+                                    someTriangleHit = true;
+
+                                    bestDistance = thisTriangleDistance;
+                                    intersectedSomething = true;
+                                    face = subMeshFace;
+                                    extraInfo = geometry.getModelNameOfMesh(subMeshIndex);
+                                }
+                            }
+                        }
+                    } else {
+                        // this is the non-triangle picking case...
+                        bestDistance = distanceToSubMesh;
+                        intersectedSomething = true;
+                        face = subMeshFace;
+                        extraInfo = geometry.getModelNameOfMesh(subMeshIndex);
+                    }
                 }
-            }
+            } 
             subMeshIndex++;
         }
+
+        if (intersectedSomething) {
+            distance = bestDistance;
+        }
         
         return intersectedSomething;
     }
@@ -571,18 +660,81 @@ bool Model::findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const g
     return intersectedSomething;
 }
 
-void Model::recalcuateMeshBoxes() {
-    if (!_calculatedMeshBoxesValid) {
+// TODO: we seem to call this too often when things haven't actually changed... look into optimizing this
+void Model::recalculateMeshBoxes(bool pickAgainstTriangles) {
+    bool calculatedMeshTrianglesNeeded = pickAgainstTriangles && !_calculatedMeshTrianglesValid;
+
+    if (!_calculatedMeshBoxesValid || calculatedMeshTrianglesNeeded) {
         PerformanceTimer perfTimer("calculatedMeshBoxes");
         const FBXGeometry& geometry = _geometry->getFBXGeometry();
         int numberOfMeshes = geometry.meshes.size();
         _calculatedMeshBoxes.resize(numberOfMeshes);
+        _calculatedMeshTriangles.clear();
+        _calculatedMeshTriangles.resize(numberOfMeshes);
         for (int i = 0; i < numberOfMeshes; i++) {
             const FBXMesh& mesh = geometry.meshes.at(i);
             Extents scaledMeshExtents = calculateScaledOffsetExtents(mesh.meshExtents);
+
             _calculatedMeshBoxes[i] = AABox(scaledMeshExtents);
+
+            if (pickAgainstTriangles) {
+                QVector<Triangle> thisMeshTriangles;
+                for (int j = 0; j < mesh.parts.size(); j++) {
+                    const FBXMeshPart& part = mesh.parts.at(j);
+
+                    const int INDICES_PER_TRIANGLE = 3;
+                    const int INDICES_PER_QUAD = 4;
+
+                    if (part.quadIndices.size() > 0) {
+                        int numberOfQuads = part.quadIndices.size() / INDICES_PER_QUAD;
+                        int vIndex = 0;
+                        for (int q = 0; q < numberOfQuads; q++) {
+                            int i0 = part.quadIndices[vIndex++];
+                            int i1 = part.quadIndices[vIndex++];
+                            int i2 = part.quadIndices[vIndex++];
+                            int i3 = part.quadIndices[vIndex++];
+
+                            glm::vec3 v0 = calculateScaledOffsetPoint(glm::vec3(mesh.modelTransform * glm::vec4(mesh.vertices[i0], 1.0f)));
+                            glm::vec3 v1 = calculateScaledOffsetPoint(glm::vec3(mesh.modelTransform * glm::vec4(mesh.vertices[i1], 1.0f)));
+                            glm::vec3 v2 = calculateScaledOffsetPoint(glm::vec3(mesh.modelTransform * glm::vec4(mesh.vertices[i2], 1.0f)));
+                            glm::vec3 v3 = calculateScaledOffsetPoint(glm::vec3(mesh.modelTransform * glm::vec4(mesh.vertices[i3], 1.0f)));
+                        
+                            // Sam's recommended triangle slices
+                            Triangle tri1 = { v0, v1, v3 };
+                            Triangle tri2 = { v1, v2, v3 };
+                        
+                            // NOTE: Random guy on the internet's recommended triangle slices
+                            //Triangle tri1 = { v0, v1, v2 };
+                            //Triangle tri2 = { v2, v3, v0 };
+                        
+                            thisMeshTriangles.push_back(tri1);
+                            thisMeshTriangles.push_back(tri2);
+                        }
+                    }
+
+                    if (part.triangleIndices.size() > 0) {
+                        int numberOfTris = part.triangleIndices.size() / INDICES_PER_TRIANGLE;
+                        int vIndex = 0;
+                        for (int t = 0; t < numberOfTris; t++) {
+                            int i0 = part.triangleIndices[vIndex++];
+                            int i1 = part.triangleIndices[vIndex++];
+                            int i2 = part.triangleIndices[vIndex++];
+
+                            glm::vec3 v0 = calculateScaledOffsetPoint(glm::vec3(mesh.modelTransform * glm::vec4(mesh.vertices[i0], 1.0f)));
+                            glm::vec3 v1 = calculateScaledOffsetPoint(glm::vec3(mesh.modelTransform * glm::vec4(mesh.vertices[i1], 1.0f)));
+                            glm::vec3 v2 = calculateScaledOffsetPoint(glm::vec3(mesh.modelTransform * glm::vec4(mesh.vertices[i2], 1.0f)));
+
+                            Triangle tri = { v0, v1, v2 };
+
+                            thisMeshTriangles.push_back(tri);
+                        }
+                    }
+                }
+                _calculatedMeshTriangles[i] = thisMeshTriangles;
+            }
         }
         _calculatedMeshBoxesValid = true;
+        _calculatedMeshTrianglesValid = pickAgainstTriangles;
     }
 }
 
@@ -592,7 +744,7 @@ void Model::renderSetup(RenderArgs* args) {
     // against. We cache the results of these calculations so long as the model hasn't been
     // simulated and the mesh hasn't changed.
     if (args && !_calculatedMeshBoxesValid) {
-        recalcuateMeshBoxes();
+        recalculateMeshBoxes();
     }
     
     // set up dilated textures on first render after load/simulate
@@ -844,6 +996,15 @@ Extents Model::calculateScaledOffsetExtents(const Extents& extents) const {
     return translatedExtents;
 }
 
+glm::vec3 Model::calculateScaledOffsetPoint(const glm::vec3& point) const {
+    // we need to include any fst scaling, translation, and rotation, which is captured in the offset matrix
+    glm::vec3 offsetPoint = glm::vec3(_geometry->getFBXGeometry().offset * glm::vec4(point, 1.0f));
+    glm::vec3 scaledPoint = ((offsetPoint + _offset) * _scale);
+    glm::vec3 rotatedPoint = _rotation * scaledPoint;
+    glm::vec3 translatedPoint = rotatedPoint + _translation;
+    return translatedPoint;
+}
+
 
 bool Model::getJointState(int index, glm::quat& rotation) const {
     if (index == -1 || index >= _jointStates.size()) {
@@ -1142,6 +1303,7 @@ void Model::simulate(float deltaTime, bool fullUpdate) {
                     
     if (isActive() && fullUpdate) {
         _calculatedMeshBoxesValid = false; // if we have to simulate, we need to assume our mesh boxes are all invalid
+        _calculatedMeshTrianglesValid = false;
 
         // check for scale to fit
         if (_scaleToFit && !_scaledToFit) {

interface/src/renderer/Model.h

@@ -19,6 +19,7 @@
 #include "Transform.h"
 #include <AABox.h>
 #include <AnimationCache.h>
+#include <GeometryUtil.h>
 #include <PhysicsEntity.h>
 
 #include "AnimationHandle.h"
@@ -34,7 +35,6 @@ class Shape;
 #include "RenderArgs.h"
 class ViewFrustum;
 
-
 #include "gpu/Stream.h"
 #include "gpu/Batch.h"
 
@@ -89,6 +89,7 @@ public:
     enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE };
     
     bool render(float alpha = 1.0f, RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
+    bool renderTriangleProxies();
     
     // Scene rendering support
     static void startScene(RenderArgs::RenderSide renderSide);
@@ -119,6 +120,9 @@ public:
     /// Returns the scaled equivalent of some extents in model space.
     Extents calculateScaledOffsetExtents(const Extents& extents) const;
 
+    /// Returns the scaled equivalent of a point in model space.
+    glm::vec3 calculateScaledOffsetPoint(const glm::vec3& point) const;
+
     /// Returns a reference to the shared geometry.
     const QSharedPointer<NetworkGeometry>& getGeometry() const { return _geometry; }
     
@@ -193,8 +197,8 @@ public:
     Q_INVOKABLE void setTextureWithNameToURL(const QString& name, const QUrl& url)
         { _geometry->setTextureWithNameToURL(name, url); }
 
-    bool findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const glm::vec3& direction, 
-                                                float& distance, BoxFace& face, QString& extraInfo) const;
+    bool findRayIntersectionAgainstSubMeshes(const glm::vec3& origin, const glm::vec3& direction, float& distance, 
+                                                BoxFace& face, QString& extraInfo, bool pickAgainstTriangles = false);
 
 protected:
     QSharedPointer<NetworkGeometry> _geometry;
@@ -318,7 +322,7 @@ private:
     static ProgramObject _skinTranslucentProgram;
 
     static ProgramObject _skinShadowProgram;
-    
+
     static int _normalMapTangentLocation;
     static int _normalSpecularMapTangentLocation;
     
@@ -361,10 +365,13 @@ private:
 
     static void initSkinProgram(ProgramObject& program, SkinLocations& locations, int specularTextureUnit = 1);
 
-    QVector<AABox> _calculatedMeshBoxes;
+    QVector<AABox> _calculatedMeshBoxes; // world coordinate AABoxes for all sub mesh boxes
     bool _calculatedMeshBoxesValid;
+    
+    QVector< QVector<Triangle> > _calculatedMeshTriangles; // world coordinate triangles for all sub meshes
+    bool _calculatedMeshTrianglesValid;
 
-    void recalcuateMeshBoxes();
+    void recalculateMeshBoxes(bool pickAgainstTriangles = false);
 
     void segregateMeshGroups(); // used to calculate our list of translucent vs opaque meshes
 

interface/src/scripting/JoystickScriptingInterface.cpp

@@ -133,7 +133,7 @@ void JoystickScriptingInterface::update() {
                     
                     // global action events fire in the center of the screen
                     HFActionEvent actionEvent(actionType,
-                                              Application::getInstance()->getViewFrustum()->computePickRay(0.5f, 0.5f));
+                                              Application::getInstance()->getCamera()->computeViewPickRay(0.5f, 0.5f));
                     qApp->sendEvent(qApp, &actionEvent);
                 }
                 

interface/src/ui/ApplicationOverlay.h

@@ -15,14 +15,13 @@
 class Overlays;
 class QOpenGLFramebufferObject;
 
-const float MAGNIFY_WIDTH = 160.0f;
-const float MAGNIFY_HEIGHT = 80.0f;
-const float MAGNIFY_MULT = 4.0f;
+const float MAGNIFY_WIDTH = 220.0f;
+const float MAGNIFY_HEIGHT = 100.0f;
+const float MAGNIFY_MULT = 2.0f;
 
 // Handles the drawing of the overlays to the screen
 class ApplicationOverlay {
 public:
-
     ApplicationOverlay();
     ~ApplicationOverlay();
 
@@ -30,16 +29,25 @@ public:
     void displayOverlayTexture();
     void displayOverlayTextureOculus(Camera& whichCamera);
     void displayOverlayTexture3DTV(Camera& whichCamera, float aspectRatio, float fov);
-    void computeOculusPickRay(float x, float y, glm::vec3& direction) const;
-    void getClickLocation(int &x, int &y) const;
+    
+    void computeOculusPickRay(float x, float y, glm::vec3& origin, glm::vec3& direction) const;
     QPoint getPalmClickLocation(const PalmData *palm) const;
     bool calculateRayUICollisionPoint(const glm::vec3& position, const glm::vec3& direction, glm::vec3& result) const;
-
-
-    // Getters
-    QOpenGLFramebufferObject* getFramebufferObject();
-    float getAlpha() const { return _alpha; }
-  
+    
+    // Converter from one frame of reference to another.
+    // Frame of reference:
+    // Screen: Position on the screen (x,y)
+    // Spherical: Pitch and yaw that gives the position on the sphere we project on (yaw,pitch)
+    // Overlay: Position on the overlay (x,y)
+    // (x,y) in Overlay are similar than (x,y) in Screen except they can be outside of the bound of te screen.
+    // This allows for picking outside of the screen projection in 3D.
+    glm::vec2 screenToSpherical(glm::vec2 screenPos) const;
+    glm::vec2 sphericalToScreen(glm::vec2 sphericalPos) const;
+    glm::vec2 sphericalToOverlay(glm::vec2 sphericalPos) const;
+    glm::vec2 overlayToSpherical(glm::vec2 overlayPos) const;
+    glm::vec2 screenToOverlay(glm::vec2 screenPos) const;
+    glm::vec2 overlayToScreen(glm::vec2 overlayPos) const;
+    
 private:
     // Interleaved vertex data
     struct TextureVertex {
@@ -48,31 +56,54 @@ private:
     };
 
     typedef QPair<GLuint, GLuint> VerticesIndices;
-
-    void renderPointers();
+    class TexturedHemisphere {
+    public:
+        TexturedHemisphere();
+        ~TexturedHemisphere();
+        
+        void bind();
+        void release();
+        void bindTexture();
+        void releaseTexture();
+        
+        void buildFramebufferObject();
+        void buildVBO(const float fov, const float aspectRatio, const int slices, const int stacks);
+        void render();
+        
+    private:
+        void cleanupVBO();
+        
+        GLuint _vertices;
+        GLuint _indices;
+        QOpenGLFramebufferObject* _framebufferObject;
+        VerticesIndices _vbo;
+    };
+    
+    void renderPointers();;
+    void renderMagnifier(glm::vec2 magPos, float sizeMult, bool showBorder) const;
+    
     void renderControllerPointers();
     void renderPointersOculus(const glm::vec3& eyePos);
-    void renderMagnifier(int mouseX, int mouseY, float sizeMult, bool showBorder) const;
+    
     void renderAudioMeter();
     void renderStatsAndLogs();
-    void renderTexturedHemisphere();
     void renderDomainConnectionStatusBorder();
 
-    QOpenGLFramebufferObject* _framebufferObject;
-    float _trailingAudioLoudness;
-    float _textureFov;
+    TexturedHemisphere _overlays;
     
-    enum MagnifyDevices { MOUSE, LEFT_CONTROLLER, RIGHT_CONTROLLER, NUMBER_OF_MAGNIFIERS = RIGHT_CONTROLLER + 1 };
-    bool _reticleActive[NUMBER_OF_MAGNIFIERS];
-    int _mouseX[NUMBER_OF_MAGNIFIERS];
-    int _mouseY[NUMBER_OF_MAGNIFIERS];
-    bool _magActive[NUMBER_OF_MAGNIFIERS];
-    int _magX[NUMBER_OF_MAGNIFIERS];
-    int _magY[NUMBER_OF_MAGNIFIERS];
-    float _magSizeMult[NUMBER_OF_MAGNIFIERS];
+    float _textureFov;
+    float _textureAspectRatio;
+    
+    enum Reticules { MOUSE, LEFT_CONTROLLER, RIGHT_CONTROLLER, NUMBER_OF_RETICULES };
+    bool _reticleActive[NUMBER_OF_RETICULES];
+    QPoint _reticulePosition[NUMBER_OF_RETICULES];
+    bool _magActive[NUMBER_OF_RETICULES];
+    float _magSizeMult[NUMBER_OF_RETICULES];
+    quint64 _lastMouseMove;
     
     float _alpha;
-    float _oculusuiRadius;
+    float _oculusUIRadius;
+    float _trailingAudioLoudness;
 
     GLuint _crosshairTexture;
 };

interface/src/ui/MetavoxelEditor.cpp

@@ -182,13 +182,6 @@ QVariant MetavoxelEditor::getValue() const {
     return editor ? editor->metaObject()->userProperty().read(editor) : QVariant();
 }
 
-void MetavoxelEditor::detachValue() {
-    SharedObjectEditor* editor = qobject_cast<SharedObjectEditor*>(_valueArea->widget());
-    if (editor) {
-        editor->detachObject();
-    }
-}
-
 bool MetavoxelEditor::eventFilter(QObject* watched, QEvent* event) {
     // pass along to the active tool
     MetavoxelTool* tool = getActiveTool();
@@ -616,7 +609,7 @@ PlaceSpannerTool::PlaceSpannerTool(MetavoxelEditor* editor, const QString& name,
 }
 
 void PlaceSpannerTool::simulate(float deltaTime) {
-    Spanner* spanner = static_cast<Spanner*>(getSpanner(true).data());
+    Spanner* spanner = static_cast<Spanner*>(getSpanner().data());
     Transformable* transformable = qobject_cast<Transformable*>(spanner);
     if (transformable && _followMouse->isChecked() && !Application::getInstance()->isMouseHidden()) {
         // find the intersection of the mouse ray with the grid and place the transformable there
@@ -634,7 +627,7 @@ void PlaceSpannerTool::simulate(float deltaTime) {
 
 void PlaceSpannerTool::renderPreview() {
     Spanner* spanner = static_cast<Spanner*>(getSpanner().data());
-    spanner->getRenderer()->render();
+    spanner->getRenderer()->render(Application::getInstance()->getMetavoxels()->getLOD());
 }
 
 bool PlaceSpannerTool::appliesTo(const AttributePointer& attribute) const {
@@ -649,10 +642,7 @@ bool PlaceSpannerTool::eventFilter(QObject* watched, QEvent* event) {
     return false;
 }
 
-SharedObjectPointer PlaceSpannerTool::getSpanner(bool detach) {
-    if (detach) {
-        _editor->detachValue();
-    }
+SharedObjectPointer PlaceSpannerTool::getSpanner() {
     return _editor->getValue().value<SharedObjectPointer>();
 }
 
@@ -663,7 +653,7 @@ QColor PlaceSpannerTool::getColor() {
 void PlaceSpannerTool::place() {
     AttributePointer attribute = AttributeRegistry::getInstance()->getAttribute(_editor->getSelectedAttribute());
     if (attribute) {
-        applyEdit(attribute, getSpanner());
+        applyEdit(attribute, getSpanner()->clone());
     }
 }
 
@@ -732,11 +722,11 @@ HeightfieldTool::HeightfieldTool(MetavoxelEditor* editor, const QString& name) :
     layout()->addWidget(widget);
     
     _form->addRow("Translation:", _translation = new Vec3Editor(widget));
-    _form->addRow("Scale:", _scale = new QDoubleSpinBox());
-    _scale->setMinimum(-FLT_MAX);
-    _scale->setMaximum(FLT_MAX);
-    _scale->setPrefix("2^");
-    _scale->setValue(2.0);
+    _form->addRow("Spacing:", _spacing = new QDoubleSpinBox());
+    _spacing->setMaximum(FLT_MAX);
+    _spacing->setDecimals(3);
+    _spacing->setSingleStep(0.001);
+    _spacing->setValue(1.0);
     
     QPushButton* applyButton = new QPushButton("Apply");
     layout()->addWidget(applyButton);
@@ -747,28 +737,20 @@ bool HeightfieldTool::appliesTo(const AttributePointer& attribute) const {
     return attribute->inherits("SpannerSetAttribute");
 }
 
-void HeightfieldTool::render() {
-    float scale = pow(2.0, _scale->value());
-    _translation->setSingleStep(scale);
-    glm::vec3 quantizedTranslation = scale * glm::floor(_translation->getValue() / scale);
-    _translation->setValue(quantizedTranslation);
-}
-
 ImportHeightfieldTool::ImportHeightfieldTool(MetavoxelEditor* editor) :
     HeightfieldTool(editor, "Import Heightfield"),
     _spanner(new Heightfield()) {
     
     _form->addRow("Height Scale:", _heightScale = new QDoubleSpinBox());
-    const double MAX_OFFSET_SCALE = 100000.0;
-    _heightScale->setMaximum(MAX_OFFSET_SCALE);
+    _heightScale->setMaximum(FLT_MAX);
     _heightScale->setSingleStep(0.01);
-    _heightScale->setValue(8.0);
+    _heightScale->setValue(16.0);
     connect(_heightScale, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this,
         &ImportHeightfieldTool::updateSpanner);
         
     _form->addRow("Height Offset:", _heightOffset = new QDoubleSpinBox());
-    _heightOffset->setMinimum(-MAX_OFFSET_SCALE);
-    _heightOffset->setMaximum(MAX_OFFSET_SCALE);
+    _heightOffset->setMinimum(-FLT_MAX);
+    _heightOffset->setMaximum(FLT_MAX);
     _heightOffset->setSingleStep(0.01);
     connect(_heightOffset, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this,
         &ImportHeightfieldTool::updateSpanner);
@@ -780,7 +762,7 @@ ImportHeightfieldTool::ImportHeightfieldTool(MetavoxelEditor* editor) :
     connect(_color, &HeightfieldColorEditor::colorChanged, this, &ImportHeightfieldTool::updateSpanner);
     
     connect(_translation, &Vec3Editor::valueChanged, this, &ImportHeightfieldTool::updateSpanner);
-    connect(_scale, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this,
+    connect(_spacing, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this,
         &ImportHeightfieldTool::updateSpanner);
 }
 
@@ -789,77 +771,16 @@ void ImportHeightfieldTool::simulate(float deltaTime) {
 }
 
 void ImportHeightfieldTool::renderPreview() {
-    static_cast<Heightfield*>(_spanner.data())->getRenderer()->render();
+    static_cast<Heightfield*>(_spanner.data())->getRenderer()->render(Application::getInstance()->getMetavoxels()->getLOD());
 }
 
-const int HEIGHTFIELD_BLOCK_SIZE = 256;
-
 void ImportHeightfieldTool::apply() {
     AttributePointer attribute = AttributeRegistry::getInstance()->getAttribute(_editor->getSelectedAttribute());
     if (!(_height->getHeight() && attribute)) {
         return;
     }
-    int width = _height->getHeight()->getWidth();
-    const QVector<quint16>& contents = _height->getHeight()->getContents();
-    int height = contents.size() / width;
-    int innerWidth = width - HeightfieldHeight::HEIGHT_EXTENSION;
-    int innerHeight = height - HeightfieldHeight::HEIGHT_EXTENSION;
-    float scale = pow(2.0, _scale->value());
-    
-    for (int i = 0; i < innerHeight; i += HEIGHTFIELD_BLOCK_SIZE) {
-        for (int j = 0; j < innerWidth; j += HEIGHTFIELD_BLOCK_SIZE) {
-            Heightfield* heightfield = new Heightfield();
-            
-            int extendedHeightSize = HEIGHTFIELD_BLOCK_SIZE + HeightfieldHeight::HEIGHT_EXTENSION;
-            QVector<quint16> heightContents(extendedHeightSize * extendedHeightSize);
-            quint16* dest = heightContents.data();
-            const quint16* src = contents.constData() + i * width + j;
-            int copyWidth = qMin(width - j, extendedHeightSize);
-            int copyHeight = qMin(height - i, extendedHeightSize);
-            for (int z = 0; z < copyHeight; z++, src += width, dest += extendedHeightSize) {
-                memcpy(dest, src, copyWidth * sizeof(quint16));
-            }
-            heightfield->setHeight(HeightfieldHeightPointer(new HeightfieldHeight(extendedHeightSize, heightContents)));
-            
-            int materialWidth = HEIGHTFIELD_BLOCK_SIZE + HeightfieldData::SHARED_EDGE;
-            int materialHeight = materialWidth;
-            if (_color->getColor()) {
-                int colorWidth = _color->getColor()->getWidth();
-                const QByteArray& contents = _color->getColor()->getContents();
-                int colorHeight = contents.size() / (colorWidth * DataBlock::COLOR_BYTES);
-                int innerColorWidth = colorWidth - HeightfieldData::SHARED_EDGE;
-                int innerColorHeight = colorHeight - HeightfieldData::SHARED_EDGE;
-                materialWidth = HEIGHTFIELD_BLOCK_SIZE * innerColorWidth / innerWidth + HeightfieldData::SHARED_EDGE;
-                materialHeight = HEIGHTFIELD_BLOCK_SIZE * innerColorHeight / innerHeight + HeightfieldData::SHARED_EDGE;
-                QByteArray colorContents(materialWidth * materialHeight * DataBlock::COLOR_BYTES, 0);
-                int colorI = i * (materialWidth - HeightfieldData::SHARED_EDGE) / HEIGHTFIELD_BLOCK_SIZE;
-                int colorJ = j * (materialHeight - HeightfieldData::SHARED_EDGE) / HEIGHTFIELD_BLOCK_SIZE;
-                char* dest = colorContents.data();
-                const char* src = contents.constData() + (colorI * colorWidth + colorJ) * DataBlock::COLOR_BYTES;
-                int copyWidth = qMin(colorWidth - colorJ, materialWidth);
-                int copyHeight = qMin(colorHeight - colorI, materialHeight);
-                for (int z = 0; z < copyHeight; z++, src += colorWidth * DataBlock::COLOR_BYTES,
-                        dest += materialWidth * DataBlock::COLOR_BYTES) {
-                    memcpy(dest, src, copyWidth * DataBlock::COLOR_BYTES);
-                }
-                heightfield->setColor(HeightfieldColorPointer(new HeightfieldColor(materialWidth, colorContents)));
-                
-            } else {
-                heightfield->setColor(HeightfieldColorPointer(new HeightfieldColor(materialWidth,
-                    QByteArray(materialWidth * materialHeight * DataBlock::COLOR_BYTES, 0xFF))));
-            }
-            heightfield->setMaterial(HeightfieldMaterialPointer(new HeightfieldMaterial(materialWidth,
-                QByteArray(materialWidth * materialHeight, 0), QVector<SharedObjectPointer>())));
-            
-            heightfield->setScale(scale);
-            heightfield->setAspectY(_heightScale->value() / scale);
-            heightfield->setTranslation(_translation->getValue() + glm::vec3((j / HEIGHTFIELD_BLOCK_SIZE) * scale,
-                _heightOffset->value(), (i / HEIGHTFIELD_BLOCK_SIZE) * scale));
-            
-            MetavoxelEditMessage message = { QVariant::fromValue(InsertSpannerEdit(attribute, heightfield)) };
-            Application::getInstance()->getMetavoxels()->applyEdit(message, true);
-        }
-    }
+    MetavoxelEditMessage message = { QVariant::fromValue(InsertSpannerEdit(attribute, _spanner->clone())) };
+    Application::getInstance()->getMetavoxels()->applyEdit(message, true);       
 }
 
 void ImportHeightfieldTool::updateSpanner() {
@@ -867,15 +788,14 @@ void ImportHeightfieldTool::updateSpanner() {
     heightfield->setHeight(_height->getHeight());
     heightfield->setColor(_color->getColor());
     
-    float scale = pow(2.0, _scale->value());
+    float scale = 1.0f;
     float aspectZ = 1.0f;
     if (_height->getHeight()) {
         int width = _height->getHeight()->getWidth();
         int innerWidth = width - HeightfieldHeight::HEIGHT_EXTENSION;
         int innerHeight = _height->getHeight()->getContents().size() / width - HeightfieldHeight::HEIGHT_EXTENSION;
-        float widthBlocks = glm::ceil((float)innerWidth / HEIGHTFIELD_BLOCK_SIZE);
-        scale *= widthBlocks;
-        aspectZ = glm::ceil((float)innerHeight / HEIGHTFIELD_BLOCK_SIZE) / widthBlocks;
+        scale = innerWidth * _spacing->value();
+        aspectZ = (float)innerHeight / innerWidth;
     }
     heightfield->setScale(scale);
     heightfield->setAspectY(_heightScale->value() / scale);
@@ -970,7 +890,8 @@ MaterialControl::MaterialControl(QWidget* widget, QFormLayout* form, bool cleara
 SharedObjectPointer MaterialControl::getMaterial() {
     SharedObjectPointer material = _materialEditor->getObject();
     if (static_cast<MaterialObject*>(material.data())->getDiffuse().isValid()) {
-        _materialEditor->detachObject();
+        material = material->clone();
+        
     } else {
         material = SharedObjectPointer();
     }
@@ -1087,10 +1008,7 @@ bool VoxelMaterialSpannerTool::appliesTo(const AttributePointer& attribute) cons
     return attribute->inherits("VoxelColorAttribute");
 }
 
-SharedObjectPointer VoxelMaterialSpannerTool::getSpanner(bool detach) {
-    if (detach) {
-        _spannerEditor->detachObject();
-    }
+SharedObjectPointer VoxelMaterialSpannerTool::getSpanner() {
     return _spannerEditor->getObject();
 }
 
@@ -1099,7 +1017,7 @@ QColor VoxelMaterialSpannerTool::getColor() {
 }
 
 void VoxelMaterialSpannerTool::applyEdit(const AttributePointer& attribute, const SharedObjectPointer& spanner) {
-    _spannerEditor->detachObject();
+    static_cast<Spanner*>(spanner.data())->setWillBeVoxelized(true);
     MetavoxelEditMessage message = { QVariant::fromValue(VoxelMaterialSpannerEdit(spanner,
         _materialControl->getMaterial(), _materialControl->getColor())) };
     Application::getInstance()->getMetavoxels()->applyEdit(message, true);

interface/src/ui/MetavoxelEditor.h

@@ -46,7 +46,6 @@ public:
     glm::quat getGridRotation() const;
     
     QVariant getValue() const;
-    void detachValue();
     
     virtual bool eventFilter(QObject* watched, QEvent* event);
 
@@ -197,7 +196,7 @@ public:
 protected:
 
     virtual QColor getColor();
-    virtual SharedObjectPointer getSpanner(bool detach = false);
+    virtual SharedObjectPointer getSpanner();
     virtual void applyEdit(const AttributePointer& attribute, const SharedObjectPointer& spanner) = 0;
 
 protected slots:
@@ -260,8 +259,6 @@ public:
     
     virtual bool appliesTo(const AttributePointer& attribute) const;
 
-    virtual void render();
-    
 protected slots:
 
     virtual void apply() = 0;
@@ -270,7 +267,7 @@ protected:
     
     QFormLayout* _form;
     Vec3Editor* _translation;
-    QDoubleSpinBox* _scale;
+    QDoubleSpinBox* _spacing;
 };
 
 /// Allows importing a heightfield.
@@ -425,7 +422,7 @@ public:
 
 protected:
 
-    virtual SharedObjectPointer getSpanner(bool detach = false);
+    virtual SharedObjectPointer getSpanner();
     virtual QColor getColor();
     virtual void applyEdit(const AttributePointer& attribute, const SharedObjectPointer& spanner);
     

interface/src/ui/NodeBounds.cpp

@@ -38,12 +38,7 @@ void NodeBounds::draw() {
     // Compute ray to find selected nodes later on.  We can't use the pre-computed ray in Application because it centers
     // itself after the cursor disappears.
     Application* application = Application::getInstance();
-    GLCanvas* glWidget = application->getGLWidget();
-    float mouseX = application->getMouseX() / (float)glWidget->width();
-    float mouseY = application->getMouseY() / (float)glWidget->height();
-    glm::vec3 mouseRayOrigin;
-    glm::vec3 mouseRayDirection;
-    application->getViewFrustum()->computePickRay(mouseX, mouseY, mouseRayOrigin, mouseRayDirection);
+    PickRay pickRay = application->getCamera()->computeViewPickRay(application->getTrueMouseX(), application->getTrueMouseY());
 
     // Variables to keep track of the selected node and properties to draw the cube later if needed
     Node* selectedNode = NULL;
@@ -106,8 +101,8 @@ void NodeBounds::draw() {
 
                 float distance;
                 BoxFace face;
-                bool inside = serverBounds.contains(mouseRayOrigin);
-                bool colliding = serverBounds.findRayIntersection(mouseRayOrigin, mouseRayDirection, distance, face);
+                bool inside = serverBounds.contains(pickRay.origin);
+                bool colliding = serverBounds.findRayIntersection(pickRay.origin, pickRay.direction, distance, face);
 
                 // If the camera is inside a node it will be "selected" if you don't have your cursor over another node
                 // that you aren't inside.
@@ -225,8 +220,8 @@ void NodeBounds::drawOverlay() {
         const int MOUSE_OFFSET = 10;
         const int BACKGROUND_BEVEL = 3;
 
-        int mouseX = application->getMouseX(),
-            mouseY = application->getMouseY(),
+        int mouseX = application->getTrueMouseX(),
+            mouseY = application->getTrueMouseY(),
             textWidth = widthText(TEXT_SCALE, 0, _overlayText);
         glColor4f(0.4f, 0.4f, 0.4f, 0.6f);
         renderBevelCornersRect(mouseX + MOUSE_OFFSET, mouseY - TEXT_HEIGHT - PADDING,

interface/src/ui/overlays/Base3DOverlay.cpp

@@ -167,7 +167,7 @@ QScriptValue Base3DOverlay::getProperty(const QString& property) {
 }
 
 bool Base3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                                        float& distance, BoxFace& face) const {
+                                                        float& distance, BoxFace& face) {
     return false;
 }
 

interface/src/ui/overlays/Base3DOverlay.h

@@ -50,10 +50,10 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face);
 
     virtual bool findRayIntersectionExtraInfo(const glm::vec3& origin, const glm::vec3& direction, 
-                                                    float& distance, BoxFace& face, QString& extraInfo) const {
+                                                    float& distance, BoxFace& face, QString& extraInfo) {
             return findRayIntersection(origin, direction, distance, face);
     }
 

interface/src/ui/overlays/BillboardOverlay.cpp

@@ -213,7 +213,7 @@ void BillboardOverlay::replyFinished() {
 }
 
 bool BillboardOverlay::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                                        float& distance, BoxFace& face) const {
+                                                        float& distance, BoxFace& face) {
 
     if (_billboardTexture) {
         float maxSize = glm::max(_fromImage.width(), _fromImage.height());

interface/src/ui/overlays/BillboardOverlay.h

@@ -35,7 +35,7 @@ public:
     void setClipFromSource(const QRect& bounds) { _fromImage = bounds; }
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face);
     
     virtual BillboardOverlay* createClone() const;
 

interface/src/ui/overlays/Circle3DOverlay.cpp

@@ -355,7 +355,7 @@ QScriptValue Circle3DOverlay::getProperty(const QString& property) {
 
 
 bool Circle3DOverlay::findRayIntersection(const glm::vec3& origin, 
-                                const glm::vec3& direction, float& distance, BoxFace& face) const {
+                                const glm::vec3& direction, float& distance, BoxFace& face) {
 
     bool intersects = Planar3DOverlay::findRayIntersection(origin, direction, distance, face);
     if (intersects) {

interface/src/ui/overlays/Circle3DOverlay.h

@@ -48,7 +48,7 @@ public:
     void setMajorTickMarksColor(const xColor& value) { _majorTickMarksColor = value; }
     void setMinorTickMarksColor(const xColor& value) { _minorTickMarksColor = value; }
 
-    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face);
 
     virtual Circle3DOverlay* createClone() const;
     

interface/src/ui/overlays/ModelOverlay.cpp

@@ -170,14 +170,14 @@ QScriptValue ModelOverlay::getProperty(const QString& property) {
 }
 
 bool ModelOverlay::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                                        float& distance, BoxFace& face) const {
+                                                        float& distance, BoxFace& face) {
     
     QString subMeshNameTemp;
     return _model.findRayIntersectionAgainstSubMeshes(origin, direction, distance, face, subMeshNameTemp);
 }
 
 bool ModelOverlay::findRayIntersectionExtraInfo(const glm::vec3& origin, const glm::vec3& direction,
-                                                        float& distance, BoxFace& face, QString& extraInfo) const {
+                                                        float& distance, BoxFace& face, QString& extraInfo) {
     
     return _model.findRayIntersectionAgainstSubMeshes(origin, direction, distance, face, extraInfo);
 }

interface/src/ui/overlays/ModelOverlay.h

@@ -26,9 +26,9 @@ public:
     virtual void render(RenderArgs* args);
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
-    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face);
     virtual bool findRayIntersectionExtraInfo(const glm::vec3& origin, const glm::vec3& direction, 
-                                                    float& distance, BoxFace& face, QString& extraInfo) const;
+                                                    float& distance, BoxFace& face, QString& extraInfo);
 
     virtual ModelOverlay* createClone() const;
 

interface/src/ui/overlays/Overlays.cpp

@@ -11,6 +11,7 @@
 #include <limits>
 #include <typeinfo>
 #include <Application.h>
+#include <devices/OculusManager.h>
 #include <Menu.h>
 #include <QScriptValueIterator>
 
@@ -244,6 +245,11 @@ void Overlays::deleteOverlay(unsigned int id) {
 }
 
 unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
+    glm::vec2 pointCopy = point;
+    if (OculusManager::isConnected()) {
+        pointCopy = Application::getInstance()->getApplicationOverlay().screenToOverlay(point);
+    }
+    
     QReadLocker lock(&_lock);
     QMapIterator<unsigned int, Overlay*> i(_overlays2D);
     i.toBack();
@@ -251,7 +257,8 @@ unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
         i.previous();
         unsigned int thisID = i.key();
         Overlay2D* thisOverlay = static_cast<Overlay2D*>(i.value());
-        if (thisOverlay->getVisible() && thisOverlay->isLoaded() && thisOverlay->getBounds().contains(point.x, point.y, false)) {
+        if (thisOverlay->getVisible() && thisOverlay->isLoaded() &&
+            thisOverlay->getBounds().contains(pointCopy.x, pointCopy.y, false)) {
             return thisID;
         }
     }

interface/src/ui/overlays/Planar3DOverlay.cpp

@@ -92,7 +92,7 @@ QScriptValue Planar3DOverlay::getProperty(const QString& property) {
 }
 
 bool Planar3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                                        float& distance, BoxFace& face) const {
+                                                        float& distance, BoxFace& face) {
 
     RayIntersectionInfo rayInfo;
     rayInfo._rayStart = origin;

interface/src/ui/overlays/Planar3DOverlay.h

@@ -39,7 +39,7 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face);
 
 protected:
     glm::vec2 _dimensions;

interface/src/ui/overlays/Volume3DOverlay.cpp

@@ -100,7 +100,7 @@ QScriptValue Volume3DOverlay::getProperty(const QString& property) {
 }
 
 bool Volume3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
-                                                        float& distance, BoxFace& face) const {
+                                                        float& distance, BoxFace& face) {
 
     // extents is the entity relative, scaled, centered extents of the entity
     glm::vec3 position = getPosition();

interface/src/ui/overlays/Volume3DOverlay.h

@@ -41,7 +41,7 @@ public:
     virtual void setProperties(const QScriptValue& properties);
     virtual QScriptValue getProperty(const QString& property);
 
-    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face) const;
+    virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face);
 
 protected:
     glm::vec3 _dimensions;

libraries/audio/src/AudioScriptingInterface.cpp

@@ -85,6 +85,13 @@ bool AudioScriptingInterface::isInjectorPlaying(AudioInjector* injector) {
     return (injector != NULL);
 }
 
+void AudioScriptingInterface::setInjectorOptions(AudioInjector* injector, const AudioInjectorOptions& injectorOptions) {
+    AudioInjectorOptions optionsCopy = injectorOptions;
+    if (injector) {
+        injector->setOptions(optionsCopy);
+    }
+}
+
 float AudioScriptingInterface::getLoudness(AudioInjector* injector) {
     if (injector) {
         return injector->getLoudness();

libraries/audio/src/AudioScriptingInterface.h

@@ -35,6 +35,8 @@ public slots:
     void stopInjector(AudioInjector* injector);
     bool isInjectorPlaying(AudioInjector* injector);
     
+    void setInjectorOptions(AudioInjector* injector, const AudioInjectorOptions& injectorOptions);
+    
     void injectorStopped();
     
 signals:

libraries/entities/src/EntityItem.h

@@ -137,7 +137,7 @@ public:
     virtual bool supportsDetailedRayIntersection() const { return false; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) const { return true; }
+                         void** intersectedObject, bool precisionPicking) const { return true; }
 
     // attributes applicable to all entity types
     EntityTypes::EntityType getType() const { return _type; }
@@ -159,7 +159,7 @@ public:
     float getLargestDimension() const { return glm::length(_dimensions); } /// get the largest possible dimension
 
     /// set dimensions in domain scale units (0.0 - 1.0) this will also reset radius appropriately
-    void setDimensions(const glm::vec3& value) { _dimensions = value; recalculateCollisionShape(); }
+    virtual void setDimensions(const glm::vec3& value) { _dimensions = value; recalculateCollisionShape(); }
 
     /// set dimensions in meter units (0.0 - TREE_SCALE) this will also reset radius appropriately
     void setDimensionsInMeters(const glm::vec3& value) { setDimensions(value / (float) TREE_SCALE); }

libraries/entities/src/EntityScriptingInterface.cpp

@@ -196,22 +196,26 @@ QVector<EntityItemID> EntityScriptingInterface::findEntities(const glm::vec3& ce
     return result;
 }
 
-RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersection(const PickRay& ray) {
-    return findRayIntersectionWorker(ray, Octree::TryLock);
+RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersection(const PickRay& ray, bool precisionPicking) {
+    return findRayIntersectionWorker(ray, Octree::TryLock, precisionPicking);
 }
 
-RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionBlocking(const PickRay& ray) {
-    return findRayIntersectionWorker(ray, Octree::Lock);
+RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionBlocking(const PickRay& ray, bool precisionPicking) {
+    return findRayIntersectionWorker(ray, Octree::Lock, precisionPicking);
 }
 
 RayToEntityIntersectionResult EntityScriptingInterface::findRayIntersectionWorker(const PickRay& ray, 
-                                                                                    Octree::lockType lockType) {
+                                                                                    Octree::lockType lockType, 
+                                                                                    bool precisionPicking) {
+
+
     RayToEntityIntersectionResult result;
     if (_entityTree) {
         OctreeElement* element;
         EntityItem* intersectedEntity = NULL;
         result.intersects = _entityTree->findRayIntersection(ray.origin, ray.direction, element, result.distance, result.face, 
-                                                                (void**)&intersectedEntity, lockType, &result.accurate);
+                                                                (void**)&intersectedEntity, lockType, &result.accurate, 
+                                                                precisionPicking);
         if (result.intersects && intersectedEntity) {
             result.entityID = intersectedEntity->getEntityItemID();
             result.properties = intersectedEntity->getProperties();

libraries/entities/src/EntityScriptingInterface.h

@@ -90,11 +90,11 @@ public slots:
     /// If the scripting context has visible voxels, this will determine a ray intersection, the results
     /// may be inaccurate if the engine is unable to access the visible voxels, in which case result.accurate
     /// will be false.
-    Q_INVOKABLE RayToEntityIntersectionResult findRayIntersection(const PickRay& ray);
+    Q_INVOKABLE RayToEntityIntersectionResult findRayIntersection(const PickRay& ray, bool precisionPicking = false);
 
     /// If the scripting context has visible voxels, this will determine a ray intersection, and will block in
     /// order to return an accurate result
-    Q_INVOKABLE RayToEntityIntersectionResult findRayIntersectionBlocking(const PickRay& ray);
+    Q_INVOKABLE RayToEntityIntersectionResult findRayIntersectionBlocking(const PickRay& ray, bool precisionPicking = false);
 
     Q_INVOKABLE void setLightsArePickable(bool value);
     Q_INVOKABLE bool getLightsArePickable() const;
@@ -124,7 +124,8 @@ private:
     void queueEntityMessage(PacketType packetType, EntityItemID entityID, const EntityItemProperties& properties);
 
     /// actually does the work of finding the ray intersection, can be called in locking mode or tryLock mode
-    RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType);
+    RayToEntityIntersectionResult findRayIntersectionWorker(const PickRay& ray, Octree::lockType lockType, 
+                                                                        bool precisionPicking);
 
     uint32_t _nextCreatorTokenID;
     EntityTree* _entityTree;

libraries/entities/src/EntityTree.cpp

@@ -19,9 +19,13 @@
 #include "MovingEntitiesOperator.h"
 #include "UpdateEntityOperator.h"
 
-EntityTree::EntityTree(bool shouldReaverage) : Octree(shouldReaverage), _simulation(NULL) {
+EntityTree::EntityTree(bool shouldReaverage) : 
+    Octree(shouldReaverage), 
+    _fbxService(NULL),
+    _lightsArePickable(true),
+    _simulation(NULL)
+{
     _rootElement = createNewElement();
-    _lightsArePickable = true; // assume they are by default
 }
 
 EntityTree::~EntityTree() {

libraries/entities/src/EntityTreeElement.cpp

@@ -475,13 +475,17 @@ bool EntityTreeElement::bestFitBounds(const glm::vec3& minPoint, const glm::vec3
 
 bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) {
+                         void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
 
     // only called if we do intersect our bounding cube, but find if we actually intersect with entities...
+    int entityNumber = 0;
     
     QList<EntityItem*>::iterator entityItr = _entityItems->begin();
     QList<EntityItem*>::const_iterator entityEnd = _entityItems->end();
     bool somethingIntersected = false;
+    
+    //float bestEntityDistance = distance;
+    
     while(entityItr != entityEnd) {
         EntityItem* entity = (*entityItr);
         
@@ -513,10 +517,9 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
                 if (localDistance < distance) {
                     // now ask the entity if we actually intersect
                     if (entity->supportsDetailedRayIntersection()) {
-                    
                         if (entity->findDetailedRayIntersection(origin, direction, keepSearching, element, localDistance, 
-                                                                    localFace, intersectedObject)) {
-                                                                    
+                                                                    localFace, intersectedObject, precisionPicking)) {
+    
                             if (localDistance < distance) {
                                 distance = localDistance;
                                 face = localFace;
@@ -538,6 +541,7 @@ bool EntityTreeElement::findDetailedRayIntersection(const glm::vec3& origin, con
         }
         
         ++entityItr;
+        entityNumber++;
     }
     return somethingIntersected;
 }

libraries/entities/src/EntityTreeElement.h

@@ -137,7 +137,7 @@ public:
     virtual bool canRayIntersect() const { return hasEntities(); }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject);
+                         void** intersectedObject, bool precisionPicking, float distanceToElementCube);
 
     virtual bool findSpherePenetration(const glm::vec3& center, float radius,
                         glm::vec3& penetration, void** penetratedObject) const;

libraries/entities/src/LightEntityItem.cpp

@@ -47,6 +47,13 @@ LightEntityItem::LightEntityItem(const EntityItemID& entityItemID, const EntityI
     _emptyShape.setRadius(0.0f);
 }
 
+void LightEntityItem::setDimensions(const glm::vec3& value) {
+    float maxDimension = glm::max(value.x, value.y, value.z);
+    _dimensions = glm::vec3(maxDimension, maxDimension, maxDimension); 
+    recalculateCollisionShape(); 
+}
+
+
 EntityItemProperties LightEntityItem::getProperties() const {
     EntityItemProperties properties = EntityItem::getProperties(); // get the properties from our base class
 

libraries/entities/src/LightEntityItem.h

@@ -22,6 +22,9 @@ public:
     LightEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
     
     ALLOW_INSTANTIATION // This class can be instantiated
+
+    /// set dimensions in domain scale units (0.0 - 1.0) this will also reset radius appropriately
+    virtual void setDimensions(const glm::vec3& value);
     
     // methods for getting/setting all properties of an entity
     virtual EntityItemProperties getProperties() const;

libraries/entities/src/SphereEntityItem.cpp

@@ -10,9 +10,12 @@
 //
 
 
+#include <glm/gtx/transform.hpp>
+
 #include <QDebug>
 
 #include <ByteCountCoding.h>
+#include <GeometryUtil.h>
 
 #include "EntityTree.h"
 #include "EntityTreeElement.h"
@@ -96,19 +99,25 @@ void SphereEntityItem::recalculateCollisionShape() {
 
 bool SphereEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                      bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                     void** intersectedObject) const {
-                     
-    // NOTE: origin and direction are in tree units. But our _sphereShape is in meters, so we need to
-    // do a little math to make these match each other.
-    RayIntersectionInfo rayInfo;
-    rayInfo._rayStart = origin * (float)TREE_SCALE;
-    rayInfo._rayDirection = direction;
+                     void** intersectedObject, bool precisionPicking) const {
+    // determine the ray in the frame of the entity transformed from a unit sphere
+    glm::mat4 translation = glm::translate(getPosition());
+    glm::mat4 rotation = glm::mat4_cast(getRotation());
+    glm::mat4 scale = glm::scale(getDimensions());
+    glm::mat4 registration = glm::translate(glm::vec3(0.5f, 0.5f, 0.5f) - getRegistrationPoint());
+    glm::mat4 entityToWorldMatrix = translation * rotation * scale * registration;
+    glm::mat4 worldToEntityMatrix = glm::inverse(entityToWorldMatrix);
+    glm::vec3 entityFrameOrigin = glm::vec3(worldToEntityMatrix * glm::vec4(origin, 1.0f));
+    glm::vec3 entityFrameDirection = glm::normalize(glm::vec3(worldToEntityMatrix * glm::vec4(direction, 1.0f)));
 
-    // TODO: Note this is really doing ray intersections against a sphere, which is fine except in cases
-    // where our dimensions actually make us an ellipsoid. But we'll live with this for now until we
-    // get a more full fledged physics library
-    if (_sphereShape.findRayIntersection(rayInfo)) {
-        distance = rayInfo._hitDistance / (float)TREE_SCALE;
+    float localDistance;
+    // NOTE: unit sphere has center of 0,0,0 and radius of 0.5
+    if (findRaySphereIntersection(entityFrameOrigin, entityFrameDirection, glm::vec3(0.0f), 0.5f, localDistance)) {
+        // determine where on the unit sphere the hit point occured
+        glm::vec3 entityFrameHitAt = entityFrameOrigin + (entityFrameDirection * localDistance);
+        // then translate back to work coordinates
+        glm::vec3 hitAt = glm::vec3(entityToWorldMatrix * glm::vec4(entityFrameHitAt, 1.0f));
+        distance = glm::distance(origin,hitAt);
         return true;
     }
     return false;                

libraries/entities/src/SphereEntityItem.h

@@ -59,8 +59,8 @@ public:
     virtual bool supportsDetailedRayIntersection() const { return true; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) const;
-    
+                         void** intersectedObject, bool precisionPicking) const;
+
 protected:
     virtual void recalculateCollisionShape();
 

libraries/entities/src/TextEntityItem.cpp

@@ -40,6 +40,13 @@ TextEntityItem::TextEntityItem(const EntityItemID& entityItemID, const EntityIte
     setProperties(properties, true);
 }
 
+void TextEntityItem::setDimensions(const glm::vec3& value) {
+    // NOTE: Text Entities always have a "depth" of 1cm.
+    float fixedDepth = 0.01f / (float)TREE_SCALE;
+    _dimensions = glm::vec3(value.x, value.y, fixedDepth); 
+    recalculateCollisionShape(); 
+}
+
 EntityItemProperties TextEntityItem::getProperties() const {
     EntityItemProperties properties = EntityItem::getProperties(); // get the properties from our base class
 
@@ -118,7 +125,7 @@ void TextEntityItem::appendSubclassData(OctreePacketData* packetData, EncodeBits
 
 bool TextEntityItem::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                      bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                     void** intersectedObject) const {
+                     void** intersectedObject, bool precisionPicking) const {
                      
     RayIntersectionInfo rayInfo;
     rayInfo._rayStart = origin;

libraries/entities/src/TextEntityItem.h

@@ -21,6 +21,9 @@ public:
     TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties);
     
     ALLOW_INSTANTIATION // This class can be instantiated
+
+    /// set dimensions in domain scale units (0.0 - 1.0) this will also reset radius appropriately
+    virtual void setDimensions(const glm::vec3& value);
     
     // methods for getting/setting all properties of an entity
     virtual EntityItemProperties getProperties() const;
@@ -44,7 +47,7 @@ public:
     virtual bool supportsDetailedRayIntersection() const { return true; }
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) const;
+                         void** intersectedObject, bool precisionPicking) const;
 
     static const QString DEFAULT_TEXT;
     void setText(const QString& value) { _text = value; }

libraries/fbx/src/FBXReader.cpp

@@ -1046,6 +1046,7 @@ FBXBlendshape extractBlendshape(const FBXNode& object) {
     return blendshape;
 }
 
+
 void setTangents(FBXMesh& mesh, int firstIndex, int secondIndex) {
     const glm::vec3& normal = mesh.normals.at(firstIndex);
     glm::vec3 bitangent = glm::cross(normal, mesh.vertices.at(secondIndex) - mesh.vertices.at(firstIndex));
@@ -1194,6 +1195,44 @@ int matchTextureUVSetToAttributeChannel(const std::string& texUVSetName, const Q
     }
 }
 
+
+FBXLight extractLight(const FBXNode& object) {
+    FBXLight light;
+
+    foreach (const FBXNode& subobject, object.children) {
+        std::string childname = QString(subobject.name).toStdString();
+        if (subobject.name == "Properties70") {
+            foreach (const FBXNode& property, subobject.children) {
+                int valIndex = 4;
+                std::string propName = QString(property.name).toStdString();
+                if (property.name == "P") {
+                    std::string propname = property.properties.at(0).toString().toStdString();
+                    if (propname == "Intensity") {
+                        light.intensity = 0.01f * property.properties.at(valIndex).value<double>();
+                    }
+                }
+            }
+        } else if ( subobject.name == "GeometryVersion"
+                   || subobject.name == "TypeFlags") {
+        }
+    }
+#if defined(DEBUG_FBXREADER)
+
+    std::string type = object.properties.at(0).toString().toStdString();
+    type = object.properties.at(1).toString().toStdString();
+    type = object.properties.at(2).toString().toStdString();
+
+    foreach (const QVariant& prop, object.properties) {
+        std::string proptype = prop.typeName();
+        std::string propval = prop.toString().toStdString();
+        if (proptype == "Properties70") {
+        }
+    }
+#endif
+
+    return light;
+}
+
 FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping, bool loadLightmaps, float lightmapLevel) {
     QHash<QString, ExtractedMesh> meshes;
     QHash<QString, QString> modelIDsToNames;
@@ -1222,6 +1261,8 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
     QHash<QString, QString> yComponents;
     QHash<QString, QString> zComponents;
 
+    std::map<std::string, FBXLight> lights;
+
     QVariantHash joints = mapping.value("joint").toHash();
     QString jointEyeLeftName = processID(getString(joints.value("jointEyeLeft", "jointEyeLeft")));
     QString jointEyeRightName = processID(getString(joints.value("jointEyeRight", "jointEyeRight")));
@@ -1276,6 +1317,8 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
 #endif
     FBXGeometry geometry;
     float unitScaleFactor = 1.0f;
+    glm::vec3 ambientColor;
+    QString hifiGlobalNodeID;
     foreach (const FBXNode& child, node.children) {
     
         if (child.name == "FBXHeaderExtension") {
@@ -1302,10 +1345,16 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
         } else if (child.name == "GlobalSettings") {
             foreach (const FBXNode& object, child.children) {
                 if (object.name == "Properties70") {
+                    QString propertyName = "P";
+                    int index = 4;
                     foreach (const FBXNode& subobject, object.children) {
-                        if (subobject.name == "P" && subobject.properties.size() >= 5 &&
-                                subobject.properties.at(0) == "UnitScaleFactor") {
-                            unitScaleFactor = subobject.properties.at(4).toFloat();
+                        if (subobject.name == propertyName) {
+                            std::string subpropName = subobject.properties.at(0).toString().toStdString();
+                            if (subpropName == "UnitScaleFactor") {
+                                unitScaleFactor = subobject.properties.at(index).toFloat();
+                            } else if (subpropName == "AmbientColor") {
+                                ambientColor = getVec3(subobject.properties, index);
+                            }
                         }
                     }
                 }
@@ -1324,6 +1373,11 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                     QString id = getID(object.properties);
                     modelIDsToNames.insert(id, name);
 
+                    std::string modelname = name.toLower().toStdString();
+                    if (modelname.find("hifi") == 0) {
+                        hifiGlobalNodeID = id;
+                    }
+
                     if (name == jointEyeLeftName || name == "EyeL" || name == "joint_Leye") {
                         jointEyeLeftID = getID(object.properties);
 
@@ -1354,6 +1408,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                     } else if (name == "RightToe" || name == "joint_R_toe" || name == "RightToe_End") {
                         jointRightToeID = getID(object.properties);
                     }
+
                     int humanIKJointIndex = humanIKJointNames.indexOf(name);
                     if (humanIKJointIndex != -1) {
                         humanIKJointIDs[humanIKJointIndex] = getID(object.properties);
@@ -1450,6 +1505,25 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                                 extractBlendshape(subobject) };
                             blendshapes.append(blendshape);
                         }
+#if defined(DEBUG_FBXREADER)
+                        else if (subobject.name == "TypeFlags") {
+                            std::string attributetype = subobject.properties.at(0).toString().toStdString();
+                            if (!attributetype.empty()) {
+                                if (attributetype == "Light") {
+                                    std::string lightprop; 
+                                    foreach (const QVariant& vprop, subobject.properties) {
+                                        lightprop = vprop.toString().toStdString();
+                                    }
+
+                                    FBXLight light = extractLight(object);
+                                }
+                            }
+                        } else {
+                            std::string whatisthat = subobject.name;
+                            if (whatisthat == "WTF") {
+                            } 
+                        }
+#endif
                     }
                     
                     // add the blendshapes included in the model, if any
@@ -1477,7 +1551,6 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
 
                 } else if (object.name == "Texture") {
                     TextureParam tex;
-                    bool texparam = false;
                     foreach (const FBXNode& subobject, object.children) {
                         if (subobject.name == "RelativeFilename") {
                             // trim off any path information
@@ -1625,11 +1698,28 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                     materials.insert(material.id, material);
 
                 } else if (object.name == "NodeAttribute") {
+#if defined(DEBUG_FBXREADER)
+                    std::vector<std::string> properties;
+                    foreach(const QVariant& v, object.properties) {
+                        properties.push_back(v.toString().toStdString());
+                    }
+#endif
+                    std::string attribID = getID(object.properties).toStdString();
+                    std::string attributetype;
                     foreach (const FBXNode& subobject, object.children) {
                         if (subobject.name == "TypeFlags") {
                             typeFlags.insert(getID(object.properties), subobject.properties.at(0).toString());
+                            attributetype = subobject.properties.at(0).toString().toStdString();
                         }
                     }
+
+                    if (!attributetype.empty()) {
+                        if (attributetype == "Light") {
+                            FBXLight light = extractLight(object);
+                            lights[attribID] = light;
+                        }
+                    }
+
                 } else if (object.name == "Deformer") {
                     if (object.properties.last() == "Cluster") {
                         Cluster cluster;
@@ -1667,7 +1757,20 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                         }
                     }
                     animationCurves.insert(getID(object.properties), curve);
+                
                 }
+#if defined(DEBUG_FBXREADER)
+                 else {
+                    std::string objectname = object.name.data();
+                    if ( objectname == "Pose"
+                        || objectname == "AnimationStack"
+                        || objectname == "AnimationLayer"
+                        || objectname == "AnimationCurveNode") {
+                    } else {
+                        unknown++;
+                    }
+                } 
+#endif
             }
         } else if (child.name == "Connections") {
             foreach (const FBXNode& connection, child.children) {
@@ -1676,6 +1779,15 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                         QString childID = getID(connection.properties, 1);
                         QString parentID = getID(connection.properties, 2);
                         ooChildToParent.insert(childID, parentID);
+                        if (!hifiGlobalNodeID.isEmpty() && (parentID == hifiGlobalNodeID)) {
+                            std::map< std::string, FBXLight >::iterator lit = lights.find(childID.toStdString());
+                            if (lit != lights.end()) {
+                                lightmapLevel = (*lit).second.intensity;
+                                if (lightmapLevel <= 0.0f) {
+                                    loadLightmaps = false;
+                                }
+                            }
+                        }
                     }
                     if (connection.properties.at(0) == "OP") {
                         int counter = 0;
@@ -1719,6 +1831,33 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                 }
             }
         }
+#if defined(DEBUG_FBXREADER)
+        else {
+            std::string objectname = child.name.data();
+            if ( objectname == "Pose"
+                || objectname == "CreationTime"
+                || objectname == "FileId"
+                || objectname == "Creator"
+                || objectname == "Documents"
+                || objectname == "References"
+                || objectname == "Definitions"
+                || objectname == "Takes"
+                || objectname == "AnimationStack"
+                || objectname == "AnimationLayer"
+                || objectname == "AnimationCurveNode") {
+            } else {
+                unknown++;
+            }
+        } 
+#endif
+    }
+
+    // TODO: check if is code is needed
+    if (!lights.empty()) {
+        if (hifiGlobalNodeID.isEmpty()) {
+            std::map< std::string, FBXLight >::iterator l = lights.begin();
+            lightmapLevel = (*l).second.intensity;
+        }
     }
 
     // assign the blendshapes to their corresponding meshes
@@ -1905,6 +2044,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
 
             extracted.mesh.meshExtents.minimum = glm::min(extracted.mesh.meshExtents.minimum, transformedVertex);
             extracted.mesh.meshExtents.maximum = glm::max(extracted.mesh.meshExtents.maximum, transformedVertex);
+            extracted.mesh.modelTransform = modelTransform;
         }
 
         // look for textures, material properties
@@ -1957,7 +2097,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
                 emissiveParams.y = lightmapLevel;
                 QString emissiveTextureID = emissiveTextures.value(childID);
                 QString ambientTextureID = ambientTextures.value(childID);
-                if (!emissiveTextureID.isNull() || !ambientTextureID.isNull()) {
+                if (loadLightmaps && (!emissiveTextureID.isNull() || !ambientTextureID.isNull())) {
 
                     if (!emissiveTextureID.isNull()) {
                         emissiveTexture = getTexture(emissiveTextureID, textureNames, textureFilenames, textureContent, textureParams);

libraries/fbx/src/FBXReader.h

@@ -149,6 +149,7 @@ public:
     QVector<FBXCluster> clusters;
 
     Extents meshExtents;
+    glm::mat4 modelTransform;
 
     bool isEye;
     
@@ -165,6 +166,22 @@ public:
     QVector<glm::quat> rotations;
 };
 
+/// A light in an FBX document.
+class FBXLight {
+public:
+    QString name;
+    Transform transform;
+    float intensity;
+    glm::vec3 color;
+
+    FBXLight() :
+        name(),
+        transform(),
+        intensity(1.0f),
+        color(1.0f)
+    {}
+};
+
 Q_DECLARE_METATYPE(FBXAnimationFrame)
 Q_DECLARE_METATYPE(QVector<FBXAnimationFrame>)
 

libraries/gpu/CMakeLists.txt

@@ -0,0 +1,46 @@
+set(TARGET_NAME gpu)
+
+# use setup_hifi_library macro to setup our project and link appropriate Qt modules
+setup_hifi_library()
+
+include_glm()
+
+link_hifi_libraries(shared)
+if (APPLE)
+  # link in required OS X frameworks and include the right GL headers
+  find_library(OpenGL OpenGL)
+
+  target_link_libraries(${TARGET_NAME} ${OpenGL})
+    
+else (APPLE)
+  find_package(OpenGL REQUIRED)
+  
+  if (${OPENGL_INCLUDE_DIR})
+    include_directories(SYSTEM "${OPENGL_INCLUDE_DIR}")
+  endif ()
+  
+  target_link_libraries(${TARGET_NAME} "${OPENGL_LIBRARY}")
+  
+  # link target to external libraries
+  if (WIN32)
+    find_package(GLEW REQUIRED)
+    include_directories(${GLEW_INCLUDE_DIRS})
+
+    # we're using static GLEW, so define GLEW_STATIC
+    add_definitions(-DGLEW_STATIC)
+
+    target_link_libraries(${TARGET_NAME} "${GLEW_LIBRARIES}" "${NSIGHT_LIBRARIES}" opengl32.lib)
+
+    # try to find the Nsight package and add it to the build if we find it
+    find_package(NSIGHT)
+    if (NSIGHT_FOUND)
+      include_directories(${NSIGHT_INCLUDE_DIRS})
+      add_definitions(-DNSIGHT_FOUND)
+      target_link_libraries(${TARGET_NAME} "${NSIGHT_LIBRARIES}")
+    endif ()
+
+  endif()
+endif (APPLE)
+
+# call macro to link our dependencies and bubble them up via a property on our target
+link_shared_dependencies()

libraries/gpu/src/gpu/Batch.h

@@ -12,13 +12,13 @@
 #define hifi_gpu_Batch_h
 
 #include <assert.h>
-#include "InterfaceConfig.h"
+#include "GPUConfig.h"
 
 #include "Transform.h"
 
 #include <vector>
 
-#include "gpu/Stream.h"
+#include "Stream.h"
 
 #if defined(NSIGHT_FOUND)
     #include "nvToolsExt.h"

libraries/gpu/src/gpu/Context.h

@@ -12,9 +12,9 @@
 #define hifi_gpu_Context_h
 
 #include <assert.h>
-#include "InterfaceConfig.h"
+#include "GPUConfig.h"
 
-#include "gpu/Resource.h"
+#include "Resource.h"
 
 namespace gpu {
 

libraries/gpu/src/gpu/Format.h

@@ -12,7 +12,7 @@
 #define hifi_gpu_Format_h
 
 #include <assert.h>
-#include "InterfaceConfig.h"
+#include "GPUConfig.h"
 
 
 namespace gpu {

libraries/gpu/src/gpu/GLBackend.cpp

@@ -12,7 +12,7 @@
 
 #include <QDebug>
 
-#include "gpu/Batch.h"
+#include "Batch.h"
 
 using namespace gpu;
 
@@ -445,7 +445,6 @@ void GLBackend::updateTransform() {
             _transform._lastMode = GL_PROJECTION;
         }
         CHECK_GL_ERROR();*/
-        _transform._invalidProj;
     }
 
     if (_transform._invalidModel || _transform._invalidView) {

libraries/gpu/src/gpu/GLBackend.h

@@ -12,10 +12,10 @@
 #define hifi_gpu_GLBackend_h
 
 #include <assert.h>
-#include "InterfaceConfig.h"
+#include "GPUConfig.h"
 
-#include "gpu/Context.h"
-#include "gpu/Batch.h"
+#include "Context.h"
+#include "Batch.h"
 #include <bitset>
 
 

libraries/gpu/src/gpu/GPUConfig.h

@@ -0,0 +1,32 @@
+//
+//  GPUConfig.h
+//  libraries/gpu/src/gpu
+//
+//  Created by Sam Gateau on 12/4/14.
+//  Copyright 2013 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 gpu__GPUConfig__
+#define gpu__GPUConfig__
+
+#define GL_GLEXT_PROTOTYPES 1
+
+#if defined(__APPLE__)
+#include <OpenGL/gl.h>
+#include <OpenGL/glext.h>
+
+#elif defined(WIN32)
+#include <GL/glew.h>
+#include <GL/wglew.h>
+
+#else
+#include <GL/gl.h>
+#include <GL/glext.h>
+
+
+#endif
+
+#endif

libraries/gpu/src/gpu/Resource.h

@@ -12,9 +12,9 @@
 #define hifi_gpu_Resource_h
 
 #include <assert.h>
-#include "InterfaceConfig.h"
+#include "GPUConfig.h"
 
-#include "gpu/Format.h"
+#include "Format.h"
 
 #include <vector>
 

libraries/gpu/src/gpu/Stream.h

@@ -12,10 +12,10 @@
 #define hifi_gpu_Stream_h
 
 #include <assert.h>
-#include "InterfaceConfig.h"
+#include "GPUConfig.h"
 
-#include "gpu/Resource.h"
-#include "gpu/Format.h"
+#include "Resource.h"
+#include "Format.h"
 #include <vector>
 #include <map>
 

libraries/metavoxels/src/AttributeRegistry.cpp

@@ -1274,25 +1274,37 @@ void SpannerSetAttribute::writeMetavoxelRoot(const MetavoxelNode& root, Metavoxe
 
 void SpannerSetAttribute::readMetavoxelDelta(MetavoxelData& data,
         const MetavoxelNode& reference, MetavoxelStreamState& state) {
-    forever {
-        SharedObjectPointer object;
-        state.base.stream >> object;
-        if (!object) {
-            break;
+    readMetavoxelSubdivision(data, state);
+}
+
+static void writeDeltaSubdivision(SharedObjectSet& oldSet, SharedObjectSet& newSet, Bitstream& stream) {
+    for (SharedObjectSet::iterator newIt = newSet.begin(); newIt != newSet.end(); ) {
+        SharedObjectSet::iterator oldIt = oldSet.find(*newIt);
+        if (oldIt == oldSet.end()) {
+            stream << *newIt; // added
+            newIt = newSet.erase(newIt);
+            
+        } else {
+            oldSet.erase(oldIt);
+            newIt++;
         }
-        data.toggle(state.base.attribute, object);
     }
-    // even if the root is empty, it should still exist
-    if (!data.getRoot(state.base.attribute)) {
-        data.createRoot(state.base.attribute);
+    foreach (const SharedObjectPointer& object, oldSet) {
+        stream << object; // removed
     }
+    stream << SharedObjectPointer();
+    foreach (const SharedObjectPointer& object, newSet) {
+        object->maybeWriteSubdivision(stream);
+    }
+    stream << SharedObjectPointer();
 }
 
 void SpannerSetAttribute::writeMetavoxelDelta(const MetavoxelNode& root,
         const MetavoxelNode& reference, MetavoxelStreamState& state) {
-    state.base.visit = Spanner::getAndIncrementNextVisit();
-    root.writeSpannerDelta(reference, state);
-    state.base.stream << SharedObjectPointer();
+    SharedObjectSet oldSet, newSet;
+    reference.getSpanners(this, state.minimum, state.size, state.base.referenceLOD, oldSet);
+    root.getSpanners(this, state.minimum, state.size, state.base.lod, newSet);
+    writeDeltaSubdivision(oldSet, newSet, state.base.stream);
 }
 
 void SpannerSetAttribute::readMetavoxelSubdivision(MetavoxelData& data, MetavoxelStreamState& state) {
@@ -1302,14 +1314,31 @@ void SpannerSetAttribute::readMetavoxelSubdivision(MetavoxelData& data, Metavoxe
         if (!object) {
             break;
         }
-        data.insert(state.base.attribute, object);
+        data.toggle(state.base.attribute, object);
+    }
+    forever {
+        SharedObjectPointer object;
+        state.base.stream >> object;
+        if (!object) {
+            break;
+        }
+        SharedObjectPointer newObject = object->readSubdivision(state.base.stream);
+        if (newObject != object) {
+            data.replace(state.base.attribute, object, newObject);
+            state.base.stream.addSubdividedObject(newObject);
+        }
+    }
+    // even if the root is empty, it should still exist
+    if (!data.getRoot(state.base.attribute)) {
+        data.createRoot(state.base.attribute);
     }
 }
 
 void SpannerSetAttribute::writeMetavoxelSubdivision(const MetavoxelNode& root, MetavoxelStreamState& state) {
-    state.base.visit = Spanner::getAndIncrementNextVisit();
-    root.writeSpannerSubdivision(state);
-    state.base.stream << SharedObjectPointer();
+    SharedObjectSet oldSet, newSet;
+    root.getSpanners(this, state.minimum, state.size, state.base.referenceLOD, oldSet);
+    root.getSpanners(this, state.minimum, state.size, state.base.lod, newSet);
+    writeDeltaSubdivision(oldSet, newSet, state.base.stream);
 }
 
 bool SpannerSetAttribute::metavoxelRootsEqual(const MetavoxelNode& firstRoot, const MetavoxelNode& secondRoot,

libraries/metavoxels/src/Bitstream.cpp

@@ -151,6 +151,7 @@ Bitstream::Bitstream(QDataStream& underlying, MetadataType metadataType, Generic
     _position(0),
     _metadataType(metadataType),
     _genericsMode(genericsMode),
+    _context(NULL),
     _objectStreamerStreamer(*this),
     _typeStreamerStreamer(*this),
     _attributeStreamer(*this),
@@ -266,7 +267,9 @@ Bitstream::ReadMappings Bitstream::getAndResetReadMappings() {
         _typeStreamerStreamer.getAndResetTransientValues(),
         _attributeStreamer.getAndResetTransientValues(),
         _scriptStringStreamer.getAndResetTransientValues(),
-        _sharedObjectStreamer.getAndResetTransientValues() };
+        _sharedObjectStreamer.getAndResetTransientValues(),
+        _subdividedObjects };
+    _subdividedObjects.clear();
     return mappings;
 }
 
@@ -290,6 +293,16 @@ void Bitstream::persistReadMappings(const ReadMappings& mappings) {
         reference = it.value();
         _weakSharedObjectHash.remove(it.value()->getRemoteID());
     }
+    foreach (const SharedObjectPointer& object, mappings.subdividedObjects) {
+        QPointer<SharedObject>& reference = _sharedObjectReferences[object->getRemoteOriginID()];
+        if (reference && reference != object) {
+            int id = _sharedObjectStreamer.removePersistentValue(reference.data());
+            if (id != 0) {
+                _sharedObjectStreamer.insertPersistentValue(id, object);
+            }
+        }
+        reference = object;
+    }
 }
 
 void Bitstream::persistAndResetReadMappings() {
@@ -1155,6 +1168,16 @@ Bitstream& Bitstream::operator<(const ObjectStreamer* streamer) {
     return *this;
 }
 
+static MappedObjectStreamer* createMappedObjectStreamer(const QMetaObject* metaObject,
+        const QVector<StreamerPropertyPair>& properties) {
+    for (const QMetaObject* super = metaObject; super; super = super->superClass()) {
+        if (super == &SharedObject::staticMetaObject) {
+            return new SharedObjectStreamer(metaObject, properties);
+        }
+    }
+    return new MappedObjectStreamer(metaObject, properties);    
+}
+
 Bitstream& Bitstream::operator>(ObjectStreamerPointer& streamer) {
     QByteArray className;
     *this >> className;
@@ -1230,7 +1253,7 @@ Bitstream& Bitstream::operator>(ObjectStreamerPointer& streamer) {
     } else if (metaObject) {
         const QVector<StreamerPropertyPair>& localProperties = streamer->getProperties();
         if (localProperties.size() != properties.size()) {
-            streamer = ObjectStreamerPointer(new MappedObjectStreamer(metaObject, properties));
+            streamer = ObjectStreamerPointer(createMappedObjectStreamer(metaObject, properties));
             return *this;
         }
         for (int i = 0; i < localProperties.size(); i++) {
@@ -1238,13 +1261,13 @@ Bitstream& Bitstream::operator>(ObjectStreamerPointer& streamer) {
             const StreamerPropertyPair& localProperty = localProperties.at(i);
             if (property.first != localProperty.first ||
                     property.second.propertyIndex() != localProperty.second.propertyIndex()) {
-                streamer = ObjectStreamerPointer(new MappedObjectStreamer(metaObject, properties));
+                streamer = ObjectStreamerPointer(createMappedObjectStreamer(metaObject, properties));
                 return *this;
             }
         }
         return *this;
     }
-    streamer = ObjectStreamerPointer(new MappedObjectStreamer(metaObject, properties));
+    streamer = ObjectStreamerPointer(createMappedObjectStreamer(metaObject, properties));
     return *this;
 }
 
@@ -1670,7 +1693,7 @@ QHash<const QMetaObject*, const ObjectStreamer*> Bitstream::createObjectStreamer
                 properties.append(StreamerPropertyPair(streamer->getSelf(), property));
             }
         }
-        ObjectStreamerPointer streamer = ObjectStreamerPointer(new MappedObjectStreamer(metaObject, properties));
+        ObjectStreamerPointer streamer = ObjectStreamerPointer(createMappedObjectStreamer(metaObject, properties));
         streamer->_self = streamer;
         objectStreamers.insert(metaObject, streamer.data());
     }
@@ -2121,7 +2144,7 @@ JSONReader::JSONReader(const QJsonDocument& document, Bitstream::GenericsMode ge
         if (matches) {
             _objectStreamers.insert(name, baseStreamer->getSelf());
         } else {
-            _objectStreamers.insert(name, ObjectStreamerPointer(new MappedObjectStreamer(metaObject, properties)));
+            _objectStreamers.insert(name, ObjectStreamerPointer(createMappedObjectStreamer(metaObject, properties)));
         }
     }
     
@@ -2436,6 +2459,32 @@ QObject* MappedObjectStreamer::readRawDelta(Bitstream& in, const QObject* refere
     return object;
 }
 
+SharedObjectStreamer::SharedObjectStreamer(const QMetaObject* metaObject, const QVector<StreamerPropertyPair>& properties) :
+    MappedObjectStreamer(metaObject, properties) {
+}
+
+void SharedObjectStreamer::write(Bitstream& out, const QObject* object) const {
+    MappedObjectStreamer::write(out, object);
+    static_cast<const SharedObject*>(object)->writeExtra(out);
+}
+
+void SharedObjectStreamer::writeRawDelta(Bitstream& out, const QObject* object, const QObject* reference) const {
+    MappedObjectStreamer::writeRawDelta(out, object, reference);
+    static_cast<const SharedObject*>(object)->writeExtraDelta(out, static_cast<const SharedObject*>(reference));
+}
+
+QObject* SharedObjectStreamer::read(Bitstream& in, QObject* object) const {
+    QObject* result = MappedObjectStreamer::read(in, object);
+    static_cast<SharedObject*>(result)->readExtra(in);
+    return result;
+}
+
+QObject* SharedObjectStreamer::readRawDelta(Bitstream& in, const QObject* reference, QObject* object) const {
+    QObject* result = MappedObjectStreamer::readRawDelta(in, reference, object);
+    static_cast<SharedObject*>(result)->readExtraDelta(in, static_cast<const SharedObject*>(reference));
+    return result;
+}
+
 GenericObjectStreamer::GenericObjectStreamer(const QByteArray& name, const QVector<StreamerNamePair>& properties,
         const QByteArray& hash) :
     ObjectStreamer(&GenericSharedObject::staticMetaObject),

libraries/metavoxels/src/Bitstream.h

@@ -99,10 +99,12 @@ public:
     
     int takePersistentID(P value) { return _persistentIDs.take(value); }
     
-    void removePersistentValue(V value) { int id = _valueIDs.take(value); _persistentValues.remove(id); }
+    int removePersistentValue(V value) { int id = _valueIDs.take(value); _persistentValues.remove(id); return id; }
     
     V takePersistentValue(int id) { V value = _persistentValues.take(id); _valueIDs.remove(value); return value; }
     
+    void insertPersistentValue(int id, V value) { _valueIDs.insert(value, id); _persistentValues.insert(id, value); }
+    
     void copyPersistentMappings(const RepeatedValueStreamer& other);
     void clearPersistentMappings();
     
@@ -289,6 +291,7 @@ public:
         QHash<int, AttributePointer> attributeValues;
         QHash<int, QScriptString> scriptStringValues;
         QHash<int, SharedObjectPointer> sharedObjectValues;
+        QVector<SharedObjectPointer> subdividedObjects;
     };
 
     /// Performs all of the various lazily initializations (of object streamers, etc.)  If multiple threads need to use
@@ -342,6 +345,12 @@ public:
     /// Returns a reference to the underlying data stream.
     QDataStream& getUnderlying() { return _underlying; }
 
+    /// Sets the context pointer.
+    void setContext(void* context) { _context = context; }
+
+    /// Returns the context pointer.
+    void* getContext() const { return _context; }
+
     /// Substitutes the supplied metaobject for the given class name's default mapping.  This is mostly useful for testing the
     /// process of mapping between different types, but may in the future be used for permanently renaming classes.
     void addMetaObjectSubstitution(const QByteArray& className, const QMetaObject* metaObject);
@@ -368,6 +377,9 @@ public:
     /// Resets to the initial state.
     void reset();
 
+    /// Adds a subdivided object, which will be added to the read mappings and used as a reference if persisted.
+    void addSubdividedObject(const SharedObjectPointer& object) { _subdividedObjects.append(object); }
+    
     /// Returns the set of transient mappings gathered during writing and resets them.
     WriteMappings getAndResetWriteMappings();
 
@@ -562,12 +574,16 @@ private:
     MetadataType _metadataType;
     GenericsMode _genericsMode;
 
+    void* _context;
+
     RepeatedValueStreamer<const ObjectStreamer*, const ObjectStreamer*, ObjectStreamerPointer> _objectStreamerStreamer;
     RepeatedValueStreamer<const TypeStreamer*, const TypeStreamer*, TypeStreamerPointer> _typeStreamerStreamer;
     RepeatedValueStreamer<AttributePointer> _attributeStreamer;
     RepeatedValueStreamer<QScriptString> _scriptStringStreamer;
     RepeatedValueStreamer<SharedObjectPointer, SharedObject*> _sharedObjectStreamer;
     
+    QVector<SharedObjectPointer> _subdividedObjects;
+    
     WeakSharedObjectHash _sharedObjectReferences;
 
     WeakSharedObjectHash _weakSharedObjectHash;
@@ -1125,6 +1141,18 @@ private:
     QVector<StreamerPropertyPair> _properties;
 };
 
+/// A streamer that maps to a local shared object class.  Shared objects can write extra, non-property data.
+class SharedObjectStreamer : public MappedObjectStreamer {
+public:
+    
+    SharedObjectStreamer(const QMetaObject* metaObject, const QVector<StreamerPropertyPair>& properties);
+    
+    virtual void write(Bitstream& out, const QObject* object) const;
+    virtual void writeRawDelta(Bitstream& out, const QObject* object, const QObject* reference) const;
+    virtual QObject* read(Bitstream& in, QObject* object = NULL) const;
+    virtual QObject* readRawDelta(Bitstream& in, const QObject* reference, QObject* object = NULL) const;
+};
+
 typedef QPair<TypeStreamerPointer, QByteArray> StreamerNamePair;
 
 /// A streamer for generic objects.

libraries/metavoxels/src/DatagramSequencer.cpp

@@ -239,39 +239,44 @@ void DatagramSequencer::receivedDatagram(const QByteArray& datagram) {
         _sendRecords.erase(_sendRecords.begin(), it + 1);
     }
     
-    // alert external parties so that they can read the middle
-    emit readyToRead(_inputStream);
-    
-    // read and dispatch the high-priority messages
-    int highPriorityMessageCount;
-    _inputStream >> highPriorityMessageCount;
-    int newHighPriorityMessages = highPriorityMessageCount - _receivedHighPriorityMessages;
-    for (int i = 0; i < highPriorityMessageCount; i++) {
-        QVariant data;
-        _inputStream >> data;
-        if (i >= _receivedHighPriorityMessages) {
-            emit receivedHighPriorityMessage(data);
+    try {
+        // alert external parties so that they can read the middle
+        emit readyToRead(_inputStream);
+        
+        // read and dispatch the high-priority messages
+        int highPriorityMessageCount;
+        _inputStream >> highPriorityMessageCount;
+        int newHighPriorityMessages = highPriorityMessageCount - _receivedHighPriorityMessages;
+        for (int i = 0; i < highPriorityMessageCount; i++) {
+            QVariant data;
+            _inputStream >> data;
+            if (i >= _receivedHighPriorityMessages) {
+                emit receivedHighPriorityMessage(data);
+            }
         }
-    }
-    _receivedHighPriorityMessages = highPriorityMessageCount;
+        _receivedHighPriorityMessages = highPriorityMessageCount;
+        
+        // read the reliable data, if any
+        quint32 reliableChannels;
+        _incomingPacketStream >> reliableChannels;
+        for (quint32 i = 0; i < reliableChannels; i++) {
+            quint32 channelIndex;
+            _incomingPacketStream >> channelIndex;
+            getReliableInputChannel(channelIndex)->readData(_incomingPacketStream);
+        }
+        
+        // record the receipt
+        ReceiveRecord record = { _incomingPacketNumber, _inputStream.getAndResetReadMappings(), newHighPriorityMessages };
+        _receiveRecords.append(record);
+        
+        emit receiveRecorded();
     
-    // read the reliable data, if any
-    quint32 reliableChannels;
-    _incomingPacketStream >> reliableChannels;
-    for (quint32 i = 0; i < reliableChannels; i++) {
-        quint32 channelIndex;
-        _incomingPacketStream >> channelIndex;
-        getReliableInputChannel(channelIndex)->readData(_incomingPacketStream);
+    } catch (const BitstreamException& e) {
+        qWarning() << "Error reading datagram:" << e.getDescription();
     }
     
     _incomingPacketStream.device()->seek(0);
-    _inputStream.reset();
-    
-    // record the receipt
-    ReceiveRecord record = { _incomingPacketNumber, _inputStream.getAndResetReadMappings(), newHighPriorityMessages };
-    _receiveRecords.append(record);
-    
-    emit receiveRecorded();
+    _inputStream.reset();    
 }
 
 void DatagramSequencer::sendClearSharedObjectMessage(int id) {

libraries/metavoxels/src/MetavoxelData.cpp

@@ -56,6 +56,34 @@ bool MetavoxelLOD::becameSubdividedOrCollapsed(const glm::vec3& minimum, float s
     return true;
 }
 
+bool MetavoxelLOD::shouldSubdivide(const glm::vec2& minimum, float size, float multiplier) const {
+    return size >= glm::distance(glm::vec2(position), minimum + glm::vec2(size, size) * 0.5f) * threshold * multiplier;
+}
+
+bool MetavoxelLOD::becameSubdivided(const glm::vec2& minimum, float size,
+        const MetavoxelLOD& reference, float multiplier) const {
+    if (position == reference.position && threshold >= reference.threshold) {
+        return false; // first off, nothing becomes subdivided if it doesn't change
+    }
+    if (!shouldSubdivide(minimum, size, multiplier)) {
+        return false; // this one must be subdivided
+    }
+    // TODO: find some way of culling subtrees that can't possibly contain subdivided nodes
+    return true;
+}
+
+bool MetavoxelLOD::becameSubdividedOrCollapsed(const glm::vec2& minimum, float size,
+        const MetavoxelLOD& reference, float multiplier) const {
+    if (position == reference.position && threshold == reference.threshold) {
+        return false; // first off, nothing becomes subdivided or collapsed if it doesn't change
+    }
+    if (!(shouldSubdivide(minimum, size, multiplier) || reference.shouldSubdivide(minimum, size, multiplier))) {
+        return false; // this one or the reference must be subdivided
+    }
+    // TODO: find some way of culling subtrees that can't possibly contain subdivided or collapsed nodes
+    return true;
+}
+
 MetavoxelData::MetavoxelData() : _size(1.0f) {
 }
 
@@ -577,7 +605,9 @@ void MetavoxelData::read(Bitstream& in, const MetavoxelLOD& lod) {
         }
         MetavoxelStreamBase base = { attribute, in, lod, lod };
         MetavoxelStreamState state = { base, getMinimum(), _size };
+        in.setContext(&base);
         attribute->readMetavoxelRoot(*this, state);
+        in.setContext(NULL);
     }
 }
 
@@ -587,7 +617,9 @@ void MetavoxelData::write(Bitstream& out, const MetavoxelLOD& lod) const {
         out << it.key();
         MetavoxelStreamBase base = { it.key(), out, lod, lod };
         MetavoxelStreamState state = { base, getMinimum(), _size };
+        out.setContext(&base);
         it.key()->writeMetavoxelRoot(*it.value(), state);
+        out.setContext(NULL);
     }
     out << AttributePointer();
 }
@@ -622,6 +654,7 @@ void MetavoxelData::readDelta(const MetavoxelData& reference, const MetavoxelLOD
             MetavoxelStreamBase base = { attribute, in, lod, referenceLOD };
             MetavoxelStreamState state = { base, minimum, _size };
             MetavoxelNode* oldRoot = _roots.value(attribute);
+            in.setContext(&base);
             if (oldRoot) {
                 bool changed;
                 in >> changed;
@@ -637,6 +670,7 @@ void MetavoxelData::readDelta(const MetavoxelData& reference, const MetavoxelLOD
             } else {
                 attribute->readMetavoxelRoot(*this, state);
             } 
+            in.setContext(NULL);
         }
         
         forever {
@@ -657,7 +691,9 @@ void MetavoxelData::readDelta(const MetavoxelData& reference, const MetavoxelLOD
                 it != remainingRoots.constEnd(); it++) {
             MetavoxelStreamBase base = { it.key(), in, lod, referenceLOD };
             MetavoxelStreamState state = { base, minimum, _size };
+            in.setContext(&base);
             it.key()->readMetavoxelSubdivision(*this, state);
+            in.setContext(NULL);
         }
     }
 }
@@ -693,6 +729,7 @@ void MetavoxelData::writeDelta(const MetavoxelData& reference, const MetavoxelLO
         MetavoxelNode* referenceRoot = expandedReference->_roots.value(it.key());
         MetavoxelStreamBase base = { it.key(), out, lod, referenceLOD };
         MetavoxelStreamState state = { base, minimum, _size };
+        out.setContext(&base);
         if (it.value() != referenceRoot || becameSubdivided) {
             out << it.key();    
             if (referenceRoot) {
@@ -707,6 +744,7 @@ void MetavoxelData::writeDelta(const MetavoxelData& reference, const MetavoxelLO
                 it.key()->writeMetavoxelRoot(*it.value(), state);
             }
         }
+        out.setContext(NULL);
     }
     out << AttributePointer();
     

libraries/metavoxels/src/MetavoxelData.h

@@ -53,6 +53,17 @@ public:
     /// enabled or disabled as compared to the reference.
     bool becameSubdividedOrCollapsed(const glm::vec3& minimum, float size,
         const MetavoxelLOD& reference, float multiplier = 1.0f) const;
+    
+    /// Checks whether, according to this LOD, we should subdivide the described region.
+    bool shouldSubdivide(const glm::vec2& minimum, float size, float multiplier = 1.0f) const;
+    
+    /// Checks whether the node or any of the nodes underneath it have had subdivision enabled as compared to the reference.
+    bool becameSubdivided(const glm::vec2& minimum, float size, const MetavoxelLOD& reference, float multiplier = 1.0f) const;
+    
+    /// Checks whether the node or any of the nodes underneath it have had subdivision
+    /// enabled or disabled as compared to the reference.
+    bool becameSubdividedOrCollapsed(const glm::vec2& minimum, float size,
+        const MetavoxelLOD& reference, float multiplier = 1.0f) const;
 };
 
 DECLARE_STREAMABLE_METATYPE(MetavoxelLOD)

libraries/metavoxels/src/MetavoxelMessages.cpp

@@ -123,11 +123,9 @@ RemoveSpannerEdit::RemoveSpannerEdit(const AttributePointer& attribute, int id)
 
 void RemoveSpannerEdit::apply(MetavoxelData& data, const WeakSharedObjectHash& objects) const {
     SharedObject* object = objects.value(id);
-    if (!object) {
-        qDebug() << "Missing object to remove" << id;
-        return;
+    if (object) {
+        data.remove(attribute, object);
     }
-    data.remove(attribute, object);
 }
 
 ClearSpannersEdit::ClearSpannersEdit(const AttributePointer& attribute) :

libraries/metavoxels/src/SharedObject.cpp

@@ -131,6 +131,30 @@ void SharedObject::dump(QDebug debug) const {
     }
 }
 
+void SharedObject::writeExtra(Bitstream& out) const {
+    // nothing by default
+}
+
+void SharedObject::readExtra(Bitstream& in) {
+    // nothing by default
+}
+
+void SharedObject::writeExtraDelta(Bitstream& out, const SharedObject* reference) const {
+    // nothing by default
+}
+
+void SharedObject::readExtraDelta(Bitstream& in, const SharedObject* reference) {
+    // nothing by default
+}
+
+void SharedObject::maybeWriteSubdivision(Bitstream& out) {
+    // nothing by default
+}
+
+SharedObject* SharedObject::readSubdivision(Bitstream& in) {
+    return this;
+}
+
 QAtomicInt SharedObject::_nextID(1);
 WeakSharedObjectHash SharedObject::_weakHash;
 QReadWriteLock SharedObject::_weakHashLock;

libraries/metavoxels/src/SharedObject.h

@@ -24,6 +24,7 @@
 
 class QComboBox;
 
+class Bitstream;
 class SharedObject;
 
 typedef QHash<int, QPointer<SharedObject> > WeakSharedObjectHash;
@@ -76,9 +77,29 @@ public:
     /// this is an instance of a superclass of the other object's class) rather than simply returning false.
     virtual bool equals(const SharedObject* other, bool sharedAncestry = false) const;
 
-    // Dumps the contents of this object to the debug output.
+    /// Dumps the contents of this object to the debug output.
     virtual void dump(QDebug debug = QDebug(QtDebugMsg)) const;
 
+    /// Writes the non-property contents of this object to the specified stream.
+    virtual void writeExtra(Bitstream& out) const;
+    
+    /// Reads the non-property contents of this object from the specified stream.
+    virtual void readExtra(Bitstream& in);
+
+    /// Writes the delta-encoded non-property contents of this object to the specified stream.
+    virtual void writeExtraDelta(Bitstream& out, const SharedObject* reference) const;
+
+    /// Reads the delta-encoded non-property contents of this object from the specified stream.
+    virtual void readExtraDelta(Bitstream& in, const SharedObject* reference);
+
+    /// Writes the subdivision of the contents of this object (preceeded by a
+    /// reference to the object itself) to the specified stream if necessary.
+    virtual void maybeWriteSubdivision(Bitstream& out);
+    
+    /// Reads the subdivision of this object from the specified stream.
+    /// \return the modified object, or this if no modification was performed
+    virtual SharedObject* readSubdivision(Bitstream& in);
+
 private:
     
     int _id;

libraries/metavoxels/src/Spanner.h

@@ -17,9 +17,12 @@
 #include "AttributeRegistry.h"
 #include "MetavoxelUtil.h"
 
+class AbstractHeightfieldNodeRenderer;
+class Heightfield;
 class HeightfieldColor;
 class HeightfieldHeight;
 class HeightfieldMaterial;
+class HeightfieldNode;
 class SpannerRenderer;
 
 /// An object that spans multiple octree cells.
@@ -28,6 +31,7 @@ class Spanner : public SharedObject {
     Q_PROPERTY(Box bounds MEMBER _bounds WRITE setBounds NOTIFY boundsChanged DESIGNABLE false)
     Q_PROPERTY(float placementGranularity MEMBER _placementGranularity DESIGNABLE false)
     Q_PROPERTY(float voxelizationGranularity MEMBER _voxelizationGranularity DESIGNABLE false)
+    Q_PROPERTY(bool willBeVoxelized MEMBER _willBeVoxelized DESIGNABLE false)
     
 public:
     
@@ -48,6 +52,9 @@ public:
     void setMerged(bool merged) { _merged = merged; }
     bool isMerged() const { return _merged; }
     
+    void setWillBeVoxelized(bool willBeVoxelized) { _willBeVoxelized = willBeVoxelized; }
+    bool getWillBeVoxelized() const { return _willBeVoxelized; }
+    
     /// Checks whether we've visited this object on the current traversal.  If we have, returns false.
     /// If we haven't, sets the last visit identifier and returns true.
     bool testAndSetVisited(int visit);
@@ -117,6 +124,7 @@ private:
     float _placementGranularity;
     float _voxelizationGranularity;
     bool _merged;
+    bool _willBeVoxelized;
     QHash<QThread*, int> _lastVisits; ///< last visit identifiers for each thread
     QMutex _lastVisitsMutex;
     
@@ -133,7 +141,7 @@ public:
     
     virtual void init(Spanner* spanner);
     virtual void simulate(float deltaTime);
-    virtual void render(bool cursor = false);
+    virtual void render(const MetavoxelLOD& lod = MetavoxelLOD(), bool contained = false, bool cursor = false);
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance) const;
 
 protected:
@@ -458,14 +466,129 @@ Bitstream& operator>>(Bitstream& in, HeightfieldMaterialPointer& value);
 template<> void Bitstream::writeRawDelta(const HeightfieldMaterialPointer& value, const HeightfieldMaterialPointer& reference);
 template<> void Bitstream::readRawDelta(HeightfieldMaterialPointer& value, const HeightfieldMaterialPointer& reference);
 
+typedef QExplicitlySharedDataPointer<HeightfieldNode> HeightfieldNodePointer;
+
+/// Holds the base state used in streaming heightfield data.
+class HeightfieldStreamBase {
+public:
+    Bitstream& stream;
+    const MetavoxelLOD& lod;
+    const MetavoxelLOD& referenceLOD;
+};
+
+/// Holds the state used in streaming a heightfield node.
+class HeightfieldStreamState {
+public:
+    HeightfieldStreamBase& base;
+    glm::vec2 minimum;
+    float size;
+    
+    bool shouldSubdivide() const;
+    bool shouldSubdivideReference() const;
+    bool becameSubdivided() const;
+    bool becameSubdividedOrCollapsed() const;
+    
+    void setMinimum(const glm::vec2& lastMinimum, int index);
+};
+
+/// A node in a heightfield quadtree.
+class HeightfieldNode : public QSharedData {
+public:
+    
+    static const int CHILD_COUNT = 4;
+    
+    HeightfieldNode(const HeightfieldHeightPointer& height = HeightfieldHeightPointer(),
+        const HeightfieldColorPointer& color = HeightfieldColorPointer(),
+        const HeightfieldMaterialPointer& material = HeightfieldMaterialPointer());
+    
+    HeightfieldNode(const HeightfieldNode& other);
+    
+    ~HeightfieldNode();
+    
+    void setContents(const HeightfieldHeightPointer& height, const HeightfieldColorPointer& color,
+        const HeightfieldMaterialPointer& material);
+    
+    void setHeight(const HeightfieldHeightPointer& height) { _height = height; }
+    const HeightfieldHeightPointer& getHeight() const { return _height; }
+    
+    void setColor(const HeightfieldColorPointer& color) { _color = color; }
+    const HeightfieldColorPointer& getColor() const { return _color; }
+    
+    void setMaterial(const HeightfieldMaterialPointer& material) { _material = material; }
+    const HeightfieldMaterialPointer& getMaterial() const { return _material; }
+    
+    void setRenderer(AbstractHeightfieldNodeRenderer* renderer) { _renderer = renderer; }
+    AbstractHeightfieldNodeRenderer* getRenderer() const { return _renderer; }
+    
+    bool isLeaf() const;
+    
+    void setChild(int index, const HeightfieldNodePointer& child) { _children[index] = child; }
+    const HeightfieldNodePointer& getChild(int index) const { return _children[index]; }
+    
+    float getHeight(const glm::vec3& location) const;
+    
+    bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance) const;
+    
+    HeightfieldNode* paintMaterial(const glm::vec3& position, const glm::vec3& radius, const SharedObjectPointer& material,
+        const QColor& color);
+    
+    void getRangeAfterHeightPaint(const glm::vec3& position, const glm::vec3& radius,
+        float height, int& minimum, int& maximum) const;
+    
+    HeightfieldNode* paintHeight(const glm::vec3& position, const glm::vec3& radius, float height,
+        float normalizeScale, float normalizeOffset);
+        
+    HeightfieldNode* clearAndFetchHeight(const glm::vec3& translation, const glm::quat& rotation, const glm::vec3& scale,
+        const Box& bounds, SharedObjectPointer& heightfield);
+        
+    void read(HeightfieldStreamState& state);
+    void write(HeightfieldStreamState& state) const;
+    
+    void readDelta(const HeightfieldNodePointer& reference, HeightfieldStreamState& state);
+    void writeDelta(const HeightfieldNodePointer& reference, HeightfieldStreamState& state) const;
+    
+    HeightfieldNode* readSubdivision(HeightfieldStreamState& state);
+    void writeSubdivision(HeightfieldStreamState& state) const;
+    
+    void readSubdivided(HeightfieldStreamState& state, const HeightfieldStreamState& ancestorState,
+        const HeightfieldNode* ancestor);
+    void writeSubdivided(HeightfieldStreamState& state, const HeightfieldStreamState& ancestorState,
+        const HeightfieldNode* ancestor) const;
+    
+private:
+    
+    void clearChildren();
+    void mergeChildren(bool height = true, bool colorMaterial = true);
+    
+    QRgb getColorAt(const glm::vec3& location) const;
+    int getMaterialAt(const glm::vec3& location) const;
+    
+    HeightfieldHeightPointer _height;
+    HeightfieldColorPointer _color;
+    HeightfieldMaterialPointer _material;
+    
+    HeightfieldNodePointer _children[CHILD_COUNT];
+    
+    AbstractHeightfieldNodeRenderer* _renderer;
+};
+
+/// Base class for heightfield node rendering.
+class AbstractHeightfieldNodeRenderer {
+public:
+    
+    virtual ~AbstractHeightfieldNodeRenderer();
+};
+
 /// A heightfield represented as a spanner.
 class Heightfield : public Transformable {
     Q_OBJECT
     Q_PROPERTY(float aspectY MEMBER _aspectY WRITE setAspectY NOTIFY aspectYChanged)
     Q_PROPERTY(float aspectZ MEMBER _aspectZ WRITE setAspectZ NOTIFY aspectZChanged)
-    Q_PROPERTY(HeightfieldHeightPointer height MEMBER _height WRITE setHeight NOTIFY heightChanged)
-    Q_PROPERTY(HeightfieldColorPointer color MEMBER _color WRITE setColor NOTIFY colorChanged)
-    Q_PROPERTY(HeightfieldMaterialPointer material MEMBER _material WRITE setMaterial NOTIFY materialChanged DESIGNABLE false)
+    Q_PROPERTY(HeightfieldHeightPointer height MEMBER _height WRITE setHeight NOTIFY heightChanged STORED false)
+    Q_PROPERTY(HeightfieldColorPointer color MEMBER _color WRITE setColor NOTIFY colorChanged STORED false)
+    Q_PROPERTY(HeightfieldMaterialPointer material MEMBER _material WRITE setMaterial NOTIFY materialChanged STORED false
+        DESIGNABLE false)
+    Q_PROPERTY(HeightfieldNodePointer root MEMBER _root WRITE setRoot NOTIFY rootChanged STORED false DESIGNABLE false)
 
 public:
     
@@ -486,6 +609,13 @@ public:
     void setMaterial(const HeightfieldMaterialPointer& material);
     const HeightfieldMaterialPointer& getMaterial() const { return _material; }
 
+    void setRoot(const HeightfieldNodePointer& root);
+    const HeightfieldNodePointer& getRoot() const { return _root; }
+
+    MetavoxelLOD transformLOD(const MetavoxelLOD& lod) const;
+
+    virtual SharedObject* clone(bool withID = false, SharedObject* target = NULL) const;
+    
     virtual bool isHeightfield() const;
     
     virtual float getHeight(const glm::vec3& location) const;
@@ -508,6 +638,13 @@ public:
     virtual bool contains(const glm::vec3& point);
     virtual bool intersects(const glm::vec3& start, const glm::vec3& end, float& distance, glm::vec3& normal);
     
+    virtual void writeExtra(Bitstream& out) const;
+    virtual void readExtra(Bitstream& in);
+    virtual void writeExtraDelta(Bitstream& out, const SharedObject* reference) const;
+    virtual void readExtraDelta(Bitstream& in, const SharedObject* reference);
+    virtual void maybeWriteSubdivision(Bitstream& out);
+    virtual SharedObject* readSubdivision(Bitstream& in);
+    
 signals:
 
     void aspectYChanged(float aspectY);
@@ -515,6 +652,7 @@ signals:
     void heightChanged(const HeightfieldHeightPointer& height);
     void colorChanged(const HeightfieldColorPointer& color);
     void materialChanged(const HeightfieldMaterialPointer& material);
+    void rootChanged(const HeightfieldNodePointer& root);
     
 protected:
     
@@ -523,14 +661,18 @@ protected:
 private slots:
     
     void updateBounds();
+    void updateRoot();
     
 private:
 
     float _aspectY;
     float _aspectZ;
+    
     HeightfieldHeightPointer _height;
     HeightfieldColorPointer _color;
     HeightfieldMaterialPointer _material;
+    
+    HeightfieldNodePointer _root;
 };
 
 #endif // hifi_Spanner_h

libraries/networking/src/PacketHeaders.cpp

@@ -81,7 +81,7 @@ PacketVersion versionForPacketType(PacketType type) {
         case PacketTypeAudioStreamStats:
             return 1;
         case PacketTypeMetavoxelData:
-            return 9;
+            return 10;
         case PacketTypeVoxelData:
             return VERSION_VOXELS_HAS_FILE_BREAKS;
         default:

libraries/octree/src/Octree.cpp

@@ -693,13 +693,14 @@ public:
     BoxFace& face;
     void** intersectedObject;
     bool found;
+    bool precisionPicking;
 };
 
 bool findRayIntersectionOp(OctreeElement* element, void* extraData) {
     RayArgs* args = static_cast<RayArgs*>(extraData);
     bool keepSearching = true;
     if (element->findRayIntersection(args->origin, args->direction, keepSearching, 
-                            args->element, args->distance, args->face, args->intersectedObject)) {
+                            args->element, args->distance, args->face, args->intersectedObject, args->precisionPicking)) {
         args->found = true;
     }
     return keepSearching;
@@ -707,8 +708,9 @@ bool findRayIntersectionOp(OctreeElement* element, void* extraData) {
 
 bool Octree::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                                     OctreeElement*& element, float& distance, BoxFace& face, void** intersectedObject,
-                                    Octree::lockType lockType, bool* accurateResult) {
-    RayArgs args = { origin / (float)(TREE_SCALE), direction, element, distance, face, intersectedObject, false};
+                                    Octree::lockType lockType, bool* accurateResult, bool precisionPicking) {
+    RayArgs args = { origin / (float)(TREE_SCALE), direction, element, distance, face, 
+                        intersectedObject, false, precisionPicking};
     distance = FLT_MAX;
 
     bool gotLock = false;

libraries/octree/src/Octree.h

@@ -298,7 +298,9 @@ public:
     bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                              OctreeElement*& node, float& distance, BoxFace& face, 
                              void** intersectedObject = NULL,
-                             Octree::lockType lockType = Octree::TryLock, bool* accurateResult = NULL);
+                             Octree::lockType lockType = Octree::TryLock, 
+                             bool* accurateResult = NULL, 
+                             bool precisionPicking = false);
 
     bool findSpherePenetration(const glm::vec3& center, float radius, glm::vec3& penetration, void** penetratedObject = NULL, 
                                     Octree::lockType lockType = Octree::TryLock, bool* accurateResult = NULL);

libraries/octree/src/OctreeElement.cpp

@@ -1334,16 +1334,20 @@ void OctreeElement::notifyUpdateHooks() {
 
 bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) {
+                         void** intersectedObject, bool precisionPicking) {
 
     keepSearching = true; // assume that we will continue searching after this.
 
     AACube cube = getAACube();
-    float localDistance;
+    float distanceToElementCube = std::numeric_limits<float>::max();
+    float distanceToElementDetails = distance;
     BoxFace localFace;
 
+    AACube debugCube = cube;
+    debugCube.scale((float)TREE_SCALE);
+
     // if the ray doesn't intersect with our cube, we can stop searching!
-    if (!cube.findRayIntersection(origin, direction, localDistance, localFace)) {
+    if (!cube.findRayIntersection(origin, direction, distanceToElementCube, localFace)) {
         keepSearching = false; // no point in continuing to search
         return false; // we did not intersect
     }
@@ -1353,14 +1357,18 @@ bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3
         return false; // we don't intersect with non-leaves, and we keep searching
     }
 
-    // we did hit this element, so calculate appropriate distances    
-    localDistance *= TREE_SCALE;
-    if (localDistance < distance) {
-        if (findDetailedRayIntersection(origin, direction, keepSearching,
-                                        element, distance, face, intersectedObject)) {
-            distance = localDistance;
-            face = localFace;
-            return true;
+    // if the distance to the element cube is not less than the current best distance, then it's not possible
+    // for any details inside the cube to be closer so we don't need to consider them.
+    if (cube.contains(origin) || distanceToElementCube < distance) {
+
+        if (findDetailedRayIntersection(origin, direction, keepSearching, element, distanceToElementDetails, 
+                                            face, intersectedObject, precisionPicking, distanceToElementCube)) {
+
+            if (distanceToElementDetails < distance) {
+                distance = distanceToElementDetails;
+                face = localFace;
+                return true;
+            }
         }
     }
     return false;
@@ -1368,11 +1376,12 @@ bool OctreeElement::findRayIntersection(const glm::vec3& origin, const glm::vec3
 
 bool OctreeElement::findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject) {
+                         void** intersectedObject, bool precisionPicking, float distanceToElementCube) {
 
     // we did hit this element, so calculate appropriate distances    
     if (hasContent()) {
         element = this;
+        distance = distanceToElementCube;
         if (intersectedObject) {
             *intersectedObject = this;
         }

libraries/octree/src/OctreeElement.h

@@ -119,11 +119,11 @@ public:
     virtual bool canRayIntersect() const { return isLeaf(); }
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                              bool& keepSearching, OctreeElement*& node, float& distance, BoxFace& face, 
-                             void** intersectedObject = NULL);
+                             void** intersectedObject = NULL, bool precisionPicking = false);
 
     virtual bool findDetailedRayIntersection(const glm::vec3& origin, const glm::vec3& direction,
                          bool& keepSearching, OctreeElement*& element, float& distance, BoxFace& face, 
-                         void** intersectedObject);
+                         void** intersectedObject, bool precisionPicking, float distanceToElementCube);
 
     virtual bool findSpherePenetration(const glm::vec3& center, float radius, 
                         glm::vec3& penetration, void** penetratedObject) const;

libraries/shared/src/GeometryUtil.cpp

@@ -252,6 +252,30 @@ bool findRayCapsuleIntersection(const glm::vec3& origin, const glm::vec3& direct
     return true;
 }
 
+bool findRayTriangleIntersection(const glm::vec3& origin, const glm::vec3& direction,
+        const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2, float& distance) {
+    glm::vec3 firstSide = v0 - v1;
+    glm::vec3 secondSide = v2 - v1;
+    glm::vec3 normal = glm::cross(secondSide, firstSide);
+    float dividend = glm::dot(normal, v1) - glm::dot(origin, normal);
+    if (dividend > 0.0f) {
+        return false; // origin below plane
+    }
+    float divisor = glm::dot(normal, direction);
+    if (divisor > -EPSILON) {
+        return false;
+    }
+    float t = dividend / divisor;
+    glm::vec3 point = origin + direction * t;
+    if (glm::dot(normal, glm::cross(point - v1, firstSide)) > 0.0f &&
+            glm::dot(normal, glm::cross(secondSide, point - v1)) > 0.0f &&
+            glm::dot(normal, glm::cross(point - v0, v2 - v0)) > 0.0f) {
+        distance = t;
+        return true;
+    }
+    return false;
+}
+
 // Do line segments (r1p1.x, r1p1.y)--(r1p2.x, r1p2.y) and (r2p1.x, r2p1.y)--(r2p2.x, r2p2.y) intersect?
 // from: http://ptspts.blogspot.com/2010/06/how-to-determine-if-two-line-segments.html
 bool doLineSegmentsIntersect(glm::vec2 r1p1, glm::vec2 r1p2, glm::vec2 r2p1, glm::vec2 r2p2) {

libraries/shared/src/GeometryUtil.h

@@ -76,6 +76,22 @@ bool findRaySphereIntersection(const glm::vec3& origin, const glm::vec3& directi
 bool findRayCapsuleIntersection(const glm::vec3& origin, const glm::vec3& direction,
     const glm::vec3& start, const glm::vec3& end, float radius, float& distance);
 
+bool findRayTriangleIntersection(const glm::vec3& origin, const glm::vec3& direction, 
+                                    const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2, float& distance);
+
+class Triangle {
+public:
+    glm::vec3 v0;
+    glm::vec3 v1;
+    glm::vec3 v2;
+};
+
+inline bool findRayTriangleIntersection(const glm::vec3& origin, const glm::vec3& direction, 
+                                    const Triangle& triangle, float& distance) {
+    return findRayTriangleIntersection(origin, direction, triangle.v0, triangle.v1, triangle.v2, distance);
+}
+    
+
 bool doLineSegmentsIntersect(glm::vec2 r1p1, glm::vec2 r1p2, glm::vec2 r2p1, glm::vec2 r2p2);
 bool isOnSegment(float xi, float yi, float xj, float yj, float xk, float yk);
 int computeDirection(float xi, float yi, float xj, float yj, float xk, float yk);