krisyotam/overte

interface/src/Application.cpp+32−4

     // Check HMD use (may be technically available without being in use)
     bool hasHMD = PluginUtils::isHMDAvailable();
-    bool isUsingHMD = hasHMD && hasHandControllers && _displayPlugin->isHmd();
+    bool isUsingHMD = _displayPlugin->isHmd();
+    bool isUsingHMDAndHandControllers = hasHMD && hasHandControllers && isUsingHMD;
     Setting::Handle<bool> tutorialComplete{ "tutorialComplete", false };
     Setting::Handle<bool> firstRun{ Settings::firstRun, true };
     bool isTutorialComplete = tutorialComplete.get();
-    bool shouldGoToTutorial = isUsingHMD && hasTutorialContent && !isTutorialComplete;
+    bool shouldGoToTutorial = isUsingHMDAndHandControllers && hasTutorialContent && !isTutorialComplete;
-    qCDebug(interfaceapp) << "HMD:" << hasHMD << ", Hand Controllers: " << hasHandControllers << ", Using HMD: " << isUsingHMD;
+    qCDebug(interfaceapp) << "HMD:" << hasHMD << ", Hand Controllers: " << hasHandControllers << ", Using HMD: " << isUsingHMDAndHandControllers;
     qCDebug(interfaceapp) << "Tutorial version:" << contentVersion << ", sufficient:" << hasTutorialContent <<
         ", complete:" << isTutorialComplete << ", should go:" << shouldGoToTutorial;
     const QString TUTORIAL_PATH = "/tutorial_begin";
