Merge branch 'master' of https://github.com/highfidelity/hifi into body_not_rotating

assignment-client/src/octree/OctreeSendThread.cpp

@@ -404,6 +404,13 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
 
             bool lastNodeDidntFit = false; // assume each node fits
             if (!nodeData->elementBag.isEmpty()) {
+                
+                quint64 lockWaitStart = usecTimestampNow();
+                _myServer->getOctree()->lockForRead();
+                quint64 lockWaitEnd = usecTimestampNow();
+                lockWaitElapsedUsec = (float)(lockWaitEnd - lockWaitStart);
+                quint64 encodeStart = usecTimestampNow();
+
                 OctreeElement* subTree = nodeData->elementBag.extract();
 
                 /* TODO: Looking for a way to prevent locking and encoding a tree that is not
@@ -447,12 +454,6 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
                 // it seems like it may be a good idea to include the lock time as part of the encode time
                 // are reported to client. Since you can encode without the lock
                 nodeData->stats.encodeStarted();
-                
-                quint64 lockWaitStart = usecTimestampNow();
-                _myServer->getOctree()->lockForRead();
-                quint64 lockWaitEnd = usecTimestampNow();
-                lockWaitElapsedUsec = (float)(lockWaitEnd - lockWaitStart);
-                quint64 encodeStart = usecTimestampNow();
 
                 bytesWritten = _myServer->getOctree()->encodeTreeBitstream(subTree, &_packetData, nodeData->elementBag, params);
 

examples/editEntities.js

@@ -1077,6 +1077,19 @@ PropertiesTool = function(opts) {
                     pushCommandForSelections();
                     selectionManager._update();
                 }
+            } else if (data.action == "rescaleDimensions") {
+                var multiplier = data.percentage / 100;
+                if (selectionManager.hasSelection()) {
+                    selectionManager.saveProperties();
+                    for (var i = 0; i < selectionManager.selections.length; i++) {
+                        var properties = selectionManager.savedProperties[selectionManager.selections[i].id];
+                        Entities.editEntity(selectionManager.selections[i], {
+                            dimensions: Vec3.multiply(multiplier, properties.dimensions),
+                        });
+                    }
+                    pushCommandForSelections();
+                    selectionManager._update();
+                }
             }
         }
     });

examples/html/entityProperties.html

@@ -84,6 +84,8 @@
             var elDimensionsY = document.getElementById("property-dim-y");
             var elDimensionsZ = document.getElementById("property-dim-z");
             var elResetToNaturalDimensions = document.getElementById("reset-to-natural-dimensions");
+            var elRescaleDimensionsPct = document.getElementById("dimension-rescale-pct");
+            var elRescaleDimensionsButton  = document.getElementById("dimension-rescale-button");
 
             var elRegistrationX = document.getElementById("property-reg-x");
             var elRegistrationY = document.getElementById("property-reg-y");
@@ -419,6 +421,13 @@
                     action: "resetToNaturalDimensions",
                 }));
             });
+            elRescaleDimensionsButton.addEventListener("click", function() {
+                EventBridge.emitWebEvent(JSON.stringify({
+                    type: "action",
+                    action: "rescaleDimensions",
+                    percentage: parseInt(elRescaleDimensionsPct.value),
+                }));
+            });
 
 
             var resizing = false;
@@ -537,6 +546,12 @@
                 <div>
                     <input type="button" id="reset-to-natural-dimensions" value="Reset to Natural Dimensions">
                 </div>
+                <div class="input-area">
+                    <input class="coord" type='number' id="dimension-rescale-pct" value=100></input>%
+                </div>
+                <span>
+                    <input type="button" id="dimension-rescale-button" value="Rescale"></input>
+                </span>
             </td>
         </tr>
 

examples/hydraGrab.js

@@ -0,0 +1,742 @@
+//
+//  hydraGrab.js
+//  examples
+//
+//  Created by Clément Brisset on 4/24/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  This script allows you to edit models either with the razor hydras or with your mouse
+//
+//  Using the hydras :
+//  grab models with the triggers, you can then move the models around or scale them with both hands.
+//  You can switch mode using the bumpers so that you can move models around more easily.
+//
+//  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/entityPropertyDialogBox.js");
+var entityPropertyDialogBox = EntityPropertyDialogBox;
+
+var LASER_WIDTH = 4;
+var LASER_COLOR = { red: 255, green: 0, blue: 0 };
+var LASER_LENGTH_FACTOR = 500;
+
+var MIN_ANGULAR_SIZE = 2;
+var MAX_ANGULAR_SIZE = 45;
+var allowLargeModels = false;
+var allowSmallModels = false;
+var wantEntityGlow = false;
+
+var LEFT = 0;
+var RIGHT = 1;
+
+var jointList = MyAvatar.getJointNames();
+
+var mode = 0;
+
+function controller(wichSide) {
+    this.side = wichSide;
+    this.palm = 2 * wichSide;
+    this.tip = 2 * wichSide + 1;
+    this.trigger = wichSide;
+    this.bumper = 6 * wichSide + 5;
+
+    this.oldPalmPosition = Controller.getSpatialControlPosition(this.palm);
+    this.palmPosition = Controller.getSpatialControlPosition(this.palm);
+
+    this.oldTipPosition = Controller.getSpatialControlPosition(this.tip);
+    this.tipPosition = Controller.getSpatialControlPosition(this.tip);
+
+    this.oldUp = Controller.getSpatialControlNormal(this.palm);
+    this.up = this.oldUp;
+
+    this.oldFront = Vec3.normalize(Vec3.subtract(this.tipPosition, this.palmPosition));
+    this.front = this.oldFront;
+
+    this.oldRight = Vec3.cross(this.front, this.up);
+    this.right = this.oldRight;
+
+    this.oldRotation = Quat.multiply(MyAvatar.orientation, Controller.getSpatialControlRawRotation(this.palm));
+    this.rotation = this.oldRotation;
+
+    this.triggerValue = Controller.getTriggerValue(this.trigger);
+    this.bumperValue = Controller.isButtonPressed(this.bumper);
+
+    this.pressed = false; // is trigger pressed
+    this.pressing = false; // is trigger being pressed (is pressed now but wasn't previously)
+
+    this.grabbing = false;
+    this.entityID = { isKnownID: false };
+    this.modelURL = "";
+    this.oldModelRotation;
+    this.oldModelPosition;
+    this.oldModelHalfDiagonal;
+
+    this.positionAtGrab;
+    this.rotationAtGrab;
+    this.modelPositionAtGrab;
+    this.rotationAtGrab;
+    this.jointsIntersectingFromStart = [];
+
+    this.laser = Overlays.addOverlay("line3d", {
+        start: { x: 0, y: 0, z: 0 },
+        end: { x: 0, y: 0, z: 0 },
+        color: LASER_COLOR,
+        alpha: 1,
+        visible: false,
+        lineWidth: LASER_WIDTH,
+        anchor: "MyAvatar"
+    });
+
+    this.guideScale = 0.02;
+    this.ball = Overlays.addOverlay("sphere", {
+        position: { x: 0, y: 0, z: 0 },
+        size: this.guideScale,
+        solid: true,
+        color: { red: 0, green: 255, blue: 0 },
+        alpha: 1,
+        visible: false,
+        anchor: "MyAvatar"
+    });
+    this.leftRight = Overlays.addOverlay("line3d", {
+        start: { x: 0, y: 0, z: 0 },
+        end: { x: 0, y: 0, z: 0 },
+        color: { red: 0, green: 0, blue: 255 },
+        alpha: 1,
+        visible: false,
+        lineWidth: LASER_WIDTH,
+        anchor: "MyAvatar"
+    });
+    this.topDown = Overlays.addOverlay("line3d", {
+                                       start: { x: 0, y: 0, z: 0 },
+                                       end: { x: 0, y: 0, z: 0 },
+                                       color: { red: 0, green: 0, blue: 255 },
+                                       alpha: 1,
+                                       visible: false,
+                                       lineWidth: LASER_WIDTH,
+                                       anchor: "MyAvatar"
+                                       });
+    
+
+    
+    this.grab = function (entityID, properties) {
+        print("Grabbing " + entityID.id);
+        this.grabbing = true;
+        this.entityID = entityID;
+        this.modelURL = properties.modelURL;
+
+        this.oldModelPosition = properties.position;
+        this.oldModelRotation = properties.rotation;
+        this.oldModelHalfDiagonal = Vec3.length(properties.dimensions) / 2.0;
+
+        this.positionAtGrab = this.palmPosition;
+        this.rotationAtGrab = this.rotation;
+        this.modelPositionAtGrab = properties.position;
+        this.rotationAtGrab = properties.rotation;
+        this.jointsIntersectingFromStart = [];
+        for (var i = 0; i < jointList.length; i++) {
+            var distance = Vec3.distance(MyAvatar.getJointPosition(jointList[i]), this.oldModelPosition);
+            if (distance < this.oldModelHalfDiagonal) {
+                this.jointsIntersectingFromStart.push(i);
+            }
+        }
+        this.showLaser(false);
+    }
+
+    this.release = function () {
+        if (this.grabbing) {
+            jointList = MyAvatar.getJointNames();
+
+            var closestJointIndex = -1;
+            var closestJointDistance = 10;
+            for (var i = 0; i < jointList.length; i++) {
+                var distance = Vec3.distance(MyAvatar.getJointPosition(jointList[i]), this.oldModelPosition);
+                if (distance < closestJointDistance) {
+                    closestJointDistance = distance;
+                    closestJointIndex = i;
+                }
+            }
+
+            if (closestJointIndex != -1) {
+                print("closestJoint: " + jointList[closestJointIndex]);
+                print("closestJointDistance (attach max distance): " + closestJointDistance + " (" + this.oldModelHalfDiagonal + ")");
+            }
+
+            if (closestJointDistance < this.oldModelHalfDiagonal) {
+
+                if (this.jointsIntersectingFromStart.indexOf(closestJointIndex) != -1 ||
+                    (leftController.grabbing && rightController.grabbing &&
+                    leftController.entityID.id == rightController.entityID.id)) {
+                    // Do nothing
+                } else {
+                    print("Attaching to " + jointList[closestJointIndex]);
+                    var jointPosition = MyAvatar.getJointPosition(jointList[closestJointIndex]);
+                    var jointRotation = MyAvatar.getJointCombinedRotation(jointList[closestJointIndex]);
+
+                    var attachmentOffset = Vec3.subtract(this.oldModelPosition, jointPosition);
+                    attachmentOffset = Vec3.multiplyQbyV(Quat.inverse(jointRotation), attachmentOffset);
+                    var attachmentRotation = Quat.multiply(Quat.inverse(jointRotation), this.oldModelRotation);
+
+                    MyAvatar.attach(this.modelURL, jointList[closestJointIndex],
+                                    attachmentOffset, attachmentRotation, 2.0 * this.oldModelHalfDiagonal,
+                                    true, false);
+                    Entities.deleteEntity(this.entityID);
+                }
+            }
+        }
+
+        this.grabbing = false;
+        this.entityID.isKnownID = false;
+        this.jointsIntersectingFromStart = [];
+        this.showLaser(true);
+    }
+
+    this.checkTrigger = function () {
+        if (this.triggerValue > 0.9) {
+            if (this.pressed) {
+                this.pressing = false;
+            } else {
+                this.pressing = true;
+            }
+            this.pressed = true;
+        } else {
+            this.pressing = false;
+            this.pressed = false;
+        }
+    }
+
+    this.checkEntity = function (properties) {
+        //                P         P - Model
+        //               /|         A - Palm
+        //              / | d       B - unit vector toward tip
+        //             /  |         X - base of the perpendicular line
+        //            A---X----->B  d - distance fom axis
+        //              x           x - distance from A
+        //
+        //            |X-A| = (P-A).B
+        //            X == A + ((P-A).B)B
+        //            d = |P-X|
+
+        var A = this.palmPosition;
+        var B = this.front;
+        var P = properties.position;
+
+        var x = Vec3.dot(Vec3.subtract(P, A), B);
+        var y = Vec3.dot(Vec3.subtract(P, A), this.up);
+        var z = Vec3.dot(Vec3.subtract(P, A), this.right);
+        var X = Vec3.sum(A, Vec3.multiply(B, x));
+        var d = Vec3.length(Vec3.subtract(P, X));
+        var halfDiagonal = Vec3.length(properties.dimensions) / 2.0;
+
+        var angularSize = 2 * Math.atan(halfDiagonal / Vec3.distance(Camera.getPosition(), properties.position)) * 180 / 3.14;
+        
+        var sizeOK = (allowLargeModels || angularSize < MAX_ANGULAR_SIZE) 
+                        && (allowSmallModels || angularSize > MIN_ANGULAR_SIZE);
+
+        if (0 < x && sizeOK) {
+            return { valid: true, x: x, y: y, z: z };
+        }
+        return { valid: false };
+    }
+
+    this.glowedIntersectingModel = { isKnownID: false };
+    this.moveLaser = function () {
+        // the overlays here are anchored to the avatar, which means they are specified in the avatar's local frame
+
+        var inverseRotation = Quat.inverse(MyAvatar.orientation);
+        var startPosition = Vec3.multiplyQbyV(inverseRotation, Vec3.subtract(this.palmPosition, MyAvatar.position));
+        var direction = Vec3.multiplyQbyV(inverseRotation, Vec3.subtract(this.tipPosition, this.palmPosition));
+        var distance = Vec3.length(direction);
+        direction = Vec3.multiply(direction, LASER_LENGTH_FACTOR / distance);
+        var endPosition = Vec3.sum(startPosition, direction);
+
+        Overlays.editOverlay(this.laser, {
+            start: startPosition,
+            end: endPosition
+        });
+
+
+        Overlays.editOverlay(this.ball, {
+            position: endPosition
+        });
+        Overlays.editOverlay(this.leftRight, {
+            start: Vec3.sum(endPosition, Vec3.multiply(this.right, 2 * this.guideScale)),
+            end: Vec3.sum(endPosition, Vec3.multiply(this.right, -2 * this.guideScale))
+        });
+        Overlays.editOverlay(this.topDown, {
+            start: Vec3.sum(endPosition, Vec3.multiply(this.up, 2 * this.guideScale)),
+            end: Vec3.sum(endPosition, Vec3.multiply(this.up, -2 * this.guideScale))
+        });
+        this.showLaser(!this.grabbing || mode == 0);
+
+        if (this.glowedIntersectingModel.isKnownID) {
+            Entities.editEntity(this.glowedIntersectingModel, { glowLevel: 0.0 });
+            this.glowedIntersectingModel.isKnownID = false;
+        }
+        if (!this.grabbing) {
+            var intersection = Entities.findRayIntersection({
+                                                          origin: this.palmPosition,
+                                                          direction: this.front
+                                                          });
+                                                          
+            var halfDiagonal = Vec3.length(intersection.properties.dimensions) / 2.0;
+                                                          
+            var angularSize = 2 * Math.atan(halfDiagonal / Vec3.distance(Camera.getPosition(), intersection.properties.position)) * 180 / 3.14;
+            var sizeOK = (allowLargeModels || angularSize < MAX_ANGULAR_SIZE) 
+                            && (allowSmallModels || angularSize > MIN_ANGULAR_SIZE);
+            if (intersection.accurate && intersection.entityID.isKnownID && sizeOK) {
+                this.glowedIntersectingModel = intersection.entityID;
+                
+                if (wantEntityGlow) {
+                    Entities.editEntity(this.glowedIntersectingModel, { glowLevel: 0.25 });
+                }
+            }
+        }
+    }
+
+    this.showLaser = function (show) {
+        Overlays.editOverlay(this.laser, { visible: show });
+        Overlays.editOverlay(this.ball, { visible: show });
+        Overlays.editOverlay(this.leftRight, { visible: show });
+        Overlays.editOverlay(this.topDown, { visible: show });
+    }
+    this.moveEntity = function () {
+        if (this.grabbing) {
+            if (!this.entityID.isKnownID) {
+                print("Unknown grabbed ID " + this.entityID.id + ", isKnown: " + this.entityID.isKnownID);
+                this.entityID =  Entities.findRayIntersection({
+                                                        origin: this.palmPosition,
+                                                        direction: this.front
+                                                           }).entityID;
+                print("Identified ID " + this.entityID.id + ", isKnown: " + this.entityID.isKnownID);
+            }
+            var newPosition;
+            var newRotation;
+
+            switch (mode) {
+                case 0:
+                    newPosition = Vec3.sum(this.palmPosition,
+                                           Vec3.multiply(this.front, this.x));
+                    newPosition = Vec3.sum(newPosition,
+                                           Vec3.multiply(this.up, this.y));
+                    newPosition = Vec3.sum(newPosition,
+                                           Vec3.multiply(this.right, this.z));
+
+
+                    newRotation = Quat.multiply(this.rotation,
+                                                Quat.inverse(this.oldRotation));
+                    newRotation = Quat.multiply(newRotation,
+                                                this.oldModelRotation);
+                    break;
+                case 1:
+                    var forward = Vec3.multiplyQbyV(MyAvatar.orientation, { x: 0, y: 0, z: -1 });
+                    var d = Vec3.dot(forward, MyAvatar.position);
+
+                    var factor1 = Vec3.dot(forward, this.positionAtGrab) - d;
+                    var factor2 = Vec3.dot(forward, this.modelPositionAtGrab) - d;
+                    var vector = Vec3.subtract(this.palmPosition, this.positionAtGrab);
+
+                    if (factor2 < 0) {
+                        factor2 = 0;
+                    }
+                    if (factor1 <= 0) {
+                        factor1 = 1;
+                        factor2 = 1;
+                    }
+
+                    newPosition = Vec3.sum(this.modelPositionAtGrab,
+                                           Vec3.multiply(vector,
+                                                         factor2 / factor1));
+
+                    newRotation = Quat.multiply(this.rotation,
+                                                Quat.inverse(this.rotationAtGrab));
+                    newRotation = Quat.multiply(newRotation,
+                                                this.rotationAtGrab);
+                    break;
+            }
+            Entities.editEntity(this.entityID, {
+                             position: newPosition,
+                             rotation: newRotation
+                             });
+            this.oldModelRotation = newRotation;
+            this.oldModelPosition = newPosition;
+
+            var indicesToRemove = [];
+            for (var i = 0; i < this.jointsIntersectingFromStart.length; ++i) {
+                var distance = Vec3.distance(MyAvatar.getJointPosition(this.jointsIntersectingFromStart[i]), this.oldModelPosition);
+                if (distance >= this.oldModelHalfDiagonal) {
+                    indicesToRemove.push(this.jointsIntersectingFromStart[i]);
+                }
+
+            }
+            for (var i = 0; i < indicesToRemove.length; ++i) {
+                this.jointsIntersectingFromStart.splice(this.jointsIntersectingFromStart.indexOf(indicesToRemove[i], 1));
+            }
+        }
+    }
+
+    this.update = function () {
+        this.oldPalmPosition = this.palmPosition;
+        this.oldTipPosition = this.tipPosition;
+        this.palmPosition = Controller.getSpatialControlPosition(this.palm);
+        this.tipPosition = Controller.getSpatialControlPosition(this.tip);
+
+        this.oldUp = this.up;
+        this.up = Vec3.normalize(Controller.getSpatialControlNormal(this.palm));
+
+        this.oldFront = this.front;
+        this.front = Vec3.normalize(Vec3.subtract(this.tipPosition, this.palmPosition));
+
+        this.oldRight = this.right;
+        this.right = Vec3.normalize(Vec3.cross(this.front, this.up));
+
+        this.oldRotation = this.rotation;
+        this.rotation = Quat.multiply(MyAvatar.orientation, Controller.getSpatialControlRawRotation(this.palm));
+
+        this.triggerValue = Controller.getTriggerValue(this.trigger);
+
+        var bumperValue = Controller.isButtonPressed(this.bumper);
+        if (bumperValue && !this.bumperValue) {
+            if (mode == 0) {
+                mode = 1;
+                Overlays.editOverlay(leftController.laser, { color: { red: 0, green: 0, blue: 255 } });
+                Overlays.editOverlay(rightController.laser, { color: { red: 0, green: 0, blue: 255 } });
+            } else {
+                mode = 0;
+                Overlays.editOverlay(leftController.laser, { color: { red: 255, green: 0, blue: 0 } });
+                Overlays.editOverlay(rightController.laser, { color: { red: 255, green: 0, blue: 0 } });
+            }
+        }
+        this.bumperValue = bumperValue;
+
+
+        this.checkTrigger();
+
+        this.moveLaser();
+
+        if (!this.pressed && this.grabbing) {
+            // release if trigger not pressed anymore.
+            this.release();
+        }
+
+        if (this.pressing) {
+            // Checking for attachments intersecting
+            var attachments = MyAvatar.getAttachmentData();
+            var attachmentIndex = -1;
+            var attachmentX = LASER_LENGTH_FACTOR;
+
+            var newModel;
+            var newProperties;
+
+            for (var i = 0; i < attachments.length; ++i) {
+                var position = Vec3.sum(MyAvatar.getJointPosition(attachments[i].jointName),
+                                        Vec3.multiplyQbyV(MyAvatar.getJointCombinedRotation(attachments[i].jointName), attachments[i].translation));
+                var scale = attachments[i].scale;
+
+                var A = this.palmPosition;
+                var B = this.front;
+                var P = position;
+
+                var x = Vec3.dot(Vec3.subtract(P, A), B);
+                var X = Vec3.sum(A, Vec3.multiply(B, x));
+                var d = Vec3.length(Vec3.subtract(P, X));
+
+                if (d < scale / 2.0 && 0 < x && x < attachmentX) {
+                    attachmentIndex = i;
+                    attachmentX = d;
+                }
+            }
+
+            if (attachmentIndex != -1) {
+                print("Detaching: " + attachments[attachmentIndex].modelURL);
+                MyAvatar.detachOne(attachments[attachmentIndex].modelURL, attachments[attachmentIndex].jointName);
+
+                newProperties = {
+                    type: "Model",
+                    position: Vec3.sum(MyAvatar.getJointPosition(attachments[attachmentIndex].jointName),
+                                       Vec3.multiplyQbyV(MyAvatar.getJointCombinedRotation(attachments[attachmentIndex].jointName), attachments[attachmentIndex].translation)),
+                    rotation: Quat.multiply(MyAvatar.getJointCombinedRotation(attachments[attachmentIndex].jointName),
+                                                 attachments[attachmentIndex].rotation),
+                                                 
+                    // TODO: how do we know the correct dimensions for detachment???
+                    dimensions: { x: attachments[attachmentIndex].scale / 2.0,
+                                  y: attachments[attachmentIndex].scale / 2.0,
+                                  z: attachments[attachmentIndex].scale / 2.0 },
+                                  
+                    modelURL: attachments[attachmentIndex].modelURL
+                };
+
+                newModel = Entities.addEntity(newProperties);
+
+
+            } else {
+                // There is none so ...
+                // Checking model tree
+                Vec3.print("Looking at: ", this.palmPosition);
+                var pickRay = { origin: this.palmPosition,
+                    direction: Vec3.normalize(Vec3.subtract(this.tipPosition, this.palmPosition)) };
+                var foundIntersection = Entities.findRayIntersection(pickRay);
+                
+                if(!foundIntersection.accurate) {
+                    print("No accurate intersection");
+                    return;
+                }
+                newModel = foundIntersection.entityID;
+                if (!newModel.isKnownID) {
+                    var identify = Entities.identifyEntity(newModel);
+                    if (!identify.isKnownID) {
+                        print("Unknown ID " + identify.id + " (update loop " + newModel.id + ")");
+                        return;
+                    }
+                    newModel = identify;
+                }
+                newProperties = Entities.getEntityProperties(newModel);
+            }
+            print("foundEntity.modelURL=" + newProperties.modelURL);
+            var check = this.checkEntity(newProperties);
+            if (!check.valid) {
+                return;
+            }
+
+            this.grab(newModel, newProperties);
+
+            this.x = check.x;
+            this.y = check.y;
+            this.z = check.z;
+            return;
+        }
+    }
+
+    this.cleanup = function () {
+        Overlays.deleteOverlay(this.laser);
+        Overlays.deleteOverlay(this.ball);
+        Overlays.deleteOverlay(this.leftRight);
+        Overlays.deleteOverlay(this.topDown);
+    }
+}
+
+var leftController = new controller(LEFT);
+var rightController = new controller(RIGHT);
+
+function moveEntities() {
+    if (leftController.grabbing && rightController.grabbing && rightController.entityID.id == leftController.entityID.id) {
+        var newPosition = leftController.oldModelPosition;
+        var rotation = leftController.oldModelRotation;
+        var ratio = 1;
+
+
+        switch (mode) {
+            case 0:
+                var oldLeftPoint = Vec3.sum(leftController.oldPalmPosition, Vec3.multiply(leftController.oldFront, leftController.x));
+                var oldRightPoint = Vec3.sum(rightController.oldPalmPosition, Vec3.multiply(rightController.oldFront, rightController.x));
+
+                var oldMiddle = Vec3.multiply(Vec3.sum(oldLeftPoint, oldRightPoint), 0.5);
+                var oldLength = Vec3.length(Vec3.subtract(oldLeftPoint, oldRightPoint));
+
+
+                var leftPoint = Vec3.sum(leftController.palmPosition, Vec3.multiply(leftController.front, leftController.x));
+                var rightPoint = Vec3.sum(rightController.palmPosition, Vec3.multiply(rightController.front, rightController.x));
+
+                var middle = Vec3.multiply(Vec3.sum(leftPoint, rightPoint), 0.5);
+                var length = Vec3.length(Vec3.subtract(leftPoint, rightPoint));
+
+
+                ratio = length / oldLength;
+                newPosition = Vec3.sum(middle,
+                                       Vec3.multiply(Vec3.subtract(leftController.oldModelPosition, oldMiddle), ratio));
+                break;
+            case 1:
+                var u = Vec3.normalize(Vec3.subtract(rightController.oldPalmPosition, leftController.oldPalmPosition));
+                var v = Vec3.normalize(Vec3.subtract(rightController.palmPosition, leftController.palmPosition));
+
+                var cos_theta = Vec3.dot(u, v);
+                if (cos_theta > 1) {
+                    cos_theta = 1;
+                }
+                var angle = Math.acos(cos_theta) / Math.PI * 180;
+                if (angle < 0.1) {
+                    return;
+
+                }
+                var w = Vec3.normalize(Vec3.cross(u, v));
+
+                rotation = Quat.multiply(Quat.angleAxis(angle, w), leftController.oldModelRotation);
+
+
+                leftController.positionAtGrab = leftController.palmPosition;
+                leftController.rotationAtGrab = leftController.rotation;
+                leftController.modelPositionAtGrab = leftController.oldModelPosition;
+                leftController.rotationAtGrab = rotation;
+                rightController.positionAtGrab = rightController.palmPosition;
+                rightController.rotationAtGrab = rightController.rotation;
+                rightController.modelPositionAtGrab = rightController.oldModelPosition;
+                rightController.rotationAtGrab = rotation;
+                break;
+        }
+        Entities.editEntity(leftController.entityID, {
+                         position: newPosition,
+                         rotation: rotation,
+                         // TODO: how do we know the correct dimensions for detachment???
+                         //radius: leftController.oldModelHalfDiagonal * ratio
+                         dimensions: { x: leftController.oldModelHalfDiagonal * ratio,
+                                       y: leftController.oldModelHalfDiagonal * ratio,
+                                       z: leftController.oldModelHalfDiagonal * ratio }
+
+
+                         });
+        leftController.oldModelPosition = newPosition;
+        leftController.oldModelRotation = rotation;
+        leftController.oldModelHalfDiagonal *= ratio;
+
+        rightController.oldModelPosition = newPosition;
+        rightController.oldModelRotation = rotation;
+        rightController.oldModelHalfDiagonal *= ratio;
+        return;
+    }
+    leftController.moveEntity();
+    rightController.moveEntity();
+}
+
+var hydraConnected = false;
+function checkController(deltaTime) {
+    var numberOfButtons = Controller.getNumberOfButtons();
+    var numberOfTriggers = Controller.getNumberOfTriggers();
+    var numberOfSpatialControls = Controller.getNumberOfSpatialControls();
+    var controllersPerTrigger = numberOfSpatialControls / numberOfTriggers;
+
+    // this is expected for hydras
+    if (numberOfButtons == 12 && numberOfTriggers == 2 && controllersPerTrigger == 2) {
+        if (!hydraConnected) {
+            hydraConnected = true;
+        }
+
+        leftController.update();
+        rightController.update();
+        moveEntities();
+    } else {
+        if (hydraConnected) {
+            hydraConnected = false;
+
+            leftController.showLaser(false);
+            rightController.showLaser(false);
+        }
+    }
+}
+
+var glowedEntityID = { id: -1, isKnownID: false };
+
+// In order for editVoxels and editModels to play nice together, they each check to see if a "delete" menu item already
+// exists. If it doesn't they add it. If it does they don't. They also only delete the menu item if they were the one that
+// added it.
+var modelMenuAddedDelete = false;
+var originalLightsArePickable = Entities.getLightsArePickable();
+function setupModelMenus() {
+    print("setupModelMenus()");
+    // adj our menuitems
+    Menu.addMenuItem({ menuName: "Edit", menuItemName: "Models", isSeparator: true, beforeItem: "Physics" });
+    Menu.addMenuItem({ menuName: "Edit", menuItemName: "Edit Properties...",
+        shortcutKeyEvent: { text: "`" }, afterItem: "Models" });
+    if (!Menu.menuItemExists("Edit", "Delete")) {
+        print("no delete... adding ours");
+        Menu.addMenuItem({ menuName: "Edit", menuItemName: "Delete",
+            shortcutKeyEvent: { text: "backspace" }, afterItem: "Models" });
+        modelMenuAddedDelete = true;
+    } else {
+        print("delete exists... don't add ours");
+    }
+
+    Menu.addMenuItem({ menuName: "Edit", menuItemName: "Allow Selecting of Large Models", shortcutKey: "CTRL+META+L", 
+                        afterItem: "Paste Models", isCheckable: true });
+    Menu.addMenuItem({ menuName: "Edit", menuItemName: "Allow Selecting of Small Models", shortcutKey: "CTRL+META+S", 
+                        afterItem: "Allow Selecting of Large Models", isCheckable: true });
+    Menu.addMenuItem({ menuName: "Edit", menuItemName: "Allow Selecting of Lights", shortcutKey: "CTRL+SHIFT+META+L", 
+                        afterItem: "Allow Selecting of Small Models", isCheckable: true });
+
+    Entities.setLightsArePickable(false);
+}
+
+function cleanupModelMenus() {
+    Menu.removeMenuItem("Edit", "Edit Properties...");
+    if (modelMenuAddedDelete) {
+        // delete our menuitems
+        Menu.removeMenuItem("Edit", "Delete");
+    }
+
+    Menu.removeMenuItem("Edit", "Allow Selecting of Large Models");
+    Menu.removeMenuItem("Edit", "Allow Selecting of Small Models");
+    Menu.removeMenuItem("Edit", "Allow Selecting of Lights");
+
+}
+
+function scriptEnding() {
+    leftController.cleanup();
+    rightController.cleanup();
+    cleanupModelMenus();
+    Entities.setLightsArePickable(originalLightsArePickable);
+}
+Script.scriptEnding.connect(scriptEnding);
+
+// register the call back so it fires before each data send
+Script.update.connect(checkController);
+
+setupModelMenus();
+
+var editModelID = -1;
+function showPropertiesForm(editModelID) {
+    entityPropertyDialogBox.openDialog(editModelID);
+}
+
+Menu.menuItemEvent.connect(function (menuItem) {
+    print("menuItemEvent() in JS... menuItem=" + menuItem);
+    if (menuItem == "Allow Selecting of Small Models") {
+        allowSmallModels = Menu.isOptionChecked("Allow Selecting of Small Models");
+    } else if (menuItem == "Allow Selecting of Large Models") {
+        allowLargeModels = Menu.isOptionChecked("Allow Selecting of Large Models");
+    } else if (menuItem == "Allow Selecting of Lights") {
+        Entities.setLightsArePickable(Menu.isOptionChecked("Allow Selecting of Lights"));
+    } else if (menuItem == "Delete") {
+        if (leftController.grabbing) {
+            print("  Delete Entity.... leftController.entityID="+ leftController.entityID);
+            Entities.deleteEntity(leftController.entityID);
+            leftController.grabbing = false;
+            if (glowedEntityID.id == leftController.entityID.id) {
+                glowedEntityID = { id: -1, isKnownID: false };
+            }
+        } else if (rightController.grabbing) {
+            print("  Delete Entity.... rightController.entityID="+ rightController.entityID);
+            Entities.deleteEntity(rightController.entityID);
+            rightController.grabbing = false;
+            if (glowedEntityID.id == rightController.entityID.id) {
+                glowedEntityID = { id: -1, isKnownID: false };
+            }
+        } else {
+            print("  Delete Entity.... not holding...");
+        }
+    } else if (menuItem == "Edit Properties...") {
+        editModelID = -1;
+        if (leftController.grabbing) {
+            print("  Edit Properties.... leftController.entityID="+ leftController.entityID);
+            editModelID = leftController.entityID;
+        } else if (rightController.grabbing) {
+            print("  Edit Properties.... rightController.entityID="+ rightController.entityID);
+            editModelID = rightController.entityID;
+        } else {
+            print("  Edit Properties.... not holding...");
+        }
+        if (editModelID != -1) {
+            print("  Edit Properties.... about to edit properties...");
+            showPropertiesForm(editModelID);
+        }
+    }
+});
+
+Controller.keyReleaseEvent.connect(function (event) {
+    // since sometimes our menu shortcut keys don't work, trap our menu items here also and fire the appropriate menu items
+    if (event.text == "`") {
+        handeMenuEvent("Edit Properties...");
+    }
+    if (event.text == "BACKSPACE") {
+        handeMenuEvent("Delete");
+    }
+});
+

examples/lobby.js

@@ -139,10 +139,10 @@ function drawLobby() {
     MyAvatar.attach(HELMET_ATTACHMENT_URL, "Neck", {x: 0, y: 0, z: 0}, Quat.fromPitchYawRollDegrees(0, 0, 0), 1.15);
     
     // start the drone sound
-    currentDrone = Audio.playSound(droneSound, { stereo: true, loop: true, localOnly: true, volume: DRONE_VOLUME });
+    // currentDrone = Audio.playSound(droneSound, { stereo: true, loop: true, localOnly: true, volume: DRONE_VOLUME });
     
     // start one of our muzak sounds
-    playRandomMuzak();
+    // playRandomMuzak();
   }
 }
 
@@ -353,9 +353,9 @@ function update(deltaTime) {
     Overlays.editOverlay(descriptionText, { position: textOverlayPosition() });
 
     // if the reticle is up then we may need to play the next muzak
-    if (!Audio.isInjectorPlaying(currentMuzakInjector)) {
+    // if (!Audio.isInjectorPlaying(currentMuzakInjector)) {
-      playNextMuzak();
+//       playNextMuzak();
-    }
+//     }
   }
 }
 

interface/external/sdl2/readme.txt

@@ -0,0 +1,13 @@
+
+Instructions for adding the SDL library (SDL2) to Interface
+David Rowe, 11 Jan 2015
+
+You can download the SDL development library from https://www.libsdl.org/. Interface has been tested with version 2.0.3.
+
+1. Copy the include and lib folders into the interface/externals/sdl2 folder.
+   This readme.txt should be there as well.
+   
+   You may optionally choose to copy the SDK folders to a location outside the repository (so you can re-use with different checkouts and different projects). 
+   If so our CMake find module expects you to set the ENV variable 'HIFI_LIB_DIR' to a directory containing a subfolder 'sdl2' that contains the two folders mentioned above.
+
+2. Clear your build directory, run cmake and build, and you should be all set.

libraries/entities/src/DeleteEntityOperator.cpp

@@ -92,7 +92,8 @@ bool DeleteEntityOperator::preRecursion(OctreeElement* element) {
             // and we can stop searching.
             if (entityTreeElement == details.containingElement) {
                 EntityItem* theEntity = details.entity;
-                assert(entityTreeElement->removeEntityItem(theEntity)); // remove it from the element
+                bool entityDeleted = entityTreeElement->removeEntityItem(theEntity); // remove it from the element
+                assert(entityDeleted);
                 _tree->setContainingElement(details.entity->getEntityItemID(), NULL); // update or id to element lookup
                 _foundCount++;
             }

libraries/entities/src/EntityItem.cpp

@@ -21,31 +21,6 @@
 #include "EntityItem.h"
 #include "EntityTree.h"
 
-const float EntityItem::IMMORTAL = -1.0f; /// special lifetime which means the entity lives for ever. default lifetime
-const float EntityItem::DEFAULT_GLOW_LEVEL = 0.0f;
-const float EntityItem::DEFAULT_LOCAL_RENDER_ALPHA = 1.0f;
-const float EntityItem::DEFAULT_MASS = 1.0f;
-const float EntityItem::DEFAULT_LIFETIME = EntityItem::IMMORTAL;
-const QString EntityItem::DEFAULT_USER_DATA = QString("");
-const float EntityItem::DEFAULT_DAMPING = 0.39347f;  // approx timescale = 2.0 sec (see damping timescale formula in header)
-const glm::vec3 EntityItem::NO_VELOCITY = glm::vec3(0, 0, 0);
-const float EntityItem::EPSILON_VELOCITY_LENGTH = (1.0f / 1000.0f) / (float)TREE_SCALE; // really small: 1mm/second
-const glm::vec3 EntityItem::DEFAULT_VELOCITY = EntityItem::NO_VELOCITY;
-const glm::vec3 EntityItem::NO_GRAVITY = glm::vec3(0, 0, 0);
-const glm::vec3 EntityItem::REGULAR_GRAVITY = glm::vec3(0, (-9.8f / TREE_SCALE), 0);
-const glm::vec3 EntityItem::DEFAULT_GRAVITY = EntityItem::NO_GRAVITY;
-const QString EntityItem::DEFAULT_SCRIPT = QString("");
-const glm::quat EntityItem::DEFAULT_ROTATION;
-const glm::vec3 EntityItem::DEFAULT_DIMENSIONS = glm::vec3(0.1f, 0.1f, 0.1f);
-const glm::vec3 EntityItem::DEFAULT_REGISTRATION_POINT = glm::vec3(0.5f, 0.5f, 0.5f); // center
-const glm::vec3 EntityItem::NO_ANGULAR_VELOCITY = glm::vec3(0.0f, 0.0f, 0.0f);
-const glm::vec3 EntityItem::DEFAULT_ANGULAR_VELOCITY = NO_ANGULAR_VELOCITY;
-const float EntityItem::DEFAULT_ANGULAR_DAMPING = 2.0f;
-const bool EntityItem::DEFAULT_VISIBLE = true;
-const bool EntityItem::DEFAULT_IGNORE_FOR_COLLISIONS = false;
-const bool EntityItem::DEFAULT_COLLISIONS_WILL_MOVE = false;
-const bool EntityItem::DEFAULT_LOCKED = false;
-
 void EntityItem::initFromEntityItemID(const EntityItemID& entityItemID) {
     _id = entityItemID.id;
     _creatorTokenID = entityItemID.creatorTokenID;
@@ -95,6 +70,7 @@ EntityItem::EntityItem(const EntityItemID& entityItemID) {
     _physicsInfo = NULL;
     _dirtyFlags = 0;
     _changedOnServer = 0;
+    _element = NULL;
     initFromEntityItemID(entityItemID);
 }
 
@@ -110,6 +86,7 @@ EntityItem::EntityItem(const EntityItemID& entityItemID, const EntityItemPropert
     _physicsInfo = NULL;
     _dirtyFlags = 0;
     _changedOnServer = 0;
+    _element = NULL;
     initFromEntityItemID(entityItemID);
     setProperties(properties);
 }
@@ -117,6 +94,7 @@ EntityItem::EntityItem(const EntityItemID& entityItemID, const EntityItemPropert
 EntityItem::~EntityItem() {
     // be sure to clean up _physicsInfo before calling this dtor
     assert(_physicsInfo == NULL);
+    assert(_element == NULL);
 }
 
 EntityPropertyFlags EntityItem::getEntityProperties(EncodeBitstreamParams& params) const {
@@ -1015,7 +993,6 @@ void EntityItem::recalculateCollisionShape() {
     entityAACube.scale(TREE_SCALE); // scale to meters
     _collisionShape.setTranslation(entityAACube.calcCenter());
     _collisionShape.setScale(entityAACube.getScale());
-    // TODO: use motionState to update physics object
 }
 
 const float MIN_POSITION_DELTA = 0.0001f;

libraries/entities/src/EntityItem.h

@@ -35,10 +35,36 @@ class EntityTreeElementExtraEncodeData;
 #define DONT_ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() = 0;
 #define ALLOW_INSTANTIATION virtual void pureVirtualFunctionPlaceHolder() { };
 
+const glm::vec3 DEFAULT_DIMENSIONS = glm::vec3(0.1f) / (float)TREE_SCALE;
+const glm::quat DEFAULT_ROTATION;
+const float DEFAULT_GLOW_LEVEL = 0.0f;
+const float DEFAULT_LOCAL_RENDER_ALPHA = 1.0f;
+const float DEFAULT_MASS = 1.0f;
+const glm::vec3 NO_VELOCITY= glm::vec3(0.0f);
+const glm::vec3 DEFAULT_VELOCITY = NO_VELOCITY;
+const float EPSILON_VELOCITY_LENGTH = 0.001f / (float)TREE_SCALE;
+const glm::vec3 NO_GRAVITY = glm::vec3(0.0f);
+const glm::vec3 DEFAULT_GRAVITY = NO_GRAVITY;
+const glm::vec3 REGULAR_GRAVITY = glm::vec3(0, -9.8f / (float)TREE_SCALE, 0);
+const float DEFAULT_DAMPING = 0.39347f;  // approx timescale = 2.0 sec (see damping timescale formula in header)
+const float IMMORTAL = -1.0f; /// special lifetime which means the entity lives for ever. default lifetime
+const float DEFAULT_LIFETIME = IMMORTAL;
+const QString DEFAULT_SCRIPT = QString("");
+const glm::vec3 DEFAULT_REGISTRATION_POINT = glm::vec3(0.5f, 0.5f, 0.5f); // center
+const glm::vec3 NO_ANGULAR_VELOCITY = glm::vec3(0.0f);
+const glm::vec3 DEFAULT_ANGULAR_VELOCITY = NO_ANGULAR_VELOCITY;
+const float DEFAULT_ANGULAR_DAMPING = 0.39347f;  // approx timescale = 2.0 sec (see damping timescale formula in header)
+const bool DEFAULT_VISIBLE = true;
+const bool DEFAULT_IGNORE_FOR_COLLISIONS = false;
+const bool DEFAULT_COLLISIONS_WILL_MOVE = false;
+const bool DEFAULT_LOCKED = false;
+const QString DEFAULT_USER_DATA = QString("");
+
 /// EntityItem class this is the base class for all entity types. It handles the basic properties and functionality available
 /// to all other entity types. In particular: postion, size, rotation, age, lifetime, velocity, gravity. You can not instantiate
 /// one directly, instead you must only construct one of it's derived classes with additional features.
 class EntityItem  {
+    friend class EntityTreeElement;
 
 public:
     enum EntityDirtyFlags {
@@ -148,7 +174,6 @@ public:
     glm::vec3 getCenter() const; /// calculates center of the entity in domain scale units (0.0 - 1.0)
     glm::vec3 getCenterInMeters() const { return getCenter() * (float) TREE_SCALE; }
 
-    static const glm::vec3 DEFAULT_DIMENSIONS;
     const glm::vec3& getDimensions() const { return _dimensions; } /// get dimensions in domain scale units (0.0 - 1.0)
     glm::vec3 getDimensionsInMeters() const { return _dimensions * (float) TREE_SCALE; } /// get dimensions in meters
     float getDistanceToBottomOfEntity() const; /// get the distance from the position of the entity to its "bottom" in y axis
@@ -160,34 +185,24 @@ public:
     /// 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); }
 
-    static const glm::quat DEFAULT_ROTATION;
     const glm::quat& getRotation() const { return _rotation; }
     void setRotation(const glm::quat& rotation) { _rotation = rotation; recalculateCollisionShape(); }
 
-    static const float DEFAULT_GLOW_LEVEL;
     float getGlowLevel() const { return _glowLevel; }
     void setGlowLevel(float glowLevel) { _glowLevel = glowLevel; }
 
-    static const float DEFAULT_LOCAL_RENDER_ALPHA;
     float getLocalRenderAlpha() const { return _localRenderAlpha; }
     void setLocalRenderAlpha(float localRenderAlpha) { _localRenderAlpha = localRenderAlpha; }
 
-    static const float DEFAULT_MASS;
     float getMass() const { return _mass; }
     void setMass(float value) { _mass = value; }
 
-    static const glm::vec3 DEFAULT_VELOCITY;
-    static const glm::vec3 NO_VELOCITY;
-    static const float EPSILON_VELOCITY_LENGTH;
     const glm::vec3& getVelocity() const { return _velocity; } /// velocity in domain scale units (0.0-1.0) per second
     glm::vec3 getVelocityInMeters() const { return _velocity * (float) TREE_SCALE; } /// get velocity in meters
     void setVelocity(const glm::vec3& value) { _velocity = value; } /// velocity in domain scale units (0.0-1.0) per second
     void setVelocityInMeters(const glm::vec3& value) { _velocity = value / (float) TREE_SCALE; } /// velocity in meters
     bool hasVelocity() const { return _velocity != NO_VELOCITY; }
 
-    static const glm::vec3 DEFAULT_GRAVITY;
-    static const glm::vec3 REGULAR_GRAVITY;
-    static const glm::vec3 NO_GRAVITY;
     const glm::vec3& getGravity() const { return _gravity; } /// gravity in domain scale units (0.0-1.0) per second squared
     glm::vec3 getGravityInMeters() const { return _gravity * (float) TREE_SCALE; } /// get gravity in meters
     void setGravity(const glm::vec3& value) { _gravity = value; } /// gravity in domain scale units (0.0-1.0) per second squared
@@ -197,13 +212,10 @@ public:
     // TODO: this should eventually be updated to support resting on collisions with other surfaces
     bool isRestingOnSurface() const;
 
-    static const float DEFAULT_DAMPING;
     float getDamping() const { return _damping; }
     void setDamping(float value) { _damping = value; }
 
     // lifetime related properties.
-    static const float IMMORTAL; /// special lifetime which means the entity lives for ever. default lifetime
-    static const float DEFAULT_LIFETIME;
     float getLifetime() const { return _lifetime; } /// get the lifetime in seconds for the entity
     void setLifetime(float value) { _lifetime = value; } /// set the lifetime in seconds for the entity
 
@@ -224,46 +236,36 @@ public:
     AACube getMinimumAACube() const;
     AABox getAABox() const; /// axis aligned bounding box in domain scale units (0.0 - 1.0)
 
-    static const QString DEFAULT_SCRIPT;
     const QString& getScript() const { return _script; }
     void setScript(const QString& value) { _script = value; }
 
-    static const glm::vec3 DEFAULT_REGISTRATION_POINT;
     const glm::vec3& getRegistrationPoint() const { return _registrationPoint; } /// registration point as ratio of entity
 
     /// registration point as ratio of entity
     void setRegistrationPoint(const glm::vec3& value) 
             { _registrationPoint = glm::clamp(value, 0.0f, 1.0f); recalculateCollisionShape(); }
 
-    static const glm::vec3 NO_ANGULAR_VELOCITY;
-    static const glm::vec3 DEFAULT_ANGULAR_VELOCITY;
     const glm::vec3& getAngularVelocity() const { return _angularVelocity; }
     void setAngularVelocity(const glm::vec3& value) { _angularVelocity = value; }
     bool hasAngularVelocity() const { return _angularVelocity != NO_ANGULAR_VELOCITY; }
 
-    static const float DEFAULT_ANGULAR_DAMPING;
     float getAngularDamping() const { return _angularDamping; }
     void setAngularDamping(float value) { _angularDamping = value; }
 
-    static const bool DEFAULT_VISIBLE;
     bool getVisible() const { return _visible; }
     void setVisible(bool value) { _visible = value; }
     bool isVisible() const { return _visible; }
     bool isInvisible() const { return !_visible; }
 
-    static const bool DEFAULT_IGNORE_FOR_COLLISIONS;
     bool getIgnoreForCollisions() const { return _ignoreForCollisions; }
     void setIgnoreForCollisions(bool value) { _ignoreForCollisions = value; }
 
-    static const bool DEFAULT_COLLISIONS_WILL_MOVE;
     bool getCollisionsWillMove() const { return _collisionsWillMove; }
     void setCollisionsWillMove(bool value) { _collisionsWillMove = value; }
 
-    static const bool DEFAULT_LOCKED;
     bool getLocked() const { return _locked; }
     void setLocked(bool value) { _locked = value; }
     
-    static const QString DEFAULT_USER_DATA;
     const QString& getUserData() const { return _userData; }
     void setUserData(const QString& value) { _userData = value; }
     
@@ -301,6 +303,7 @@ public:
     void* getPhysicsInfo() const { return _physicsInfo; }
     void setPhysicsInfo(void* data) { _physicsInfo = data; }
     
+    EntityTreeElement* getElement() const { return _element; }
 protected:
 
     virtual void initFromEntityItemID(const EntityItemID& entityItemID); // maybe useful to allow subclasses to init
@@ -362,6 +365,8 @@ protected:
 
     // DirtyFlags are set whenever a property changes that the EntitySimulation needs to know about.
     uint32_t _dirtyFlags;   // things that have changed from EXTERNAL changes (via script or packet) but NOT from simulation
+
+    EntityTreeElement* _element;    // back pointer to containing Element
 };
 
 

libraries/entities/src/EntityItemProperties.cpp

@@ -24,27 +24,27 @@
 
 EntityItemProperties::EntityItemProperties() :
 
-    CONSTRUCT_PROPERTY(visible, EntityItem::DEFAULT_VISIBLE),
+    CONSTRUCT_PROPERTY(visible, DEFAULT_VISIBLE),
     CONSTRUCT_PROPERTY(position, 0),
-    CONSTRUCT_PROPERTY(dimensions, EntityItem::DEFAULT_DIMENSIONS),
+    CONSTRUCT_PROPERTY(dimensions, DEFAULT_DIMENSIONS),
-    CONSTRUCT_PROPERTY(rotation, EntityItem::DEFAULT_ROTATION),
+    CONSTRUCT_PROPERTY(rotation, DEFAULT_ROTATION),
-    CONSTRUCT_PROPERTY(mass, EntityItem::DEFAULT_MASS),
+    CONSTRUCT_PROPERTY(mass, DEFAULT_MASS),
-    CONSTRUCT_PROPERTY(velocity, EntityItem::DEFAULT_VELOCITY),
+    CONSTRUCT_PROPERTY(velocity, DEFAULT_VELOCITY),
-    CONSTRUCT_PROPERTY(gravity, EntityItem::DEFAULT_GRAVITY),
+    CONSTRUCT_PROPERTY(gravity, DEFAULT_GRAVITY),
-    CONSTRUCT_PROPERTY(damping, EntityItem::DEFAULT_DAMPING),
+    CONSTRUCT_PROPERTY(damping, DEFAULT_DAMPING),
-    CONSTRUCT_PROPERTY(lifetime, EntityItem::DEFAULT_LIFETIME),
+    CONSTRUCT_PROPERTY(lifetime, DEFAULT_LIFETIME),
-    CONSTRUCT_PROPERTY(script, EntityItem::DEFAULT_SCRIPT),
+    CONSTRUCT_PROPERTY(script, DEFAULT_SCRIPT),
     CONSTRUCT_PROPERTY(color, ),
     CONSTRUCT_PROPERTY(modelURL, ""),
     CONSTRUCT_PROPERTY(animationURL, ""),
     CONSTRUCT_PROPERTY(animationFPS, ModelEntityItem::DEFAULT_ANIMATION_FPS),
     CONSTRUCT_PROPERTY(animationFrameIndex, ModelEntityItem::DEFAULT_ANIMATION_FRAME_INDEX),
     CONSTRUCT_PROPERTY(animationIsPlaying, ModelEntityItem::DEFAULT_ANIMATION_IS_PLAYING),
-    CONSTRUCT_PROPERTY(registrationPoint, EntityItem::DEFAULT_REGISTRATION_POINT),
+    CONSTRUCT_PROPERTY(registrationPoint, DEFAULT_REGISTRATION_POINT),
-    CONSTRUCT_PROPERTY(angularVelocity, EntityItem::DEFAULT_ANGULAR_VELOCITY),
+    CONSTRUCT_PROPERTY(angularVelocity, DEFAULT_ANGULAR_VELOCITY),
-    CONSTRUCT_PROPERTY(angularDamping, EntityItem::DEFAULT_ANGULAR_DAMPING),
+    CONSTRUCT_PROPERTY(angularDamping, DEFAULT_ANGULAR_DAMPING),
-    CONSTRUCT_PROPERTY(ignoreForCollisions, EntityItem::DEFAULT_IGNORE_FOR_COLLISIONS),
+    CONSTRUCT_PROPERTY(ignoreForCollisions, DEFAULT_IGNORE_FOR_COLLISIONS),
-    CONSTRUCT_PROPERTY(collisionsWillMove, EntityItem::DEFAULT_COLLISIONS_WILL_MOVE),
+    CONSTRUCT_PROPERTY(collisionsWillMove, DEFAULT_COLLISIONS_WILL_MOVE),
     CONSTRUCT_PROPERTY(isSpotlight, false),
     CONSTRUCT_PROPERTY(diffuseColor, ),
     CONSTRUCT_PROPERTY(ambientColor, ),
@@ -57,7 +57,7 @@ EntityItemProperties::EntityItemProperties() :
     CONSTRUCT_PROPERTY(locked, false),
     CONSTRUCT_PROPERTY(textures, ""),
     CONSTRUCT_PROPERTY(animationSettings, ""),
-    CONSTRUCT_PROPERTY(userData, EntityItem::DEFAULT_USER_DATA),
+    CONSTRUCT_PROPERTY(userData, DEFAULT_USER_DATA),
     CONSTRUCT_PROPERTY(text, TextEntityItem::DEFAULT_TEXT),
     CONSTRUCT_PROPERTY(lineHeight, TextEntityItem::DEFAULT_LINE_HEIGHT),
     CONSTRUCT_PROPERTY(textColor, TextEntityItem::DEFAULT_TEXT_COLOR),

libraries/entities/src/EntityTreeElement.cpp

@@ -682,6 +682,7 @@ void EntityTreeElement::cleanupEntities() {
     uint16_t numberOfEntities = _entityItems->size();
     for (uint16_t i = 0; i < numberOfEntities; i++) {
         EntityItem* entity = (*_entityItems)[i];
+        entity->_element = NULL;
         delete entity;
     }
     _entityItems->clear();
@@ -693,6 +694,7 @@ bool EntityTreeElement::removeEntityWithEntityItemID(const EntityItemID& id) {
     for (uint16_t i = 0; i < numberOfEntities; i++) {
         if ((*_entityItems)[i]->getEntityItemID() == id) {
             foundEntity = true;
+            (*_entityItems)[i]->_element = NULL;
             _entityItems->removeAt(i);
             break;
         }
@@ -701,7 +703,13 @@ bool EntityTreeElement::removeEntityWithEntityItemID(const EntityItemID& id) {
 }
 
 bool EntityTreeElement::removeEntityItem(EntityItem* entity) {
-    return _entityItems->removeAll(entity) > 0;
+    int numEntries = _entityItems->removeAll(entity);
+    if (numEntries > 0) {
+        assert(entity->_element == this);
+        entity->_element = NULL;
+        return true;
+    }
+    return false;
 }
 
 
@@ -808,7 +816,10 @@ int EntityTreeElement::readElementDataFromBuffer(const unsigned char* data, int
 }
 
 void EntityTreeElement::addEntityItem(EntityItem* entity) {
+    assert(entity);
+    assert(entity->_element == NULL);
     _entityItems->push_back(entity);
+    entity->_element = this;
 }
 
 // will average a "common reduced LOD view" from the the child elements...

libraries/entities/src/MovingEntitiesOperator.cpp

@@ -179,7 +179,7 @@ bool MovingEntitiesOperator::preRecursion(OctreeElement* element) {
 
             // If this is one of the old elements we're looking for, then ask it to remove the old entity
             if (!details.oldFound && entityTreeElement == details.oldContainingElement) {
-                entityTreeElement->removeEntityItem(details.entity);
+                // DO NOT remove the entity here.  It will be removed when added to the destination element.
                 _foundOldCount++;
                 //details.oldFound = true; // TODO: would be nice to add this optimization
                 if (_wantDebug) {
@@ -193,8 +193,15 @@ bool MovingEntitiesOperator::preRecursion(OctreeElement* element) {
             // If this element is the best fit for the new bounds of this entity then add the entity to the element
             if (!details.newFound && entityTreeElement->bestFitBounds(details.newCube)) {
                 EntityItemID entityItemID = details.entity->getEntityItemID();
-                entityTreeElement->addEntityItem(details.entity);
+                // remove from the old before adding
-                _tree->setContainingElement(entityItemID, entityTreeElement);
+                EntityTreeElement* oldElement = details.entity->getElement();
+                if (oldElement != entityTreeElement) {
+                    if (oldElement) {
+                        oldElement->removeEntityItem(details.entity);
+                    }
+                    entityTreeElement->addEntityItem(details.entity);
+                    _tree->setContainingElement(entityItemID, entityTreeElement);
+                }
                 _foundNewCount++;
                 //details.newFound = true; // TODO: would be nice to add this optimization
                 if (_wantDebug) {
@@ -227,7 +234,7 @@ bool MovingEntitiesOperator::postRecursion(OctreeElement* element) {
     
 
 
-    // It's not OK to prune if we have the potential of deleting the original containig element.
+    // It's not OK to prune if we have the potential of deleting the original containing element
     // because if we prune the containing element then new might end up reallocating the same memory later 
     // and that will confuse our logic.
     // 

libraries/entities/src/UpdateEntityOperator.cpp

@@ -231,18 +231,19 @@ bool UpdateEntityOperator::preRecursion(OctreeElement* element) {
                     qDebug() << "    *** REMOVING from ELEMENT ***";
                 }
 
-                entityTreeElement->removeEntityItem(_existingEntity); // NOTE: only removes the entity, doesn't delete it
+                // the entity knows what element it's in, so we remove it from that one
+                // NOTE: we know we haven't yet added it to its new element because _removeOld is true
+                EntityTreeElement* oldElement = _existingEntity->getElement();
+                oldElement->removeEntityItem(_existingEntity);
+                _tree->setContainingElement(_entityItemID, NULL);
 
-                // If we haven't yet found the new location, then we need to 
+                if (oldElement != _containingElement) {
-                // make sure to remove our entity to element map, because for
+                    qDebug() << "WARNING entity moved during UpdateEntityOperator recursion";
-                // now we're not in that map
+                    _containingElement->removeEntityItem(_existingEntity);
-                if (!_foundNew) {
+                }
-                    _tree->setContainingElement(_entityItemID, NULL);
-
-                    if (_wantDebug) {
-                        qDebug() << "    *** REMOVING from MAP ***";
-                    }
 
+                if (_wantDebug) {
+                    qDebug() << "    *** REMOVING from MAP ***";
                 }
             }
             _foundOld = true;
@@ -263,7 +264,6 @@ bool UpdateEntityOperator::preRecursion(OctreeElement* element) {
             qDebug() << "    entityTreeElement->bestFitBounds(_newEntityBox)=" << entityTreeElement->bestFitBounds(_newEntityBox);
         }
 
-
         // If this element is the best fit for the new entity properties, then add/or update it
         if (entityTreeElement->bestFitBounds(_newEntityBox)) {
 
@@ -271,33 +271,14 @@ bool UpdateEntityOperator::preRecursion(OctreeElement* element) {
                 qDebug() << "    *** THIS ELEMENT IS BEST FIT ***";
             }
 
+            EntityTreeElement* oldElement = _existingEntity->getElement();
             // if we are the existing containing element, then we can just do the update of the entity properties
-            if (entityTreeElement == _containingElement) {
+            if (entityTreeElement == oldElement) {
 
                 if (_wantDebug) {
                     qDebug() << "    *** This is the same OLD ELEMENT ***";
                 }
             
-                // TODO: We shouldn't be in a remove old case and also be the new best fit. This indicates that
-                // we have some kind of a logic error in this operator. But, it can handle it properly by setting
-                // the new properties for the entity and moving on. Still going to output a warning that if we
-                // see consistently we will want to address this.
-                if (_removeOld) {
-                    qDebug() << "UNEXPECTED - UpdateEntityOperator - "
-                                "we thought we needed to removeOld, but the old entity is our best fit.";
-                    _removeOld = false;
-                    
-                    // if we thought we were supposed to remove the old item, and we already did, then we need
-                    // to repair this case.
-                    if (_foundOld) {
-                        if (_wantDebug) {
-                            qDebug() << "    *** REPAIRING PREVIOUS REMOVAL from ELEMENT and MAP ***";
-                        }
-                        entityTreeElement->addEntityItem(_existingEntity);
-                        _tree->setContainingElement(_entityItemID, entityTreeElement);
-                    }
-                }
-
                 // set the entity properties and mark our element as changed.
                 _existingEntity->setProperties(_properties);
                 if (_wantDebug) {
@@ -305,14 +286,22 @@ bool UpdateEntityOperator::preRecursion(OctreeElement* element) {
                 }
             } else {
                 // otherwise, this is an add case.
+                if (oldElement) {
+                    oldElement->removeEntityItem(_existingEntity);
+                    if (oldElement != _containingElement) {
+                        qDebug() << "WARNING entity moved during UpdateEntityOperator recursion";
+                    }
+                }
                 entityTreeElement->addEntityItem(_existingEntity);
-                _existingEntity->setProperties(_properties); // still need to update the properties!
                 _tree->setContainingElement(_entityItemID, entityTreeElement);
+
+                _existingEntity->setProperties(_properties); // still need to update the properties!
                 if (_wantDebug) {
                     qDebug() << "    *** ADDING ENTITY to ELEMENT and MAP and SETTING PROPERTIES ***";
                 }
             }
-            _foundNew = true; // we found the new item!
+            _foundNew = true; // we found the new element
+            _removeOld = false; // and it has already been removed from the old
         } else {
             keepSearching = true;
         }

libraries/physics/src/ObjectMotionState.cpp

@@ -154,8 +154,6 @@ bool ObjectMotionState::shouldSendUpdate(uint32_t simulationFrame, float subStep
     // NOTE: math in done the simulation-frame, which is NOT necessarily the same as the world-frame 
     // due to _worldOffset.
 
-    // TODO: Andrew to reconcile Bullet and legacy damping coefficients.
-
     // compute position error
     if (glm::length2(_sentVelocity) > 0.0f) {
         _sentVelocity += _sentAcceleration * dt;

libraries/physics/src/ObjectMotionState.h

@@ -111,7 +111,7 @@ protected:
     glm::vec3 _sentPosition;    // in simulation-frame (not world-frame)
     glm::quat _sentRotation;;
     glm::vec3 _sentVelocity;
-    glm::vec3 _sentAngularVelocity;
+    glm::vec3 _sentAngularVelocity; // radians per second
     glm::vec3 _sentAcceleration;
 };