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

CMakeLists.txt

@@ -46,6 +46,9 @@ if (WIN32)
   # Caveats: http://stackoverflow.com/questions/2288728/drawbacks-of-using-largeaddressaware-for-32-bit-windows-executables
   # TODO: Remove when building 64-bit.
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE")
+  # always produce symbols as PDB files
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Zi")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /DEBUG /OPT:REF /OPT:ICF")
 else ()
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -fno-strict-aliasing -Wno-unused-parameter")
   if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)

assignment-client/src/Agent.cpp

@@ -364,10 +364,14 @@ void Agent::processAgentAvatarAndAudio(float deltaTime) {
 }
 
 void Agent::aboutToFinish() {
-    _scriptEngine->stop();
+    if (_scriptEngine) {
+        _scriptEngine->stop();
+    }
 
-    _pingTimer->stop();
+    if (_pingTimer) {
-    delete _pingTimer;
+        _pingTimer->stop();
+        delete _pingTimer;
+    }
 
     // our entity tree is going to go away so tell that to the EntityScriptingInterface
     DependencyManager::get<EntityScriptingInterface>()->setEntityTree(NULL);

assignment-client/src/octree/OctreeInboundPacketProcessor.cpp

@@ -238,7 +238,6 @@ int OctreeInboundPacketProcessor::sendNackPackets() {
         return 0;
     }
 
-    auto nackPacketList = NLPacketList::create(_myServer->getMyEditNackType());
     auto nodeList = DependencyManager::get<NodeList>();
     int packetsSent = 0;
 
@@ -272,18 +271,19 @@ int OctreeInboundPacketProcessor::sendNackPackets() {
 
         auto it = missingSequenceNumbers.constBegin();
 
-        while (it != missingSequenceNumbers.constEnd()) {
+        if (it != missingSequenceNumbers.constEnd()) {
-            unsigned short int sequenceNumber = *it;
+            auto nackPacketList = NLPacketList::create(_myServer->getMyEditNackType());
-            nackPacketList->writePrimitive(sequenceNumber);
+
-            ++it;
+            while (it != missingSequenceNumbers.constEnd()) {
-        }
+                unsigned short int sequenceNumber = *it;
-        
+                nackPacketList->writePrimitive(sequenceNumber);
-        
+                ++it;
-        if (nackPacketList->getNumPackets()) {
+            }
+
             qDebug() << "NACK Sent back to editor/client... destinationNode=" << nodeUUID;
-            
+
             packetsSent += nackPacketList->getNumPackets();
-            
+
             // send the list of nack packets
             nodeList->sendPacketList(std::move(nackPacketList), *destinationNode);
         }

cmake/macros/CopyDllsBesideWindowsExecutable.cmake

@@ -37,7 +37,7 @@ macro(COPY_DLLS_BESIDE_WINDOWS_EXECUTABLE)
     add_custom_command(
       TARGET ${TARGET_NAME}
       POST_BUILD
-      COMMAND CMD /C "SET PATH=%PATH%;${QT_DIR}/bin && ${WINDEPLOYQT_COMMAND} $<TARGET_FILE:${TARGET_NAME}>"
+      COMMAND CMD /C "SET PATH=%PATH%;${QT_DIR}/bin && ${WINDEPLOYQT_COMMAND} $<$<OR:$<CONFIG:Release>,$<CONFIG:MinSizeRel>,$<CONFIG:RelWithDebInfo>>:--release> $<TARGET_FILE:${TARGET_NAME}>"
     )
   endif ()
 endmacro()

examples/actionInspector.js

@@ -0,0 +1,146 @@
+//
+//  actionInspector.js
+//  examples
+//
+//  Created by Seth Alves on 2015-9-30.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+Script.include("libraries/utils.js");
+
+
+var INSPECT_RADIUS = 10;
+var overlays = {};
+
+
+var toType = function(obj) {
+  return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
+}
+
+
+function actionArgumentsToString(actionArguments) {
+    var result = "type: " + actionArguments["type"] + "\n";
+    for (var argumentName in actionArguments) {
+        if (actionArguments.hasOwnProperty(argumentName)) {
+            if (argumentName == "type") {
+                continue;
+            }
+            var arg = actionArguments[argumentName];
+            var argType = toType(arg);
+            var argString = arg;
+            if (argType == "object") {
+                if (Object.keys(arg).length == 3) {
+                    argString = vec3toStr(arg, 1);
+                }
+            } else if (argType == "number") {
+                argString = arg.toFixed(2);
+            }
+            result += argumentName + ": "
+                // + toType(arg) + " -- "
+                + argString + "\n";
+        }
+    }
+
+    return result;
+}
+
+
+function updateOverlay(entityID, actionText) {
+    var properties = Entities.getEntityProperties(entityID, ["position", "dimensions"]);
+    var position = Vec3.sum(properties.position, {x:0, y:properties.dimensions.y, z:0});
+    // print("position: " + vec3toStr(position) + " " + actionText);
+    if (entityID in overlays) {
+        var overlay = overlays[entityID];
+        Overlays.editOverlay(overlay, {
+            text: actionText,
+            position: position
+        });
+    } else {
+        var lines = actionText.split(/\r\n|\r|\n/);
+
+        var maxLineLength = lines[0].length;
+        for (var i = 1; i < lines.length; i++) {
+            if (lines[i].length > maxLineLength) {
+                maxLineLength = lines[i].length;
+            }
+        }
+
+        var textWidth = maxLineLength * 0.034; // XXX how to know this?
+        var textHeight = .5;
+        var numberOfLines = lines.length;
+        var textMargin = 0.05;
+        var lineHeight = (textHeight - (2 * textMargin)) / numberOfLines;
+
+        overlays[entityID] = Overlays.addOverlay("text3d", {
+            position: position,
+            dimensions: { x: textWidth, y: textHeight },
+            backgroundColor: { red: 0, green: 0, blue: 0},
+            color: { red: 255, green: 255, blue: 255},
+            topMargin: textMargin,
+            leftMargin: textMargin,
+            bottomMargin: textMargin,
+            rightMargin: textMargin,
+            text: actionText,
+            lineHeight: lineHeight,
+            alpha: 0.9,
+            backgroundAlpha: 0.9,
+            ignoreRayIntersection: true,
+            visible: true,
+            isFacingAvatar: true
+        });
+    }
+}
+
+
+function cleanup() {
+    for (var entityID in overlays) {
+        Overlays.deleteOverlay(overlays[entityID]);
+    }
+}
+
+
+Script.setInterval(function() {
+    var nearbyEntities = Entities.findEntities(MyAvatar.position, INSPECT_RADIUS);
+    for (var entityIndex = 0; entityIndex < nearbyEntities.length; entityIndex++) {
+        var entityID = nearbyEntities[entityIndex];
+        var actionIDs = Entities.getActionIDs(entityID);
+        var actionText = ""
+        for (var actionIndex = 0; actionIndex < actionIDs.length; actionIndex++) {
+            var actionID = actionIDs[actionIndex];
+            var actionArguments = Entities.getActionArguments(entityID, actionID);
+            var actionArgumentText = actionArgumentsToString(actionArguments);
+            if (actionArgumentText != "") {
+                actionText += "-----------------\n";
+                actionText += actionArgumentText;
+            }
+        }
+        if (actionText != "") {
+            updateOverlay(entityID, actionText);
+        }
+
+        // if an entity no longer has an action, remove its overlay
+        if (actionIDs.length == 0) {
+            if (entityID in overlays) {
+                Overlays.deleteOverlay(overlays[entityID]);
+                delete overlays[entityID];
+            }
+        }
+    }
+
+
+    // if an entity is too far away, remove its overlay
+    for (var entityID in overlays) {
+        var position = Entities.getEntityProperties(entityID, ["position"]).position;
+        if (Vec3.distance(position, MyAvatar.position) > INSPECT_RADIUS) {
+            Overlays.deleteOverlay(overlays[entityID]);
+            delete overlays[entityID];
+        }
+    }
+
+}, 100);
+
+
+Script.scriptEnding.connect(cleanup);

examples/controllers/handControllerGrab.js

@@ -91,6 +91,27 @@ var currentAvatarCollisionsMenu = initialAvatarCollisionsMenu;
 var noCollisionsCount = 0; // how many hands want collisions disabled?
 
 
+function getTag() {
+    return "grab-" + MyAvatar.sessionUUID;
+}
+
+function entityIsGrabbedByOther(entityID) {
+    var actionIDs = Entities.getActionIDs(entityID);
+    for (var actionIndex = 0; actionIndex < actionIDs.length; actionIndex++) {
+        var actionID = actionIDs[actionIndex];
+        var actionArguments = Entities.getActionArguments(entityID, actionID);
+        var tag = actionArguments["tag"];
+        if (tag == getTag()) {
+            continue;
+        }
+        if (tag.slice(0, 5) == "grab-") {
+            return true;
+        }
+    }
+    return false;
+}
+
+
 function MyController(hand, triggerAction) {
     this.hand = hand;
     if (this.hand === RIGHT_HAND) {
@@ -252,7 +273,8 @@ function MyController(hand, triggerAction) {
         var intersection = Entities.findRayIntersection(pickRay, true);
         if (intersection.intersects &&
             intersection.properties.collisionsWillMove === 1 &&
-            intersection.properties.locked === 0) {
+            intersection.properties.locked === 0 &&
+            !entityIsGrabbedByOther(intersection.entityID)) {
             // the ray is intersecting something we can move.
             var handControllerPosition = Controller.getSpatialControlPosition(this.palm);
             var intersectionDistance = Vec3.distance(handControllerPosition, intersection.intersection);
@@ -320,11 +342,14 @@ function MyController(hand, triggerAction) {
         this.handPreviousPosition = handControllerPosition;
         this.handPreviousRotation = handRotation;
 
+        this.actionID = NULL_ACTION_ID;
         this.actionID = Entities.addAction("spring", this.grabbedEntity, {
             targetPosition: this.currentObjectPosition,
             linearTimeScale: DISTANCE_HOLDING_ACTION_TIMEFRAME,
             targetRotation: this.currentObjectRotation,
-            angularTimeScale: DISTANCE_HOLDING_ACTION_TIMEFRAME
+            angularTimeScale: DISTANCE_HOLDING_ACTION_TIMEFRAME,
+            tag: getTag(),
+            lifetime: 5
         });
         if (this.actionID === NULL_ACTION_ID) {
             this.actionID = null;
@@ -390,11 +415,11 @@ function MyController(hand, triggerAction) {
         var handMovementFromTurning = Vec3.subtract(Quat.multiply(avatarDeltaOrientation, handToAvatar), handToAvatar); 
         var objectMovementFromTurning = Vec3.subtract(Quat.multiply(avatarDeltaOrientation, objectToAvatar), objectToAvatar); 
         this.currentAvatarOrientation = currentOrientation;
-      
+
         // how far did hand move this timestep?
         var handMoved = Vec3.subtract(handControllerPosition, this.handPreviousPosition);
         this.handPreviousPosition = handControllerPosition;
-        
+
         //  magnify the hand movement but not the change from avatar movement & rotation
         handMoved = Vec3.subtract(handMoved, avatarDeltaPosition);
         handMoved = Vec3.subtract(handMoved, handMovementFromTurning);
@@ -424,7 +449,8 @@ function MyController(hand, triggerAction) {
             targetPosition: this.currentObjectPosition,
             linearTimeScale: DISTANCE_HOLDING_ACTION_TIMEFRAME,
             targetRotation: this.currentObjectRotation,
-            angularTimeScale: DISTANCE_HOLDING_ACTION_TIMEFRAME
+            angularTimeScale: DISTANCE_HOLDING_ACTION_TIMEFRAME,
+            lifetime: 5
         });
     };
 
@@ -436,7 +462,7 @@ function MyController(hand, triggerAction) {
         if (this.triggerSmoothedReleased()) {
             // HACK -- until we have collision groups, don't allow held object to collide with avatar
             this.revertAvatarCollisions();
-            
+
             this.state = STATE_RELEASE;
             return;
         }
@@ -457,12 +483,17 @@ function MyController(hand, triggerAction) {
         var offset = Vec3.subtract(currentObjectPosition, handPosition);
         var offsetPosition = Vec3.multiplyQbyV(Quat.inverse(Quat.multiply(handRotation, offsetRotation)), offset);
 
-        this.actionID = Entities.addAction("hold", this.grabbedEntity, {
+        this.actionID = NULL_ACTION_ID;
-            hand: this.hand === RIGHT_HAND ? "right" : "left",
+        if (!entityIsGrabbedByOther(this.grabbedEntity)) {
-            timeScale: NEAR_GRABBING_ACTION_TIMEFRAME,
+            this.actionID = Entities.addAction("hold", this.grabbedEntity, {
-            relativePosition: offsetPosition,
+                hand: this.hand === RIGHT_HAND ? "right" : "left",
-            relativeRotation: offsetRotation
+                timeScale: NEAR_GRABBING_ACTION_TIMEFRAME,
-        });
+                relativePosition: offsetPosition,
+                relativeRotation: offsetRotation,
+                tag: getTag(),
+                lifetime: 5
+            });
+        }
         if (this.actionID === NULL_ACTION_ID) {
             this.actionID = null;
         } else {
@@ -485,7 +516,7 @@ function MyController(hand, triggerAction) {
         if (this.triggerSmoothedReleased()) {
             // HACK -- until we have collision groups, don't allow held object to collide with avatar
             this.revertAvatarCollisions();
-            
+
             this.state = STATE_RELEASE;
             return;
         }
@@ -495,7 +526,7 @@ function MyController(hand, triggerAction) {
         // object's actual held offset is an idea intended to make it easier to throw things:
         // Because we might catch something or transfer it between hands without a good idea 
         // of it's actual offset, let's try imparting a velocity which is at a fixed radius
-        // from the palm.  
+        // from the palm.
 
         var handControllerPosition = Controller.getSpatialControlPosition(this.tip);
         var now = Date.now();
@@ -507,6 +538,8 @@ function MyController(hand, triggerAction) {
         this.currentHandControllerTipPosition = handControllerPosition;
         this.currentObjectTime = now;
         Entities.callEntityMethod(this.grabbedEntity, "continueNearGrab");
+
+        Entities.updateAction(this.grabbedEntity, this.actionID, {lifetime: 5});
     };
 
     this.nearGrabbingNonColliding = function() {

examples/grab.js

@@ -14,6 +14,25 @@ var MAX_SOLID_ANGLE = 0.01; // objects that appear smaller than this can't be gr
 var ZERO_VEC3 = {x: 0, y: 0, z: 0};
 var IDENTITY_QUAT = {x: 0, y: 0, z: 0, w: 0};
 
+function getTag() {
+    return "grab-" + MyAvatar.sessionUUID;
+}
+
+function entityIsGrabbedByOther(entityID) {
+    var actionIDs = Entities.getActionIDs(entityID);
+    for (var actionIndex = 0; actionIndex < actionIDs.length; actionIndex++) {
+        var actionID = actionIDs[actionIndex];
+        var actionArguments = Entities.getActionArguments(entityID, actionID);
+        var tag = actionArguments["tag"];
+        if (tag == getTag()) {
+            continue;
+        }
+        if (tag.slice(0, 5) == "grab-") {
+            return true;
+        }
+    }
+    return false;
+}
 
 // helper function
 function mouseIntersectionWithPlane(pointOnPlane, planeNormal, event, maxDistance) {
@@ -288,7 +307,7 @@ Grabber.prototype.moveEvent = function(event) {
     }
     this.currentPosition = entityProperties.position;
 
-    var actionArgs = {};
+    var actionArgs = {tag: getTag(), lifetime: 5};
 
     if (this.mode === "rotate") {
         var drag = mouse.getDrag();
@@ -303,7 +322,7 @@ Grabber.prototype.moveEvent = function(event) {
         // var qZero = entityProperties.rotation;
         //var qZero = this.lastRotation;
         this.lastRotation = Quat.multiply(deltaQ, this.lastRotation);
-        actionArgs = {targetRotation: this.lastRotation, angularTimeScale: 0.1};
+        actionArgs = {targetRotation: this.lastRotation, angularTimeScale: 0.1, tag: getTag(), lifetime: 5};
     } else {
         var newPointOnPlane;
         if (this.mode === "verticalCylinder") {
@@ -327,13 +346,15 @@ Grabber.prototype.moveEvent = function(event) {
             }
         }
         this.targetPosition = Vec3.subtract(newPointOnPlane, this.offset);
-        actionArgs = {targetPosition: this.targetPosition, linearTimeScale: 0.1};
+        actionArgs = {targetPosition: this.targetPosition, linearTimeScale: 0.1, tag: getTag(), lifetime: 5};
 
         beacon.updatePosition(this.targetPosition);
     }
 
     if (!this.actionID) {
-        this.actionID = Entities.addAction("spring", this.entityID, actionArgs);
+        if (!entityIsGrabbedByOther(this.entityID)) {
+            this.actionID = Entities.addAction("spring", this.entityID, actionArgs);
+        }
     } else {
         Entities.updateAction(this.entityID, this.actionID, actionArgs);
     }

interface/src/InterfaceActionFactory.cpp

@@ -43,6 +43,9 @@ EntityActionPointer InterfaceActionFactory::factory(EntityActionType type,
     if (action) {
         bool ok = action->updateArguments(arguments);
         if (ok) {
+            if (action->lifetimeIsOver()) {
+                return nullptr;
+            }
             return action;
         }
     }
@@ -63,5 +66,9 @@ EntityActionPointer InterfaceActionFactory::factoryBA(EntityItemPointer ownerEnt
     if (action) {
         action->deserialize(data);
     }
+    if (action->lifetimeIsOver()) {
+        return nullptr;
+    }
+
     return action;
 }

interface/src/avatar/AvatarActionHold.cpp

@@ -84,6 +84,9 @@ void AvatarActionHold::updateActionWorker(float deltaTimeStep) {
 
 
 bool AvatarActionHold::updateArguments(QVariantMap arguments) {
+    if (!ObjectAction::updateArguments(arguments)) {
+        return false;
+    }
     bool ok = true;
     glm::vec3 relativePosition =
         EntityActionInterface::extractVec3Argument("hold", arguments, "relativePosition", ok, false);
@@ -134,7 +137,7 @@ bool AvatarActionHold::updateArguments(QVariantMap arguments) {
 
 
 QVariantMap AvatarActionHold::getArguments() {
-    QVariantMap arguments;
+    QVariantMap arguments = ObjectAction::getArguments();
     withReadLock([&]{
         if (!_mine) {
             arguments = ObjectActionSpring::getArguments();

interface/src/ui/ApplicationCompositor.cpp

@@ -313,18 +313,21 @@ void ApplicationCompositor::displayOverlayTextureHmd(RenderArgs* renderArgs, int
         glm::mat4 overlayXfm;
         _modelTransform.getMatrix(overlayXfm);
 
-        MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
+        // Only render the hand pointers if the HandMouseInput is enabled
-        for (int i = 0; i < (int)myAvatar->getHand()->getNumPalms(); i++) {
+        if (Menu::getInstance()->isOptionChecked(MenuOption::HandMouseInput)) {
-            PalmData& palm = myAvatar->getHand()->getPalms()[i];
+            MyAvatar* myAvatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
-            if (palm.isActive()) {
+            for (int i = 0; i < (int)myAvatar->getHand()->getNumPalms(); i++) {
-                glm::vec2 polar = getPolarCoordinates(palm);
+                PalmData& palm = myAvatar->getHand()->getPalms()[i];
-                // Convert to quaternion
+                if (palm.isActive()) {
-                mat4 pointerXfm = glm::mat4_cast(quat(vec3(polar.y, -polar.x, 0.0f))) * glm::translate(mat4(), vec3(0, 0, -1));
+                    glm::vec2 polar = getPolarCoordinates(palm);
-                mat4 reticleXfm = overlayXfm * pointerXfm;
+                    // Convert to quaternion
-                reticleXfm = glm::scale(reticleXfm, reticleScale);
+                    mat4 pointerXfm = glm::mat4_cast(quat(vec3(polar.y, -polar.x, 0.0f))) * glm::translate(mat4(), vec3(0, 0, -1));
-                batch.setModelTransform(reticleXfm);
+                    mat4 reticleXfm = overlayXfm * pointerXfm;
-                // Render reticle at location
+                    reticleXfm = glm::scale(reticleXfm, reticleScale);
-                geometryCache->renderUnitQuad(batch, glm::vec4(1), _reticleQuad);
+                    batch.setModelTransform(reticleXfm);
+                    // Render reticle at location
+                    geometryCache->renderUnitQuad(batch, glm::vec4(1), _reticleQuad);
+                }
             }
         }
 

libraries/avatars/src/AvatarData.cpp

@@ -966,7 +966,8 @@ bool AvatarData::hasIdentityChangedAfterParsing(NLPacket& packet) {
 QByteArray AvatarData::identityByteArray() {
     QByteArray identityData;
     QDataStream identityStream(&identityData, QIODevice::Append);
-    const QUrl& urlToSend = (_skeletonModelURL == AvatarData::defaultFullAvatarModelUrl()) ? QUrl("") : _skeletonModelURL;
+    QUrl emptyURL("");
+    const QUrl& urlToSend = (_skeletonModelURL == AvatarData::defaultFullAvatarModelUrl()) ? emptyURL : _skeletonModelURL;
 
     identityStream << QUuid() << _faceModelURL << urlToSend << _attachmentData << _displayName;
 

libraries/entities/src/EntityActionInterface.h

@@ -46,6 +46,8 @@ public:
     static EntityActionType actionTypeFromString(QString actionTypeString);
     static QString actionTypeToString(EntityActionType actionType);
 
+    virtual bool lifetimeIsOver() { return false; }
+
 protected:
     virtual glm::vec3 getPosition() = 0;
     virtual void setPosition(glm::vec3 position) = 0;

libraries/networking/src/NLPacketList.cpp

@@ -23,7 +23,8 @@ std::unique_ptr<NLPacketList> NLPacketList::create(PacketType packetType, QByteA
 }
 
 std::unique_ptr<NLPacketList> NLPacketList::fromPacketList(std::unique_ptr<PacketList> packetList) {
-    auto nlPacketList = std::unique_ptr<NLPacketList>(new NLPacketList(std::move(*packetList.release())));    nlPacketList->open(ReadOnly);
+    auto nlPacketList = std::unique_ptr<NLPacketList>(new NLPacketList(std::move(*packetList.release())));
+    nlPacketList->open(ReadOnly);
     return nlPacketList;
 }
 

libraries/networking/src/SentPacketHistory.cpp

@@ -35,6 +35,7 @@ void SentPacketHistory::packetSent(uint16_t sequenceNumber, const NLPacket& pack
     }
     _newestSequenceNumber = sequenceNumber;
 
+    QWriteLocker locker(&_packetsLock);
     _sentPackets.insert(NLPacket::createCopy(packet));
 }
 
@@ -48,6 +49,11 @@ const NLPacket* SentPacketHistory::getPacket(uint16_t sequenceNumber) const {
     if (seqDiff < 0) {
         seqDiff += UINT16_RANGE;
     }
-
+    
-    return _sentPackets.get(seqDiff)->get();
+    QReadLocker locker(&_packetsLock);
+    auto packet = _sentPackets.get(seqDiff);
+    if (packet) {
+        return packet->get();
+    }
+    return nullptr;
 }

libraries/networking/src/SentPacketHistory.h

@@ -12,7 +12,9 @@
 #define hifi_SentPacketHistory_h
 
 #include <stdint.h>
-#include <qbytearray.h>
+
+#include <QtCore/QByteArray>
+#include <QtCore/QReadWriteLock>
 
 #include "NLPacket.h"
 #include "RingBufferHistory.h"
@@ -29,6 +31,7 @@ public:
     const NLPacket* getPacket(uint16_t sequenceNumber) const;
 
 private:
+    mutable QReadWriteLock _packetsLock { QReadWriteLock::Recursive };
     RingBufferHistory<std::unique_ptr<NLPacket>> _sentPackets;    // circular buffer
 
     uint16_t _newestSequenceNumber;

libraries/networking/src/udt/CongestionControl.cpp

@@ -161,13 +161,16 @@ void DefaultCC::onLoss(SequenceNumber rangeStart, SequenceNumber rangeEnd) {
         
         _lastDecreaseMaxSeq = _sendCurrSeqNum;
         
-        // avoid synchronous rate decrease across connections using randomization
+        if (_avgNAKNum < 1) {
-        std::random_device rd;
+            _randomDecreaseThreshold = 1;
-        std::mt19937 generator(rd());
+        } else {
-        std::uniform_int_distribution<> distribution(1, _avgNAKNum);
+            // avoid synchronous rate decrease across connections using randomization
-        
+            std::random_device rd;
-        _randomDecreaseThreshold = distribution(generator);
+            std::mt19937 generator(rd());
-        
+            std::uniform_int_distribution<> distribution(1, std::max(1, _avgNAKNum));
+
+            _randomDecreaseThreshold = distribution(generator);
+        }
     } else if ((_decreaseCount++ < MAX_DECREASES_PER_CONGESTION_EPOCH) && ((++_nakCount % _randomDecreaseThreshold) == 0)) {
         // there have been fewer than MAX_DECREASES_PER_CONGESTION_EPOCH AND this NAK matches the random count at which we
         // decided we would decrease the packet send period

libraries/octree/src/OctreeEditPacketSender.cpp

@@ -346,6 +346,7 @@ void OctreeEditPacketSender::processNackPacket(NLPacket& packet, SharedNodePoint
     if (_sentPacketHistories.count(sendingNode->getUUID()) == 0) {
         return;
     }
+    
     const SentPacketHistory& sentPacketHistory = _sentPacketHistories[sendingNode->getUUID()];
 
     // read sequence numbers and queue packets for resend

libraries/physics/src/ObjectAction.cpp

@@ -30,6 +30,18 @@ void ObjectAction::updateAction(btCollisionWorld* collisionWorld, btScalar delta
         dynamicsWorld->removeAction(this);
         return;
     }
+
+    if (_expires > 0) {
+        quint64 now = usecTimestampNow();
+        if (now > _expires) {
+            EntityItemPointer ownerEntity = _ownerEntity.lock();
+            _active = false;
+            if (ownerEntity) {
+                ownerEntity->removeAction(nullptr, getID());
+            }
+        }
+    }
+
     if (!_active) {
         return;
     }
@@ -37,6 +49,40 @@ void ObjectAction::updateAction(btCollisionWorld* collisionWorld, btScalar delta
     updateActionWorker(deltaTimeStep);
 }
 
+bool ObjectAction::updateArguments(QVariantMap arguments) {
+    bool lifetimeSet = true;
+    float lifetime = EntityActionInterface::extractFloatArgument("action", arguments, "lifetime", lifetimeSet, false);
+    if (lifetimeSet) {
+        quint64 now = usecTimestampNow();
+        _expires = now + (quint64)(lifetime * USECS_PER_SECOND);
+    } else {
+        _expires = 0;
+    }
+
+    bool tagSet = true;
+    QString tag = EntityActionInterface::extractStringArgument("action", arguments, "tag", tagSet, false);
+    if (tagSet) {
+        _tag = tag;
+    } else {
+        tag = "";
+    }
+
+    return true;
+}
+
+QVariantMap ObjectAction::getArguments() {
+    QVariantMap arguments;
+    if (_expires == 0) {
+        arguments["lifetime"] = 0.0f;
+    } else {
+        quint64 now = usecTimestampNow();
+        arguments["lifetime"] = (float)(_expires - now) / (float)USECS_PER_SECOND;
+    }
+    arguments["tag"] = _tag;
+    return arguments;
+}
+
+
 void ObjectAction::debugDraw(btIDebugDraw* debugDrawer) {
 }
 
@@ -136,3 +182,14 @@ void ObjectAction::activateBody() {
     }
 }
 
+bool ObjectAction::lifetimeIsOver() {
+    if (_expires == 0) {
+        return false;
+    }
+
+    quint64 now = usecTimestampNow();
+    if (now >= _expires) {
+        return true;
+    }
+    return false;
+}

libraries/physics/src/ObjectAction.h

@@ -33,8 +33,8 @@ public:
     virtual EntityItemWeakPointer getOwnerEntity() const { return _ownerEntity; }
     virtual void setOwnerEntity(const EntityItemPointer ownerEntity) { _ownerEntity = ownerEntity; }
 
-    virtual bool updateArguments(QVariantMap arguments) = 0;
+    virtual bool updateArguments(QVariantMap arguments);
-    virtual QVariantMap getArguments() = 0;
+    virtual QVariantMap getArguments();
 
     // this is called from updateAction and should be overridden by subclasses
     virtual void updateActionWorker(float deltaTimeStep) = 0;
@@ -46,6 +46,8 @@ public:
     virtual QByteArray serialize() const = 0;
     virtual void deserialize(QByteArray serializedArguments) = 0;
 
+    virtual bool lifetimeIsOver();
+
 protected:
 
     virtual btRigidBody* getRigidBody();
@@ -59,11 +61,11 @@ protected:
     virtual void setAngularVelocity(glm::vec3 angularVelocity);
     virtual void activateBody();
 
-private:
-
-protected:
     bool _active;
     EntityItemWeakPointer _ownerEntity;
+
+    quint64 _expires; // in seconds since epoch
+    QString _tag;
 };
 
 #endif // hifi_ObjectAction_h

libraries/physics/src/ObjectActionOffset.cpp

@@ -80,6 +80,9 @@ void ObjectActionOffset::updateActionWorker(btScalar deltaTimeStep) {
 
 
 bool ObjectActionOffset::updateArguments(QVariantMap arguments) {
+    if (!ObjectAction::updateArguments(arguments)) {
+        return false;
+    }
     bool ok = true;
     glm::vec3 pointToOffsetFrom =
         EntityActionInterface::extractVec3Argument("offset action", arguments, "pointToOffsetFrom", ok, true);
@@ -90,7 +93,7 @@ bool ObjectActionOffset::updateArguments(QVariantMap arguments) {
     ok = true;
     float linearTimeScale =
         EntityActionInterface::extractFloatArgument("offset action", arguments, "linearTimeScale", ok, false);
-    if (!ok) { 
+    if (!ok) {
         linearTimeScale = _linearTimeScale;
     }
 
@@ -119,7 +122,7 @@ bool ObjectActionOffset::updateArguments(QVariantMap arguments) {
 }
 
 QVariantMap ObjectActionOffset::getArguments() {
-    QVariantMap arguments;
+    QVariantMap arguments = ObjectAction::getArguments();
     withReadLock([&] {
         arguments["pointToOffsetFrom"] = glmToQMap(_pointToOffsetFrom);
         arguments["linearTimeScale"] = _linearTimeScale;
@@ -140,6 +143,9 @@ QByteArray ObjectActionOffset::serialize() const {
     dataStream << _linearTimeScale;
     dataStream << _positionalTargetSet;
 
+    dataStream << _expires;
+    dataStream << _tag;
+
     return ba;
 }
 
@@ -165,5 +171,8 @@ void ObjectActionOffset::deserialize(QByteArray serializedArguments) {
     dataStream >> _linearTimeScale;
     dataStream >> _positionalTargetSet;
 
+    dataStream >> _expires;
+    dataStream >> _tag;
+
     _active = true;
 }

libraries/physics/src/ObjectActionSpring.cpp

@@ -109,6 +109,9 @@ void ObjectActionSpring::updateActionWorker(btScalar deltaTimeStep) {
 const float MIN_TIMESCALE = 0.1f;
 
 bool ObjectActionSpring::updateArguments(QVariantMap arguments) {
+    if (!ObjectAction::updateArguments(arguments)) {
+        return false;
+    }
     // targets are required, spring-constants are optional
     bool ok = true;
     glm::vec3 positionalTarget =
@@ -155,7 +158,7 @@ bool ObjectActionSpring::updateArguments(QVariantMap arguments) {
 }
 
 QVariantMap ObjectActionSpring::getArguments() {
-    QVariantMap arguments;
+    QVariantMap arguments = ObjectAction::getArguments();
     withReadLock([&] {
         arguments["linearTimeScale"] = _linearTimeScale;
         arguments["targetPosition"] = glmToQMap(_positionalTarget);
@@ -182,6 +185,9 @@ QByteArray ObjectActionSpring::serialize() const {
     dataStream << _angularTimeScale;
     dataStream << _rotationalTargetSet;
 
+    dataStream << _expires;
+    dataStream << _tag;
+
     return serializedActionArguments;
 }
 
@@ -210,5 +216,8 @@ void ObjectActionSpring::deserialize(QByteArray serializedArguments) {
     dataStream >> _angularTimeScale;
     dataStream >> _rotationalTargetSet;
 
+    dataStream >> _expires;
+    dataStream >> _tag;
+
     _active = true;
 }