+    static const QString SENT_TO_TUTORIAL = "tutorial";
+    static const QString SENT_TO_PREVIOUS_LOCATION = "previous_location";
+    static const QString SENT_TO_ENTRY = "entry";
+    static const QString SENT_TO_SANDBOX = "sandbox";
+    QString sentTo;
     if (shouldGoToTutorial) {
         if (sandboxIsRunning) {
             qCDebug(interfaceapp) << "Home sandbox appears to be running, going to Home.";
             DependencyManager::get<AddressManager>()->goToLocalSandbox(TUTORIAL_PATH);
+            sentTo = SENT_TO_TUTORIAL;
         } else {
             qCDebug(interfaceapp) << "Home sandbox does not appear to be running, going to Entry.";
             if (firstRun.get()) {
             }
             if (addressLookupString.isEmpty()) {
                 DependencyManager::get<AddressManager>()->goToEntry();
+                sentTo = SENT_TO_ENTRY;
             } else {
                 DependencyManager::get<AddressManager>()->loadSettings(addressLookupString);
+                sentTo = SENT_TO_PREVIOUS_LOCATION;
             }
         }
     } else {
         // If this is a first run we short-circuit the address passed in
         if (isFirstRun) {
-            if (isUsingHMD) {
+            if (isUsingHMDAndHandControllers) {
                 if (sandboxIsRunning) {
                     qCDebug(interfaceapp) << "Home sandbox appears to be running, going to Home.";
                     DependencyManager::get<AddressManager>()->goToLocalSandbox();
+                    sentTo = SENT_TO_SANDBOX;
                 } else {
                     qCDebug(interfaceapp) << "Home sandbox does not appear to be running, going to Entry.";
                     DependencyManager::get<AddressManager>()->goToEntry();
+                    sentTo = SENT_TO_ENTRY;
                 }
             } else {
                 DependencyManager::get<AddressManager>()->goToEntry();
+                sentTo = SENT_TO_ENTRY;
             }
         } else {
             qCDebug(interfaceapp) << "Not first run... going to" << qPrintable(addressLookupString.isEmpty() ? QString("previous location") : addressLookupString);
             DependencyManager::get<AddressManager>()->loadSettings(addressLookupString);
+            sentTo = SENT_TO_PREVIOUS_LOCATION;
         }
     }
+    UserActivityLogger::getInstance().logAction("startup_sent_to", {
+        { "sent_to", sentTo },
+        { "sandbox_is_running", sandboxIsRunning },
+        { "has_hmd", hasHMD },
+        { "has_hand_controllers", hasHandControllers },
+        { "is_using_hmd", isUsingHMD },
+        { "is_using_hmd_and_hand_controllers", isUsingHMDAndHandControllers },
+        { "content_version", contentVersion },
+        { "is_tutorial_complete", isTutorialComplete },
+        { "has_tutorial_content", hasTutorialContent },
+        { "should_go_to_tutorial", shouldGoToTutorial }
+    });
     _connectionMonitor.init();
     // After all of the constructor is completed, then set firstRun to false.

interface/src/Menu.cpp+6−0

 #endif
+    {
+        auto action = addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::RenderClearKtxCache);
+        connect(action, &QAction::triggered, []{
+            Setting::Handle<int>(KTXCache::SETTING_VERSION_NAME, KTXCache::INVALID_VERSION).set(KTXCache::INVALID_VERSION);
+        });
+    }
     // Developer > Render > LOD Tools
     addActionToQMenuAndActionHash(renderOptionsMenu, MenuOption::LodTools, 0,

interface/src/Menu.h+1−0

@@ -145,6 +145,7 @@ namespace MenuOption { · 144 unmodified lines
145	const QString Quit = "Quit";	145	const QString Quit = "Quit";
146	const QString ReloadAllScripts = "Reload All Scripts";	146	const QString ReloadAllScripts = "Reload All Scripts";
147	const QString ReloadContent = "Reload Content (Clears all caches)";	147	const QString ReloadContent = "Reload Content (Clears all caches)";
		148	const QString RenderClearKtxCache = "Clear KTX Cache (requires restart)";
148	const QString RenderMaxTextureMemory = "Maximum Texture Memory";	149	const QString RenderMaxTextureMemory = "Maximum Texture Memory";
149	const QString RenderMaxTextureAutomatic = "Automatic Texture Memory";	150	const QString RenderMaxTextureAutomatic = "Automatic Texture Memory";
150	const QString RenderMaxTexture4MB = "4 MB";	151	const QString RenderMaxTexture4MB = "4 MB";

libraries/entities/src/EntityItem.cpp+7−17

                 // and pretend that we own it (we assume we'll recover it soon)
                 // However, for now, when the server uses a newer time than what we sent, listen to what we're told.
-                if (overwriteLocalData) weOwnSimulation = false;
+                if (overwriteLocalData) {
+                    weOwnSimulation = false;
+                }
             } else if (_simulationOwner.set(newSimOwner)) {
                 markDirtyFlags(Simulation::DIRTY_SIMULATOR_ID);
                 somethingChanged = true;
     properties._accelerationChanged = true;
 }
-void EntityItem::pokeSimulationOwnership() {
+void EntityItem::flagForOwnershipBid(uint8_t priority) {
-    markDirtyFlags(Simulation::DIRTY_SIMULATION_OWNERSHIP_FOR_POKE);
+    markDirtyFlags(Simulation::DIRTY_SIMULATION_OWNERSHIP_PRIORITY);
-    auto nodeList = DependencyManager::get<NodeList>();
-    if (_simulationOwner.matchesValidID(nodeList->getSessionUUID())) {
-        // we already own it
-        _simulationOwner.promotePriority(SCRIPT_POKE_SIMULATION_PRIORITY);
-    } else {
-        // we don't own it yet
-        _simulationOwner.setPendingPriority(SCRIPT_POKE_SIMULATION_PRIORITY, usecTimestampNow());
-    }
-}
-void EntityItem::grabSimulationOwnership() {
-    markDirtyFlags(Simulation::DIRTY_SIMULATION_OWNERSHIP_FOR_GRAB);
     auto nodeList = DependencyManager::get<NodeList>();
     if (_simulationOwner.matchesValidID(nodeList->getSessionUUID())) {
         // we already own it
-        _simulationOwner.promotePriority(SCRIPT_GRAB_SIMULATION_PRIORITY);
+        _simulationOwner.promotePriority(priority);
     } else {
         // we don't own it yet
-        _simulationOwner.setPendingPriority(SCRIPT_GRAB_SIMULATION_PRIORITY, usecTimestampNow());
+        _simulationOwner.setPendingPriority(priority, usecTimestampNow());
     }
 }

libraries/entities/src/EntityItem.h+2−2

     void updateSimulationOwner(const SimulationOwner& owner);
     void clearSimulationOwnership();
     void setPendingOwnershipPriority(quint8 priority, const quint64& timestamp);
+    uint8_t getPendingOwnershipPriority() const { return _simulationOwner.getPendingPriority(); }
     void rememberHasSimulationOwnershipBid() const;
     QString getMarketplaceID() const;
     void getAllTerseUpdateProperties(EntityItemProperties& properties) const;
-    void pokeSimulationOwnership();
+    void flagForOwnershipBid(uint8_t priority);
-    void grabSimulationOwnership();
     void flagForMotionStateChange() { _dirtyFlags |= Simulation::DIRTY_MOTION_TYPE; }
     QString actionsToDebugString();

libraries/entities/src/EntityScriptingInterface.cpp+6−4

                 }
                 entity->setLastBroadcast(usecTimestampNow());
+                // since we're creating this object we will immediately volunteer to own its simulation
+                entity->flagForOwnershipBid(VOLUNTEER_SIMULATION_PRIORITY);
                 propertiesWithSimID.setLastEdited(entity->getLastEdited());
             } else {
                 qCDebug(entities) << "script failed to add new Entity to local Octree";
                 } else {
                     // we make a bid for simulation ownership
                     properties.setSimulationOwner(myNodeID, SCRIPT_POKE_SIMULATION_PRIORITY);
-                    entity->pokeSimulationOwnership();
+                    entity->flagForOwnershipBid(SCRIPT_POKE_SIMULATION_PRIORITY);
                     entity->rememberHasSimulationOwnershipBid();
                 }
             }
         }
         action->setIsMine(true);
         success = entity->addAction(simulation, action);
-        entity->grabSimulationOwnership();
+        entity->flagForOwnershipBid(SCRIPT_GRAB_SIMULATION_PRIORITY);
         return false; // Physics will cause a packet to be sent, so don't send from here.
     });
     if (success) {
     return actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
         bool success = entity->updateAction(simulation, actionID, arguments);
         if (success) {
-            entity->grabSimulationOwnership();
+            entity->flagForOwnershipBid(SCRIPT_GRAB_SIMULATION_PRIORITY);
         }
         return success;
     });
         success = entity->removeAction(simulation, actionID);
         if (success) {
             // reduce from grab to poke
-            entity->pokeSimulationOwnership();
+            entity->flagForOwnershipBid(SCRIPT_POKE_SIMULATION_PRIORITY);
         }
         return false; // Physics will cause a packet to be sent, so don't send from here.
     });

libraries/entities/src/SimulationFlags.h+1−3

     const uint32_t DIRTY_MATERIAL = 0x00400;
     const uint32_t DIRTY_PHYSICS_ACTIVATION = 0x0800; // should activate object in physics engine
     const uint32_t DIRTY_SIMULATOR_ID = 0x1000; // the simulatorID has changed
-    const uint32_t DIRTY_SIMULATION_OWNERSHIP_FOR_POKE = 0x2000; // bid for simulation ownership at "poke"
+    const uint32_t DIRTY_SIMULATION_OWNERSHIP_PRIORITY = 0x2000; // our own bid priority has changed
-    const uint32_t DIRTY_SIMULATION_OWNERSHIP_FOR_GRAB = 0x4000; // bid for simulation ownership at "grab"
     const uint32_t DIRTY_TRANSFORM = DIRTY_POSITION | DIRTY_ROTATION;
     const uint32_t DIRTY_VELOCITIES = DIRTY_LINEAR_VELOCITY | DIRTY_ANGULAR_VELOCITY;
-    const uint32_t DIRTY_SIMULATION_OWNERSHIP_PRIORITY = DIRTY_SIMULATION_OWNERSHIP_FOR_POKE | DIRTY_SIMULATION_OWNERSHIP_FOR_GRAB;
 };
 #endif // hifi_SimulationFlags_h

libraries/entities/src/SimulationOwner.cpp+11−11

@@ -26,9 +26,9 @@ const int SimulationOwner::NUM_BYTES_ENCODED = NUM_BYTES_RFC4122_UUID + 1; · 25 unmodified lines
26	SimulationOwner::SimulationOwner() :	26	SimulationOwner::SimulationOwner() :
27	_id(),	27	_id(),
28	_expiry(0),	28	_expiry(0),
29	_pendingTimestamp(0),	29	_pendingBidTimestamp(0),
30	_priority(0),	30	_priority(0),
31	_pendingPriority(0),	31	_pendingBidPriority(0),
32	_pendingState(PENDING_STATE_NOTHING)	32	_pendingState(PENDING_STATE_NOTHING)
33	{	33	{
34	}	34	}
@@ -36,9 +36,9 @@ SimulationOwner::SimulationOwner() : · 1 unmodified line
36	SimulationOwner::SimulationOwner(const QUuid& id, quint8 priority) :	36	SimulationOwner::SimulationOwner(const QUuid& id, quint8 priority) :
37	_id(id),	37	_id(id),
38	_expiry(0),	38	_expiry(0),
39	_pendingTimestamp(0),	39	_pendingBidTimestamp(0),
40	_priority(priority),	40	_priority(priority),
41	_pendingPriority(0)	41	_pendingBidPriority(0)
42	{	42	{
43	}	43	}
44		44
@@ -61,9 +61,9 @@ bool SimulationOwner::fromByteArray(const QByteArray& data) { · 16 unmodified lines
61	void SimulationOwner::clear() {	61	void SimulationOwner::clear() {
62	_id = QUuid();	62	_id = QUuid();
63	_expiry = 0;	63	_expiry = 0;
64	_pendingTimestamp = 0;	64	_pendingBidTimestamp = 0;
65	_priority = 0;	65	_priority = 0;
66	_pendingPriority = 0;	66	_pendingBidPriority = 0;
67	_pendingState = PENDING_STATE_NOTHING;	67	_pendingState = PENDING_STATE_NOTHING;
68	}	68	}
69		69
@@ -102,9 +102,9 @@ bool SimulationOwner::set(const SimulationOwner& owner) { · 32 unmodified lines
102	}	102	}
103		103
104	void SimulationOwner::setPendingPriority(quint8 priority, const quint64& timestamp) {	104	void SimulationOwner::setPendingPriority(quint8 priority, const quint64& timestamp) {
105	_pendingPriority = priority;	105	_pendingBidPriority = priority;
106	_pendingTimestamp = timestamp;	106	_pendingBidTimestamp = timestamp;
107	_pendingState = (_pendingPriority == 0) ? PENDING_STATE_RELEASE : PENDING_STATE_TAKE;	107	_pendingState = (_pendingBidPriority == 0) ? PENDING_STATE_RELEASE : PENDING_STATE_TAKE;
108	}	108	}
109		109
110	void SimulationOwner::updateExpiry() {	110	void SimulationOwner::updateExpiry() {
@@ -113,11 +113,11 @@ void SimulationOwner::updateExpiry() { · 2 unmodified lines
113	}	113	}
114		114
115	bool SimulationOwner::pendingRelease(const quint64& timestamp) {	115	bool SimulationOwner::pendingRelease(const quint64& timestamp) {
116	return _pendingPriority == 0 && _pendingState == PENDING_STATE_RELEASE && _pendingTimestamp >= timestamp;	116	return _pendingBidPriority == 0 && _pendingState == PENDING_STATE_RELEASE && _pendingBidTimestamp >= timestamp;
117	}	117	}
118		118
119	bool SimulationOwner::pendingTake(const quint64& timestamp) {	119	bool SimulationOwner::pendingTake(const quint64& timestamp) {
120	return _pendingPriority > 0 && _pendingState == PENDING_STATE_TAKE && _pendingTimestamp >= timestamp;	120	return _pendingBidPriority > 0 && _pendingState == PENDING_STATE_TAKE && _pendingBidTimestamp >= timestamp;
121	}	121	}
122		122
123	void SimulationOwner::clearCurrentOwner() {	123	void SimulationOwner::clearCurrentOwner() {

libraries/entities/src/SimulationOwner.h+3−2

     bool hasExpired() const { return usecTimestampNow() > _expiry; }
+    uint8_t getPendingPriority() const { return _pendingBidPriority; }
     bool pendingRelease(const quint64& timestamp); // return true if valid pending RELEASE
     bool pendingTake(const quint64& timestamp); // return true if valid pending TAKE
     void clearCurrentOwner();
 private:
     QUuid _id; // owner
     quint64 _expiry; // time when ownership can transition at equal priority
-    quint64 _pendingTimestamp; // time when pending update was set
+    quint64 _pendingBidTimestamp; // time when pending bid was set
     quint8 _priority; // priority of current owner
-    quint8 _pendingPriority; // priority of pendingTake
+    quint8 _pendingBidPriority; // priority at which we'd like to own it
     quint8 _pendingState; // NOTHING, TAKE, or RELEASE
 };

libraries/model-networking/src/model-networking/KTXCache.cpp+14−0

 #include "KTXCache.h"
+#include <SettingHandle.h>
 #include <ktx/KTX.h>
 using File = cache::File;
 using FilePointer = cache::FilePointer;
+// Whenever a change is made to the serialized format for the KTX cache that isn't backward compatible,
+// this value should be incremented.  This will force the KTX cache to be wiped
+const int KTXCache::CURRENT_VERSION = 0x01;
+const int KTXCache::INVALID_VERSION = 0x00;
+const char* KTXCache::SETTING_VERSION_NAME = "hifi.ktx.cache_version";
 KTXCache::KTXCache(const std::string& dir, const std::string& ext) :
     FileCache(dir, ext) {
     initialize();
+    Setting::Handle<int> cacheVersionHandle(SETTING_VERSION_NAME, INVALID_VERSION);
+    auto cacheVersion = cacheVersionHandle.get();
+    if (cacheVersion != CURRENT_VERSION) {
+        wipe();
+        cacheVersionHandle.set(CURRENT_VERSION);
+    }
 }
 KTXFilePointer KTXCache::writeFile(const char* data, Metadata&& metadata) {

libraries/model-networking/src/model-networking/KTXCache.h+6−0

     Q_OBJECT
 public:
+    // Whenever a change is made to the serialized format for the KTX cache that isn't backward compatible,
+    // this value should be incremented.  This will force the KTX cache to be wiped
+    static const int CURRENT_VERSION;
+    static const int INVALID_VERSION;
+    static const char* SETTING_VERSION_NAME;
     KTXCache(const std::string& dir, const std::string& ext);
     KTXFilePointer writeFile(const char* data, Metadata&& metadata);

libraries/networking/src/FileCache.cpp+31−14

     };
 }
+void FileCache::eject(const FilePointer& file) {
+    file->_cache = nullptr;
+    const auto& length = file->getLength();
+    const auto& key = file->getKey();
+    {
+        Lock lock(_filesMutex);
+        if (0 != _files.erase(key)) {
+            _numTotalFiles -= 1;
+            _totalFilesSize -= length;
+        }
+    }
+    {
+        Lock unusedLock(_unusedFilesMutex);
+        if (0 != _unusedFiles.erase(file)) {
+            _numUnusedFiles -= 1;
+            _unusedFilesSize -= length;
+        }
+    }
+}
 void FileCache::clean() {
     size_t overbudgetAmount = getOverbudgetAmount();
     for (const auto& file : _unusedFiles) {
         queue.push(file);
     }
     while (!queue.empty() && overbudgetAmount > 0) {
         auto file = queue.top();
         queue.pop();
+        eject(file);
         auto length = file->getLength();
-        unusedLock.unlock();
-        {
-            file->_cache = nullptr;
-            Lock lock(_filesMutex);
-            _files.erase(file->getKey());
-        }
-        unusedLock.lock();
-        _unusedFiles.erase(file);
-        _numTotalFiles -= 1;
-        _numUnusedFiles -= 1;
-        _totalFilesSize -= length;
-        _unusedFilesSize -= length;
         overbudgetAmount -= std::min(length, overbudgetAmount);
     }
 }
+void FileCache::wipe() {
+    Lock unusedFilesLock(_unusedFilesMutex);
+    while (!_unusedFiles.empty()) {
+        eject(*_unusedFiles.begin());
+    }
+}
 void FileCache::clear() {
     // Eliminate any overbudget files
     clean();

libraries/networking/src/FileCache.h+12−4

     FileCache(const std::string& dirname, const std::string& ext, QObject* parent = nullptr);
     virtual ~FileCache();
+    // Remove all unlocked items from the cache
+    void wipe();
     size_t getNumTotalFiles() const { return _numTotalFiles; }
     size_t getNumCachedFiles() const { return _numUnusedFiles; }
     size_t getSizeTotalFiles() const { return _totalFilesSize; }
 private:
     using Mutex = std::recursive_mutex;
     using Lock = std::unique_lock<Mutex>;
+    using Map = std::unordered_map<Key, std::weak_ptr<File>>;
+    using Set = std::unordered_set<FilePointer>;
+    using KeySet = std::unordered_set<Key>;
     friend class File;
     void removeUnusedFile(const FilePointer& file);
     void clean();
     void clear();
+    // Remove a file from the cache
+    void eject(const FilePointer& file);
     size_t getOverbudgetAmount() const;
     std::string _dirpath;
     bool _initialized { false };
-    std::unordered_map<Key, std::weak_ptr<File>> _files;
+    Map _files;
     Mutex _filesMutex;
-    std::unordered_set<FilePointer> _unusedFiles;
+    Set _unusedFiles;
     Mutex _unusedFilesMutex;
 };
     using Key = FileCache::Key;
     using Metadata = FileCache::Metadata;
-    Key getKey() const { return _key; }
+    const Key& getKey() const { return _key; }
-    size_t getLength() const { return _length; }
+    const size_t& getLength() const { return _length; }
     std::string getFilepath() const { return _filepath; }
     virtual ~File();

libraries/physics/src/EntityMotionState.cpp+20−15

@@ -65,8 +65,7 @@ EntityMotionState::EntityMotionState(btCollisionShape* shape, EntityItemPointer · 64 unmodified lines
65	_lastStep(0),	65	_lastStep(0),
66	_loopsWithoutOwner(0),	66	_loopsWithoutOwner(0),
67	_accelerationNearlyGravityCount(0),	67	_accelerationNearlyGravityCount(0),
68	_numInactiveUpdates(1),	68	_numInactiveUpdates(1)
69	_outgoingPriority(0)
70	{	69	{
71	_type = MOTIONSTATE_TYPE_ENTITY;	70	_type = MOTIONSTATE_TYPE_ENTITY;
72	assert(_entity);	71	assert(_entity);
@@ -75,6 +74,8 @@ EntityMotionState::EntityMotionState(btCollisionShape* shape, EntityItemPointer · 2 unmodified lines
75	// we need the side-effects of EntityMotionState::setShape() so we call it explicitly here	74	// we need the side-effects of EntityMotionState::setShape() so we call it explicitly here
76	// rather than pass the legit shape pointer to the ObjectMotionState ctor above.	75	// rather than pass the legit shape pointer to the ObjectMotionState ctor above.
77	setShape(shape);	76	setShape(shape);
		77
		78	_outgoingPriority = _entity->getPendingOwnershipPriority();
78	}	79	}
79		80
80	EntityMotionState::~EntityMotionState() {	81	EntityMotionState::~EntityMotionState() {
@@ -84,7 +85,7 @@ EntityMotionState::~EntityMotionState() { · 3 unmodified lines
84		85
85	void EntityMotionState::updateServerPhysicsVariables() {	86	void EntityMotionState::updateServerPhysicsVariables() {
86	assert(entityTreeIsLocked());	87	assert(entityTreeIsLocked());
87	if (_entity->getSimulatorID() == Physics::getSessionUUID()) {	88	if (isLocallyOwned()) {
88	// don't slam these values if we are the simulation owner	89	// don't slam these values if we are the simulation owner
89	return;	90	return;
90	}	91	}
@@ -136,23 +137,23 @@ void EntityMotionState::handleEasyChanges(uint32_t& flags) { · 45 unmodified lines
136	_nextOwnershipBid = usecTimestampNow() + USECS_BETWEEN_OWNERSHIP_BIDS;	137	_nextOwnershipBid = usecTimestampNow() + USECS_BETWEEN_OWNERSHIP_BIDS;
137	}	138	}
138	_loopsWithoutOwner = 0;	139	_loopsWithoutOwner = 0;
139	} else if (_entity->getSimulatorID() == Physics::getSessionUUID()) {	140	_numInactiveUpdates = 0;
		141	} else if (isLocallyOwned()) {
140	// we just inherited ownership, make sure our desired priority matches what we have	142	// we just inherited ownership, make sure our desired priority matches what we have
141	upgradeOutgoingPriority(_entity->getSimulationPriority());	143	upgradeOutgoingPriority(_entity->getSimulationPriority());
142	} else {	144	} else {
143	_outgoingPriority = 0;	145	_outgoingPriority = 0;
144	_nextOwnershipBid = usecTimestampNow() + USECS_BETWEEN_OWNERSHIP_BIDS;	146	_nextOwnershipBid = usecTimestampNow() + USECS_BETWEEN_OWNERSHIP_BIDS;
		147	_numInactiveUpdates = 0;
145	}	148	}
146	}	149	}
147	if (flags & Simulation::DIRTY_SIMULATION_OWNERSHIP_PRIORITY) {	150	if (flags & Simulation::DIRTY_SIMULATION_OWNERSHIP_PRIORITY) {
148	// The DIRTY_SIMULATOR_OWNERSHIP_PRIORITY bits really mean "we should bid for ownership because	151	// The DIRTY_SIMULATOR_OWNERSHIP_PRIORITY bit means one of the following:
149	// a local script has been changing physics properties, or we should adjust our own ownership priority".	152	// (1) we own it but may need to change the priority OR...
150	// The desired priority is determined by which bits were set.	153	// (2) we don't own it but should bid (because a local script has been changing physics properties)
151	if (flags & Simulation::DIRTY_SIMULATION_OWNERSHIP_FOR_GRAB) {	154	uint8_t newPriority = isLocallyOwned() ? _entity->getSimulationOwner().getPriority() : _entity->getSimulationOwner().getPendingPriority();
152	_outgoingPriority = SCRIPT_GRAB_SIMULATION_PRIORITY;	155	_outgoingPriority = glm::max(_outgoingPriority, newPriority);
153	} else {	156
154	_outgoingPriority = SCRIPT_POKE_SIMULATION_PRIORITY;
155	}
156	// reset bid expiry so that we bid ASAP	157	// reset bid expiry so that we bid ASAP
157	_nextOwnershipBid = 0;	158	_nextOwnershipBid = 0;
158	}	159	}
@@ -317,7 +318,7 @@ bool EntityMotionState::isCandidateForOwnership() const { · 158 unmodified lines
317	assert(_entity);	318	assert(_entity);
318	assert(entityTreeIsLocked());	319	assert(entityTreeIsLocked());
319	return _outgoingPriority != 0	320	return _outgoingPriority != 0
320	\|\| Physics::getSessionUUID() == _entity->getSimulatorID()	321	\|\| isLocallyOwned()
321	\|\| _entity->dynamicDataNeedsTransmit();	322	\|\| _entity->dynamicDataNeedsTransmit();
322	}	323	}
323		324
@@ -491,7 +492,7 @@ bool EntityMotionState::shouldSendUpdate(uint32_t simulationStep) { · 167 unmodified lines
491	return true;	492	return true;
492	}	493	}
493		494
494	if (_entity->getSimulatorID() != Physics::getSessionUUID()) {	495	if (!isLocallyOwned()) {
495	// we don't own the simulation	496	// we don't own the simulation
496		497
497	// NOTE: we do not volunteer to own kinematic or static objects	498	// NOTE: we do not volunteer to own kinematic or static objects
@@ -599,7 +600,7 @@ void EntityMotionState::sendUpdate(OctreeEditPacketSender* packetSender, uint32_ · 101 unmodified lines
599	properties.clearSimulationOwner();	600	properties.clearSimulationOwner();
600	_outgoingPriority = 0;	601	_outgoingPriority = 0;
601	_entity->setPendingOwnershipPriority(_outgoingPriority, now);	602	_entity->setPendingOwnershipPriority(_outgoingPriority, now);
602	} else if (Physics::getSessionUUID() != _entity->getSimulatorID()) {	603	} else if (!isLocallyOwned()) {
603	// we don't own the simulation for this entity yet, but we're sending a bid for it	604	// we don't own the simulation for this entity yet, but we're sending a bid for it
604	quint8 bidPriority = glm::max<uint8_t>(_outgoingPriority, VOLUNTEER_SIMULATION_PRIORITY);	605	quint8 bidPriority = glm::max<uint8_t>(_outgoingPriority, VOLUNTEER_SIMULATION_PRIORITY);
605	properties.setSimulationOwner(Physics::getSessionUUID(), bidPriority);	606	properties.setSimulationOwner(Physics::getSessionUUID(), bidPriority);
@@ -788,6 +789,10 @@ void EntityMotionState::computeCollisionGroupAndMask(int16_t& group, int16_t& ma · 182 unmodified lines
788	_entity->computeCollisionGroupAndFinalMask(group, mask);	789	_entity->computeCollisionGroupAndFinalMask(group, mask);
789	}	790	}
790		791
		792	bool EntityMotionState::isLocallyOwned() const {
		793	return _entity->getSimulatorID() == Physics::getSessionUUID();
		794	}
		795
791	bool EntityMotionState::shouldBeLocallyOwned() const {	796	bool EntityMotionState::shouldBeLocallyOwned() const {
792	return (_outgoingPriority > VOLUNTEER_SIMULATION_PRIORITY && _outgoingPriority > _entity->getSimulationPriority()) \|\|	797	return (_outgoingPriority > VOLUNTEER_SIMULATION_PRIORITY && _outgoingPriority > _entity->getSimulationPriority()) \|\|
793	_entity->getSimulatorID() == Physics::getSessionUUID();	798	_entity->getSimulatorID() == Physics::getSessionUUID();

libraries/physics/src/EntityMotionState.h+1−0

@@ -79,6 +79,7 @@ public: · 78 unmodified lines
79		79
80	virtual void computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const override;	80	virtual void computeCollisionGroupAndMask(int16_t& group, int16_t& mask) const override;
81		81
		82	bool isLocallyOwned() const override;
82	bool shouldBeLocallyOwned() const override;	83	bool shouldBeLocallyOwned() const override;
83		84
84	friend class PhysicalEntitySimulation;	85	friend class PhysicalEntitySimulation;

libraries/physics/src/ObjectMotionState.h+1−0

@@ -146,6 +146,7 @@ public: · 145 unmodified lines
146	void dirtyInternalKinematicChanges() { _hasInternalKinematicChanges = true; }	146	void dirtyInternalKinematicChanges() { _hasInternalKinematicChanges = true; }
147	void clearInternalKinematicChanges() { _hasInternalKinematicChanges = false; }	147	void clearInternalKinematicChanges() { _hasInternalKinematicChanges = false; }
148		148
		149	virtual bool isLocallyOwned() const { return false; }
149	virtual bool shouldBeLocallyOwned() const { return false; }	150	virtual bool shouldBeLocallyOwned() const { return false; }
150		151
151	friend class PhysicsEngine;	152	friend class PhysicsEngine;

libraries/physics/src/PhysicsEngine.cpp+24−19

@@ -129,6 +129,9 @@ void PhysicsEngine::addObjectToDynamicsWorld(ObjectMotionState* motionState) { · 128 unmodified lines
129	}	129	}
130	body->setCollisionFlags(btCollisionObject::CF_STATIC_OBJECT);	130	body->setCollisionFlags(btCollisionObject::CF_STATIC_OBJECT);
131	body->updateInertiaTensor();	131	body->updateInertiaTensor();
		132	if (motionState->isLocallyOwned()) {
		133	_activeStaticBodies.insert(body);
		134	}
132	break;	135	break;
133	}	136	}
134	}	137	}
@@ -174,19 +177,9 @@ void PhysicsEngine::removeObjects(const VectorOfMotionStates& objects) { · 39 unmodified lines
174	// frame (because the framerate is faster than our physics simulation rate). When this happens we must scan	177	// frame (because the framerate is faster than our physics simulation rate). When this happens we must scan
175	// _activeStaticBodies for objects that were recently deleted so we don't try to access a dangling pointer.	178	// _activeStaticBodies for objects that were recently deleted so we don't try to access a dangling pointer.
176	for (auto object : objects) {	179	for (auto object : objects) {
177	btRigidBody* body = object->getRigidBody();	180	std::set<btRigidBody*>::iterator itr = _activeStaticBodies.find(object->getRigidBody());
178		181	if (itr != _activeStaticBodies.end()) {
179	std::vector<btRigidBody*>::reverse_iterator itr = _activeStaticBodies.rbegin();	182	_activeStaticBodies.erase(itr);
180	while (itr != _activeStaticBodies.rend()) {
181	if (body == *itr) {
182	if (itr != (_activeStaticBodies.rbegin())) {
183	// swap with rbegin
184	itr = (_activeStaticBodies.rbegin());
185	}
186	_activeStaticBodies.pop_back();
187	break;
188	}
189	++itr;
190	}	183	}
191	}	184	}
192	}	185	}
@@ -245,14 +238,16 @@ VectorOfMotionStates PhysicsEngine::changeObjects(const VectorOfMotionStates& ob · 52 unmodified lines
245	object->clearIncomingDirtyFlags();	238	object->clearIncomingDirtyFlags();
246	}	239	}
247	if (object->getMotionType() == MOTION_TYPE_STATIC && object->isActive()) {	240	if (object->getMotionType() == MOTION_TYPE_STATIC && object->isActive()) {
248	_activeStaticBodies.push_back(object->getRigidBody());	241	_activeStaticBodies.insert(object->getRigidBody());
249	}	242	}
250	}	243	}
251	// active static bodies have changed (in an Easy way) and need their Aabbs updated	244	// active static bodies have changed (in an Easy way) and need their Aabbs updated
252	// but we've configured Bullet to NOT update them automatically (for improved performance)	245	// but we've configured Bullet to NOT update them automatically (for improved performance)
253	// so we must do it ourselves	246	// so we must do it ourselves
254	for (size_t i = 0; i < _activeStaticBodies.size(); ++i) {	247	std::set<btRigidBody*>::const_iterator itr = _activeStaticBodies.begin();
255	_dynamicsWorld->updateSingleAabb(_activeStaticBodies[i]);	248	while (itr != _activeStaticBodies.end()) {
		249	_dynamicsWorld->updateSingleAabb(*itr);
		250	++itr;
256	}	251	}
257	return stillNeedChange;	252	return stillNeedChange;
258	}	253	}
@@ -496,13 +491,23 @@ const CollisionEvents& PhysicsEngine::getCollisionEvents() { · 237 unmodified lines
496		491
497	const VectorOfMotionStates& PhysicsEngine::getChangedMotionStates() {	492	const VectorOfMotionStates& PhysicsEngine::getChangedMotionStates() {
498	BT_PROFILE("copyOutgoingChanges");	493	BT_PROFILE("copyOutgoingChanges");
		494
		495	_dynamicsWorld->synchronizeMotionStates();
		496
499	// Bullet will not deactivate static objects (it doesn't expect them to be active)	497	// Bullet will not deactivate static objects (it doesn't expect them to be active)
500	// so we must deactivate them ourselves	498	// so we must deactivate them ourselves
501	for (size_t i = 0; i < _activeStaticBodies.size(); ++i) {	499	std::set<btRigidBody*>::const_iterator itr = _activeStaticBodies.begin();
502	_activeStaticBodies[i]->forceActivationState(ISLAND_SLEEPING);	500	while (itr != _activeStaticBodies.end()) {
		501	btRigidBody* body = *itr;
		502	body->forceActivationState(ISLAND_SLEEPING);
		503	ObjectMotionState* motionState = static_cast<ObjectMotionState*>(body->getUserPointer());
		504	if (motionState) {
		505	_dynamicsWorld->addChangedMotionState(motionState);
		506	}
		507	++itr;
503	}	508	}
504	_activeStaticBodies.clear();	509	_activeStaticBodies.clear();
505	_dynamicsWorld->synchronizeMotionStates();	510
506	_hasOutgoingChanges = false;	511	_hasOutgoingChanges = false;
507	return _dynamicsWorld->getChangedMotionStates();	512	return _dynamicsWorld->getChangedMotionStates();
508	}	513	}

libraries/physics/src/PhysicsEngine.h+2−1

 #define hifi_PhysicsEngine_h
 #include <stdint.h>
+#include <set>
 #include <vector>
 #include <QUuid>
     CollisionEvents _collisionEvents;
     QHash<QUuid, EntityDynamicPointer> _objectDynamics;
     QHash<btRigidBody*, QSet<QUuid>> _objectDynamicsByBody;
-    std::vector<btRigidBody*> _activeStaticBodies;
+    std::set<btRigidBody*> _activeStaticBodies;
     glm::vec3 _originOffset;

libraries/physics/src/ThreadSafeDynamicsWorld.h+2−0

@@ -51,6 +51,8 @@ public: · 50 unmodified lines
51	const VectorOfMotionStates& getChangedMotionStates() const { return _changedMotionStates; }	51	const VectorOfMotionStates& getChangedMotionStates() const { return _changedMotionStates; }
52	const VectorOfMotionStates& getDeactivatedMotionStates() const { return _deactivatedStates; }	52	const VectorOfMotionStates& getDeactivatedMotionStates() const { return _deactivatedStates; }
53		53
		54	void addChangedMotionState(ObjectMotionState* motionState) { _changedMotionStates.push_back(motionState); }
		55
54	private:	56	private:
55	// call this instead of non-virtual btDiscreteDynamicsWorld::synchronizeSingleMotionState()	57	// call this instead of non-virtual btDiscreteDynamicsWorld::synchronizeSingleMotionState()
56	void synchronizeMotionState(btRigidBody* body);	58	void synchronizeMotionState(btRigidBody* body);

tests/networking/src/FileCacheTests.cpp+22−5

@@ -113,18 +113,21 @@ void FileCacheTests::testUnusedFiles() { · 112 unmodified lines
113	QVERIFY(!file.get());	113	QVERIFY(!file.get());
114	}	114	}
115		115
116	QThread::msleep(1000);
117	// Test files 90 to 99 are present	116	// Test files 90 to 99 are present
118	for (int i = 90; i < 100; ++i) {	117	for (int i = 90; i < 100; ++i) {
119	std::string key = getFileKey(i);	118	std::string key = getFileKey(i);
120	auto file = cache->getFile(key);	119	auto file = cache->getFile(key);
121	QVERIFY(file.get());	120	QVERIFY(file.get());
122	inUseFiles.push_back(file);	121	inUseFiles.push_back(file);
123	// Each access touches the file, so we need to sleep here to ensure that the files are	122
124	// spaced out in numeric order, otherwise later tests can't reliably determine the order	123	if (i == 94) {
125	// for cache ejection	124	// Each access touches the file, so we need to sleep here to ensure that the the last 5 files
126	QThread::msleep(1000);	125	// have later times for cache ejection priority, otherwise the test runs too fast to reliably
		126	// differentiate
		127	QThread::msleep(1000);
		128	}
127	}	129	}
		130
128	QCOMPARE(cache->getNumCachedFiles(), (size_t)0);	131	QCOMPARE(cache->getNumCachedFiles(), (size_t)0);
129	QCOMPARE(cache->getNumTotalFiles(), (size_t)10);	132	QCOMPARE(cache->getNumTotalFiles(), (size_t)10);
130	inUseFiles.clear();	133	inUseFiles.clear();
@@ -165,6 +168,20 @@ void FileCacheTests::testFreeSpacePreservation() { · 34 unmodified lines
165	}	168	}
166	}	169	}
167		170
		171	void FileCacheTests::testWipe() {
		172	// Reset the cache
		173	auto cache = makeFileCache(_testDir.path());
		174	QCOMPARE(cache->getNumCachedFiles(), (size_t)5);
		175	QCOMPARE(cache->getNumTotalFiles(), (size_t)5);
		176	cache->wipe();
		177	QCOMPARE(cache->getNumCachedFiles(), (size_t)0);
		178	QCOMPARE(cache->getNumTotalFiles(), (size_t)0);
		179	QVERIFY(getCacheDirectorySize() > 0);
		180	forceDeletes();
		181	QCOMPARE(getCacheDirectorySize(), (size_t)0);
		182	}
		183
		184
168	void FileCacheTests::cleanupTestCase() {	185	void FileCacheTests::cleanupTestCase() {
169	}	186	}
170		187

tests/networking/src/FileCacheTests.h+1−0

@@ -20,6 +20,7 @@ private slots: · 19 unmodified lines
20	void testUnusedFiles();	20	void testUnusedFiles();
21	void testFreeSpacePreservation();	21	void testFreeSpacePreservation();
22	void cleanupTestCase();	22	void cleanupTestCase();
		23	void testWipe();
23		24
24	private:	25	private:
25	size_t getFreeSpace() const;	26	size_t getFreeSpace() const;