Merge branch 'master' of github.com:highfidelity/hifi into avatar-entities-3

assignment-client/src/AssignmentAction.cpp

@@ -23,7 +23,7 @@ AssignmentAction::AssignmentAction(EntityActionType type, const QUuid& id, Entit
 AssignmentAction::~AssignmentAction() {
 }
 
-void AssignmentAction::removeFromSimulation(EntitySimulation* simulation) const {
+void AssignmentAction::removeFromSimulation(EntitySimulationPointer simulation) const {
     withReadLock([&]{
         simulation->removeAction(_id);
         simulation->applyActionChanges();

assignment-client/src/AssignmentAction.h

@@ -24,7 +24,7 @@ public:
     AssignmentAction(EntityActionType type, const QUuid& id, EntityItemPointer ownerEntity);
     virtual ~AssignmentAction();
 
-    virtual void removeFromSimulation(EntitySimulation* simulation) const;
+    virtual void removeFromSimulation(EntitySimulationPointer simulation) const;
     virtual EntityItemWeakPointer getOwnerEntity() const { return _ownerEntity; }
     virtual void setOwnerEntity(const EntityItemPointer ownerEntity) { _ownerEntity = ownerEntity; }
     virtual bool updateArguments(QVariantMap arguments);

assignment-client/src/entities/EntityServer.cpp

@@ -56,7 +56,7 @@ OctreePointer EntityServer::createTree() {
     tree->createRootElement();
     tree->addNewlyCreatedHook(this);
     if (!_entitySimulation) {
-        SimpleEntitySimulation* simpleSimulation = new SimpleEntitySimulation();
+        SimpleEntitySimulationPointer simpleSimulation { new SimpleEntitySimulation() };
         simpleSimulation->setEntityTree(tree);
         tree->setSimulation(simpleSimulation);
         _entitySimulation = simpleSimulation;

assignment-client/src/entities/EntityServer.h

@@ -28,6 +28,8 @@ struct ViewerSendingStats {
 };
 
 class SimpleEntitySimulation;
+using SimpleEntitySimulationPointer = std::shared_ptr<SimpleEntitySimulation>;
+
 
 class EntityServer : public OctreeServer, public NewlyCreatedEntityHook {
     Q_OBJECT
@@ -69,7 +71,7 @@ private slots:
     void handleEntityPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
 
 private:
-    SimpleEntitySimulation* _entitySimulation;
+    SimpleEntitySimulationPointer _entitySimulation;
     QTimer* _pruneDeletedEntitiesTimer = nullptr;
 
     QReadWriteLock _viewerSendingStatsLock;

interface/resources/avatar/avatar-animation.json

@@ -274,7 +274,7 @@
                                                         },
                                                         {
                                                             "id": "walkFwd",
-                                                            "interpTarget": 15,
+                                                            "interpTarget": 16,
                                                             "interpDuration": 6,
                                                             "transitions": [
                                                                 { "var": "isNotMoving", "state": "idle" },
@@ -497,7 +497,7 @@
                                                                 "data": {
                                                                     "url": "animations/idle.fbx",
                                                                     "startFrame": 0.0,
-                                                                    "endFrame": 90.0,
+                                                                    "endFrame": 300.0,
                                                                     "timeScale": 1.0,
                                                                     "loopFlag": true
                                                                 },
@@ -509,7 +509,7 @@
                                                                 "data": {
                                                                     "url": "animations/talk.fbx",
                                                                     "startFrame": 0.0,
-                                                                    "endFrame": 801.0,
+                                                                    "endFrame": 800.0,
                                                                     "timeScale": 1.0,
                                                                     "loopFlag": true
                                                                 },
@@ -572,7 +572,7 @@
                                                         "data": {
                                                             "url": "animations/idle_to_walk.fbx",
                                                             "startFrame": 1.0,
-                                                            "endFrame": 19.0,
+                                                            "endFrame": 13.0,
                                                             "timeScale": 1.0,
                                                             "loopFlag": false
                                                         },
@@ -631,11 +631,12 @@
                                                         "id": "turnRight",
                                                         "type": "clip",
                                                         "data": {
-                                                            "url": "animations/turn_right.fbx",
+                                                            "url": "animations/turn_left.fbx",
                                                             "startFrame": 0.0,
                                                             "endFrame": 30.0,
                                                             "timeScale": 1.0,
-                                                            "loopFlag": true
+                                                            "loopFlag": true,
+                                                            "mirrorFlag": true
                                                         },
                                                         "children": []
                                                     },

interface/src/Application.cpp

@@ -485,6 +485,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     _sessionRunTimer(startupTimer),
     _previousSessionCrashed(setupEssentials(argc, argv)),
     _undoStackScriptingInterface(&_undoStack),
+    _entitySimulation(new PhysicalEntitySimulation()),
     _physicsEngine(new PhysicsEngine(Vectors::ZERO)),
     _entityClipboardRenderer(false, this, this),
     _entityClipboard(new EntityTree()),
@@ -560,12 +561,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     // put the NodeList and datagram processing on the node thread
     nodeList->moveToThread(nodeThread);
 
-    // Model background downloads need to happen on the Datagram Processor Thread.  The idle loop will
-    // emit checkBackgroundDownloads to cause the ModelCache to check it's queue for requested background
-    // downloads.
-    auto modelCache = DependencyManager::get<ModelCache>();
-    connect(this, &Application::checkBackgroundDownloads, modelCache.data(), &ModelCache::checkAsynchronousGets);
-
     // put the audio processing on a separate thread
     QThread* audioThread = new QThread();
     audioThread->setObjectName("Audio Thread");
@@ -2739,9 +2734,6 @@ void Application::idle(uint64_t now) {
     }
 
     _overlayConductor.update(secondsSinceLastUpdate);
-
-    // check for any requested background downloads.
-    emit checkBackgroundDownloads();
 }
 
 void Application::setLowVelocityFilter(bool lowVelocityFilter) {
@@ -2991,13 +2983,13 @@ void Application::init() {
     _physicsEngine->init();
 
     EntityTreePointer tree = getEntities()->getTree();
-    _entitySimulation.init(tree, _physicsEngine, &_entityEditSender);
+    _entitySimulation->init(tree, _physicsEngine, &_entityEditSender);
-    tree->setSimulation(&_entitySimulation);
+    tree->setSimulation(_entitySimulation);
 
     auto entityScriptingInterface = DependencyManager::get<EntityScriptingInterface>();
 
     // connect the _entityCollisionSystem to our EntityTreeRenderer since that's what handles running entity scripts
-    connect(&_entitySimulation, &EntitySimulation::entityCollisionWithEntity,
+    connect(_entitySimulation.get(), &EntitySimulation::entityCollisionWithEntity,
             getEntities(), &EntityTreeRenderer::entityCollisionWithEntity);
 
     // connect the _entities (EntityTreeRenderer) to our script engine's EntityScriptingInterface for firing
@@ -3417,22 +3409,22 @@ void Application::update(float deltaTime) {
 
             PerformanceTimer perfTimer("updateStates)");
             static VectorOfMotionStates motionStates;
-            _entitySimulation.getObjectsToRemoveFromPhysics(motionStates);
+            _entitySimulation->getObjectsToRemoveFromPhysics(motionStates);
             _physicsEngine->removeObjects(motionStates);
-            _entitySimulation.deleteObjectsRemovedFromPhysics();
+            _entitySimulation->deleteObjectsRemovedFromPhysics();
 
             getEntities()->getTree()->withReadLock([&] {
-                _entitySimulation.getObjectsToAddToPhysics(motionStates);
+                _entitySimulation->getObjectsToAddToPhysics(motionStates);
                 _physicsEngine->addObjects(motionStates);
 
             });
             getEntities()->getTree()->withReadLock([&] {
-                _entitySimulation.getObjectsToChange(motionStates);
+                _entitySimulation->getObjectsToChange(motionStates);
                 VectorOfMotionStates stillNeedChange = _physicsEngine->changeObjects(motionStates);
-                _entitySimulation.setObjectsToChange(stillNeedChange);
+                _entitySimulation->setObjectsToChange(stillNeedChange);
             });
 
-            _entitySimulation.applyActionChanges();
+            _entitySimulation->applyActionChanges();
 
              avatarManager->getObjectsToRemoveFromPhysics(motionStates);
             _physicsEngine->removeObjects(motionStates);
@@ -3460,7 +3452,7 @@ void Application::update(float deltaTime) {
                 getEntities()->getTree()->withWriteLock([&] {
                     PerformanceTimer perfTimer("handleOutgoingChanges");
                     const VectorOfMotionStates& outgoingChanges = _physicsEngine->getOutgoingChanges();
-                    _entitySimulation.handleOutgoingChanges(outgoingChanges);
+                    _entitySimulation->handleOutgoingChanges(outgoingChanges);
                     avatarManager->handleOutgoingChanges(outgoingChanges);
                 });
 
@@ -3473,7 +3465,7 @@ void Application::update(float deltaTime) {
                     PerformanceTimer perfTimer("entities");
                     // Collision events (and their scripts) must not be handled when we're locked, above. (That would risk
                     // deadlock.)
-                    _entitySimulation.handleCollisionEvents(collisionEvents);
+                    _entitySimulation->handleCollisionEvents(collisionEvents);
 
                     // NOTE: the getEntities()->update() call below will wait for lock
                     // and will simulate entity motion (the EntityTree has been given an EntitySimulation).

interface/src/Application.h

@@ -222,8 +222,6 @@ public:
 signals:
     void svoImportRequested(const QString& url);
 
-    void checkBackgroundDownloads();
-
     void fullAvatarURLChanged(const QString& newValue, const QString& modelName);
 
     void beforeAboutToQuit();
@@ -405,7 +403,7 @@ private:
     QElapsedTimer _lastTimeUpdated;
 
     ShapeManager _shapeManager;
-    PhysicalEntitySimulation _entitySimulation;
+    PhysicalEntitySimulationPointer _entitySimulation;
     PhysicsEnginePointer _physicsEngine;
 
     EntityTreeRenderer _entityClipboardRenderer;

libraries/animation/src/AnimationCache.cpp

@@ -36,7 +36,7 @@ AnimationPointer AnimationCache::getAnimation(const QUrl& url) {
 }
 
 QSharedPointer<Resource> AnimationCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-        bool delayLoad, const void* extra) {
+    const void* extra) {
     return QSharedPointer<Resource>(new Animation(url), &Resource::deleter);
 }
 

libraries/animation/src/AnimationCache.h

@@ -35,8 +35,8 @@ public:
 
 protected:
     
-    virtual QSharedPointer<Resource> createResource(const QUrl& url,
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-                const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra);
+        const void* extra);
 private:
     explicit AnimationCache(QObject* parent = NULL);
     virtual ~AnimationCache() { }

libraries/audio/src/SoundCache.cpp

@@ -35,7 +35,7 @@ SharedSoundPointer SoundCache::getSound(const QUrl& url) {
 }
 
 QSharedPointer<Resource> SoundCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-                                                    bool delayLoad, const void* extra) {
+    const void* extra) {
     qCDebug(audio) << "Requesting sound at" << url.toString();
     return QSharedPointer<Resource>(new Sound(url), &Resource::deleter);
 }

libraries/audio/src/SoundCache.h

@@ -25,8 +25,8 @@ public:
     Q_INVOKABLE SharedSoundPointer getSound(const QUrl& url);
     
 protected:
-    virtual QSharedPointer<Resource> createResource(const QUrl& url,
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-                                                    const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra);
+        const void* extra);
 private:
     SoundCache(QObject* parent = NULL);
 };

libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp

@@ -977,8 +977,8 @@ void RenderablePolyVoxEntityItem::compressVolumeDataAndSendEditPacket() {
             properties.setVoxelDataDirty();
             properties.setLastEdited(now);
 
-            EntitySimulation* simulation = tree ? tree->getSimulation() : nullptr;
+            EntitySimulationPointer simulation = tree ? tree->getSimulation() : nullptr;
-            PhysicalEntitySimulation* peSimulation = static_cast<PhysicalEntitySimulation*>(simulation);
+            PhysicalEntitySimulationPointer peSimulation = std::static_pointer_cast<PhysicalEntitySimulation>(simulation);
             EntityEditPacketSender* packetSender = peSimulation ? peSimulation->getPacketSender() : nullptr;
             if (packetSender) {
                 packetSender->queueEditEntityMessage(PacketType::EntityEdit, tree, entity->getID(), properties);

libraries/entities/src/EntityActionInterface.h

@@ -20,6 +20,8 @@ class EntityItem;
 class EntitySimulation;
 using EntityItemPointer = std::shared_ptr<EntityItem>;
 using EntityItemWeakPointer = std::weak_ptr<EntityItem>;
+class EntitySimulation;
+using EntitySimulationPointer = std::shared_ptr<EntitySimulation>;
 
 enum EntityActionType {
     // keep these synchronized with actionTypeFromString and actionTypeToString
@@ -39,7 +41,7 @@ public:
 
     bool isActive() { return _active; }
 
-    virtual void removeFromSimulation(EntitySimulation* simulation) const = 0;
+    virtual void removeFromSimulation(EntitySimulationPointer simulation) const = 0;
     virtual EntityItemWeakPointer getOwnerEntity() const = 0;
     virtual void setOwnerEntity(const EntityItemPointer ownerEntity) = 0;
     virtual bool updateArguments(QVariantMap arguments) = 0;

libraries/entities/src/EntityItem.cpp

@@ -89,7 +89,7 @@ EntityItem::EntityItem(const EntityItemID& entityItemID) :
 EntityItem::~EntityItem() {
     // clear out any left-over actions
     EntityTreePointer entityTree = _element ? _element->getTree() : nullptr;
-    EntitySimulation* simulation = entityTree ? entityTree->getSimulation() : nullptr;
+    EntitySimulationPointer simulation = entityTree ? entityTree->getSimulation() : nullptr;
     if (simulation) {
         clearActions(simulation);
     }
@@ -1736,7 +1736,7 @@ QString EntityItem::actionsToDebugString() {
     return result;
 }
 
-bool EntityItem::addAction(EntitySimulation* simulation, EntityActionPointer action) {
+bool EntityItem::addAction(EntitySimulationPointer simulation, EntityActionPointer action) {
     bool result;
     withWriteLock([&] {
         checkWaitingToRemove(simulation);
@@ -1753,7 +1753,7 @@ bool EntityItem::addAction(EntitySimulation* simulation, EntityActionPointer act
     return result;
 }
 
-bool EntityItem::addActionInternal(EntitySimulation* simulation, EntityActionPointer action) {
+bool EntityItem::addActionInternal(EntitySimulationPointer simulation, EntityActionPointer action) {
     assert(action);
     assert(simulation);
     auto actionOwnerEntity = action->getOwnerEntity().lock();
@@ -1777,7 +1777,7 @@ bool EntityItem::addActionInternal(EntitySimulation* simulation, EntityActionPoi
     return success;
 }
 
-bool EntityItem::updateAction(EntitySimulation* simulation, const QUuid& actionID, const QVariantMap& arguments) {
+bool EntityItem::updateAction(EntitySimulationPointer simulation, const QUuid& actionID, const QVariantMap& arguments) {
     bool success = false;
     withWriteLock([&] {
         checkWaitingToRemove(simulation);
@@ -1800,7 +1800,7 @@ bool EntityItem::updateAction(EntitySimulation* simulation, const QUuid& actionI
     return success;
 }
 
-bool EntityItem::removeAction(EntitySimulation* simulation, const QUuid& actionID) {
+bool EntityItem::removeAction(EntitySimulationPointer simulation, const QUuid& actionID) {
     bool success = false;
     withWriteLock([&] {
         checkWaitingToRemove(simulation);
@@ -1809,7 +1809,7 @@ bool EntityItem::removeAction(EntitySimulation* simulation, const QUuid& actionI
     return success;
 }
 
-bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulation* simulation) {
+bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulationPointer simulation) {
     _previouslyDeletedActions.insert(actionID, usecTimestampNow());
     if (_objectActions.contains(actionID)) {
         if (!simulation) {
@@ -1836,7 +1836,7 @@ bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulation* s
     return false;
 }
 
-bool EntityItem::clearActions(EntitySimulation* simulation) {
+bool EntityItem::clearActions(EntitySimulationPointer simulation) {
     withWriteLock([&] {
         QHash<QUuid, EntityActionPointer>::iterator i = _objectActions.begin();
         while (i != _objectActions.end()) {
@@ -1872,7 +1872,7 @@ void EntityItem::deserializeActionsInternal() {
 
     EntityTreePointer entityTree = getTree();
     assert(entityTree);
-    EntitySimulation* simulation = entityTree ? entityTree->getSimulation() : nullptr;
+    EntitySimulationPointer simulation = entityTree ? entityTree->getSimulation() : nullptr;
     assert(simulation);
 
     QVector<QByteArray> serializedActions;
@@ -1952,7 +1952,7 @@ void EntityItem::deserializeActionsInternal() {
     return;
 }
 
-void EntityItem::checkWaitingToRemove(EntitySimulation* simulation) {
+void EntityItem::checkWaitingToRemove(EntitySimulationPointer simulation) {
     foreach(QUuid actionID, _actionsToRemove) {
         removeActionInternal(actionID, simulation);
     }

libraries/entities/src/EntityItem.h

@@ -383,10 +383,10 @@ public:
     void flagForMotionStateChange() { _dirtyFlags |= Simulation::DIRTY_MOTION_TYPE; }
 
     QString actionsToDebugString();
-    bool addAction(EntitySimulation* simulation, EntityActionPointer action);
+    bool addAction(EntitySimulationPointer simulation, EntityActionPointer action);
-    bool updateAction(EntitySimulation* simulation, const QUuid& actionID, const QVariantMap& arguments);
+    bool updateAction(EntitySimulationPointer simulation, const QUuid& actionID, const QVariantMap& arguments);
-    bool removeAction(EntitySimulation* simulation, const QUuid& actionID);
+    bool removeAction(EntitySimulationPointer simulation, const QUuid& actionID);
-    bool clearActions(EntitySimulation* simulation);
+    bool clearActions(EntitySimulationPointer simulation);
     void setActionData(QByteArray actionData);
     const QByteArray getActionData() const;
     bool hasActions() const { return !_objectActions.empty(); }
@@ -529,8 +529,8 @@ protected:
     void* _physicsInfo = nullptr; // set by EntitySimulation
     bool _simulated; // set by EntitySimulation
 
-    bool addActionInternal(EntitySimulation* simulation, EntityActionPointer action);
+    bool addActionInternal(EntitySimulationPointer simulation, EntityActionPointer action);
-    bool removeActionInternal(const QUuid& actionID, EntitySimulation* simulation = nullptr);
+    bool removeActionInternal(const QUuid& actionID, EntitySimulationPointer simulation = nullptr);
     void deserializeActionsInternal();
     void serializeActions(bool& success, QByteArray& result) const;
     QHash<QUuid, EntityActionPointer> _objectActions;
@@ -541,7 +541,7 @@ protected:
     // when an entity-server starts up, EntityItem::setActionData is called before the entity-tree is
     // ready.  This means we can't find our EntityItemPointer or add the action to the simulation.  These
     // are used to keep track of and work around this situation.
-    void checkWaitingToRemove(EntitySimulation* simulation = nullptr);
+    void checkWaitingToRemove(EntitySimulationPointer simulation = nullptr);
     mutable QSet<QUuid> _actionsToRemove;
     mutable bool _actionDataDirty = false;
     mutable bool _actionDataNeedsTransmit = false;

libraries/entities/src/EntityScriptingInterface.cpp

@@ -777,7 +777,7 @@ bool EntityScriptingInterface::appendPoint(QUuid entityID, const glm::vec3& poin
 
 
 bool EntityScriptingInterface::actionWorker(const QUuid& entityID,
-                                            std::function<bool(EntitySimulation*, EntityItemPointer)> actor) {
+                                            std::function<bool(EntitySimulationPointer, EntityItemPointer)> actor) {
     if (!_entityTree) {
         return false;
     }
@@ -785,7 +785,7 @@ bool EntityScriptingInterface::actionWorker(const QUuid& entityID,
     EntityItemPointer entity;
     bool doTransmit = false;
     _entityTree->withWriteLock([&] {
-        EntitySimulation* simulation = _entityTree->getSimulation();
+        EntitySimulationPointer simulation = _entityTree->getSimulation();
         entity = _entityTree->findEntityByEntityItemID(entityID);
         if (!entity) {
             qDebug() << "actionWorker -- unknown entity" << entityID;
@@ -826,7 +826,7 @@ QUuid EntityScriptingInterface::addAction(const QString& actionTypeString,
     QUuid actionID = QUuid::createUuid();
     auto actionFactory = DependencyManager::get<EntityActionFactoryInterface>();
     bool success = false;
-    actionWorker(entityID, [&](EntitySimulation* simulation, EntityItemPointer entity) {
+    actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
             // create this action even if the entity doesn't have physics info.  it will often be the
             // case that a script adds an action immediately after an object is created, and the physicsInfo
             // is computed asynchronously.
@@ -854,7 +854,7 @@ QUuid EntityScriptingInterface::addAction(const QString& actionTypeString,
 
 
 bool EntityScriptingInterface::updateAction(const QUuid& entityID, const QUuid& actionID, const QVariantMap& arguments) {
-    return actionWorker(entityID, [&](EntitySimulation* simulation, EntityItemPointer entity) {
+    return actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
             bool success = entity->updateAction(simulation, actionID, arguments);
             if (success) {
                 entity->grabSimulationOwnership();
@@ -865,7 +865,7 @@ bool EntityScriptingInterface::updateAction(const QUuid& entityID, const QUuid&
 
 bool EntityScriptingInterface::deleteAction(const QUuid& entityID, const QUuid& actionID) {
     bool success = false;
-    actionWorker(entityID, [&](EntitySimulation* simulation, EntityItemPointer entity) {
+    actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
             success = entity->removeAction(simulation, actionID);
             if (success) {
                 // reduce from grab to poke
@@ -878,7 +878,7 @@ bool EntityScriptingInterface::deleteAction(const QUuid& entityID, const QUuid&
 
 QVector<QUuid> EntityScriptingInterface::getActionIDs(const QUuid& entityID) {
     QVector<QUuid> result;
-    actionWorker(entityID, [&](EntitySimulation* simulation, EntityItemPointer entity) {
+    actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
             QList<QUuid> actionIDs = entity->getActionIDs();
             result = QVector<QUuid>::fromList(actionIDs);
             return false; // don't send an edit packet
@@ -888,7 +888,7 @@ QVector<QUuid> EntityScriptingInterface::getActionIDs(const QUuid& entityID) {
 
 QVariantMap EntityScriptingInterface::getActionArguments(const QUuid& entityID, const QUuid& actionID) {
     QVariantMap result;
-    actionWorker(entityID, [&](EntitySimulation* simulation, EntityItemPointer entity) {
+    actionWorker(entityID, [&](EntitySimulationPointer simulation, EntityItemPointer entity) {
             result = entity->getActionArguments(actionID);
             return false; // don't send an edit packet
         });

libraries/entities/src/EntityScriptingInterface.h

@@ -200,11 +200,11 @@ signals:
     void debitEnergySource(float value);
 
 private:
-    bool actionWorker(const QUuid& entityID, std::function<bool(EntitySimulation*, EntityItemPointer)> actor);
+    bool actionWorker(const QUuid& entityID, std::function<bool(EntitySimulationPointer, EntityItemPointer)> actor);
     bool setVoxels(QUuid entityID, std::function<bool(PolyVoxEntityItem&)> actor);
     bool setPoints(QUuid entityID, std::function<bool(LineEntityItem&)> actor);
     void queueEntityMessage(PacketType packetType, EntityItemID entityID, const EntityItemProperties& properties);
-    
+
     EntityItemPointer checkForTreeEntityAndTypeMatch(const QUuid& entityID,
                                                      EntityTypes::EntityType entityType = EntityTypes::Unknown);
 

libraries/entities/src/EntitySimulation.cpp

@@ -64,7 +64,7 @@ void EntitySimulation::prepareEntityForDelete(EntityItemPointer entity) {
     assert(entity->isDead());
     if (entity->isSimulated()) {
         QMutexLocker lock(&_mutex);
-        entity->clearActions(this);
+        entity->clearActions(getThisPointer());
         removeEntityInternal(entity);
         _entitiesToDelete.insert(entity);
     }

libraries/entities/src/EntitySimulation.h

@@ -22,8 +22,9 @@
 #include "EntityItem.h"
 #include "EntityTree.h"
 
-typedef QSet<EntityItemPointer> SetOfEntities;
+using EntitySimulationPointer = std::shared_ptr<EntitySimulation>;
-typedef QVector<EntityItemPointer> VectorOfEntities;
+using SetOfEntities = QSet<EntityItemPointer>;
+using VectorOfEntities = QVector<EntityItemPointer>;
 
 // the EntitySimulation needs to know when these things change on an entity,
 // so it can sort EntityItem or relay its state to the PhysicsEngine.
@@ -41,12 +42,16 @@ const int DIRTY_SIMULATION_FLAGS =
         Simulation::DIRTY_MATERIAL |
         Simulation::DIRTY_SIMULATOR_ID;
 
-class EntitySimulation : public QObject {
+class EntitySimulation : public QObject, public std::enable_shared_from_this<EntitySimulation> {
 Q_OBJECT
 public:
     EntitySimulation() : _mutex(QMutex::Recursive), _entityTree(NULL), _nextExpiry(quint64(-1)) { }
     virtual ~EntitySimulation() { setEntityTree(NULL); }
 
+    inline EntitySimulationPointer getThisPointer() const {
+        return std::const_pointer_cast<EntitySimulation>(shared_from_this());
+    }
+
     /// \param tree pointer to EntityTree which is stored internally
     void setEntityTree(EntityTreePointer tree);
 

libraries/entities/src/EntityTree.cpp

@@ -365,7 +365,7 @@ void EntityTree::notifyNewCollisionSoundURL(const QString& newURL, const EntityI
     emit newCollisionSoundURL(QUrl(newURL), entityID);
 }
 
-void EntityTree::setSimulation(EntitySimulation* simulation) {
+void EntityTree::setSimulation(EntitySimulationPointer simulation) {
     this->withWriteLock([&] {
         if (simulation) {
             // assert that the simulation's backpointer has already been properly connected

libraries/entities/src/EntityTree.h

@@ -194,8 +194,8 @@ public:
 
     void emitEntityScriptChanging(const EntityItemID& entityItemID, const bool reload);
 
-    void setSimulation(EntitySimulation* simulation);
+    void setSimulation(EntitySimulationPointer simulation);
-    EntitySimulation* getSimulation() const { return _simulation; }
+    EntitySimulationPointer getSimulation() const { return _simulation; }
 
     bool wantEditLogging() const { return _wantEditLogging; }
     void setWantEditLogging(bool value) { _wantEditLogging = value; }
@@ -299,7 +299,7 @@ protected:
     mutable QReadWriteLock _entityToElementLock;
     QHash<EntityItemID, EntityTreeElementPointer> _entityToElementMap;
 
-    EntitySimulation* _simulation;
+    EntitySimulationPointer _simulation;
 
     bool _wantEditLogging = false;
     bool _wantTerseEditLogging = false;

libraries/entities/src/EntityTreeHeadlessViewer.cpp

@@ -22,7 +22,7 @@ EntityTreeHeadlessViewer::~EntityTreeHeadlessViewer() {
 void EntityTreeHeadlessViewer::init() {
     OctreeHeadlessViewer::init();
     if (!_simulation) {
-        SimpleEntitySimulation* simpleSimulation = new SimpleEntitySimulation();
+        SimpleEntitySimulationPointer simpleSimulation { new SimpleEntitySimulation() };
         EntityTreePointer entityTree = std::static_pointer_cast<EntityTree>(_tree);
         simpleSimulation->setEntityTree(entityTree);
         entityTree->setSimulation(simpleSimulation);

libraries/entities/src/EntityTreeHeadlessViewer.h

@@ -49,7 +49,7 @@ protected:
         return newTree;
     }
 
-    EntitySimulation* _simulation;
+    EntitySimulationPointer _simulation;
 };
 
 #endif // hifi_EntityTreeHeadlessViewer_h

libraries/entities/src/SimpleEntitySimulation.h

@@ -14,6 +14,10 @@
 
 #include "EntitySimulation.h"
 
+class SimpleEntitySimulation;
+using SimpleEntitySimulationPointer = std::shared_ptr<SimpleEntitySimulation>;
+
+
 /// provides simple velocity + gravity extrapolation of EntityItem's
 
 class SimpleEntitySimulation : public EntitySimulation {

libraries/model-networking/src/model-networking/ModelCache.cpp

@@ -71,7 +71,7 @@ void GeometryMappingResource::downloadFinished(const QByteArray& data) {
         GeometryExtra extra{ mapping, _textureBaseUrl };
 
         // Get the raw GeometryResource, not the wrapped NetworkGeometry
-        _geometryResource = modelCache->getResource(url, QUrl(), false, &extra).staticCast<GeometryResource>();
+        _geometryResource = modelCache->getResource(url, QUrl(), &extra).staticCast<GeometryResource>();
         // Avoid caching nested resources - their references will be held by the parent
         _geometryResource->_isCacheable = false;
 
@@ -236,7 +236,7 @@ ModelCache::ModelCache() {
 }
 
 QSharedPointer<Resource> ModelCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-                                                    bool delayLoad, const void* extra) {
+    const void* extra) {
     Resource* resource = nullptr;
     if (url.path().toLower().endsWith(".fst")) {
         resource = new GeometryMappingResource(url);
@@ -252,7 +252,7 @@ QSharedPointer<Resource> ModelCache::createResource(const QUrl& url, const QShar
 
 std::shared_ptr<NetworkGeometry> ModelCache::getGeometry(const QUrl& url, const QVariantHash& mapping, const QUrl& textureBaseUrl) {
     GeometryExtra geometryExtra = { mapping, textureBaseUrl };
-    GeometryResource::Pointer resource = getResource(url, QUrl(), true, &geometryExtra).staticCast<GeometryResource>();
+    GeometryResource::Pointer resource = getResource(url, QUrl(), &geometryExtra).staticCast<GeometryResource>();
     if (resource) {
         if (resource->isLoaded() && resource->shouldSetTextures()) {
             resource->setTextures();

libraries/model-networking/src/model-networking/ModelCache.h

@@ -44,8 +44,8 @@ public:
 protected:
     friend class GeometryMappingResource;
 
-    virtual QSharedPointer<Resource> createResource(const QUrl& url,
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-        const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra);
+        const void* extra);
 
 private:
     ModelCache();

libraries/model-networking/src/model-networking/ShaderCache.cpp

@@ -7,11 +7,8 @@
 //
 #include "ShaderCache.h"
 
-NetworkShader::NetworkShader(const QUrl& url, bool delayLoad)
+NetworkShader::NetworkShader(const QUrl& url) :
-    : Resource(url, delayLoad)
+    Resource(url) {}
-{
-    
-}
 
 void NetworkShader::downloadFinished(const QByteArray& data) {
     _source = QString::fromUtf8(data);
@@ -24,10 +21,11 @@ ShaderCache& ShaderCache::instance() {
 }
 
 NetworkShaderPointer ShaderCache::getShader(const QUrl& url) {
-    return ResourceCache::getResource(url, QUrl(), false, nullptr).staticCast<NetworkShader>();
+    return ResourceCache::getResource(url, QUrl(), nullptr).staticCast<NetworkShader>();
 }
 
-QSharedPointer<Resource> ShaderCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) {
+QSharedPointer<Resource> ShaderCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-    return QSharedPointer<Resource>(new NetworkShader(url, delayLoad), &Resource::deleter);
+    const void* extra) {
+    return QSharedPointer<Resource>(new NetworkShader(url), &Resource::deleter);
 }
 

libraries/model-networking/src/model-networking/ShaderCache.h

@@ -13,7 +13,7 @@
 
 class NetworkShader : public Resource {
 public:
-    NetworkShader(const QUrl& url, bool delayLoad);
+    NetworkShader(const QUrl& url);
     virtual void downloadFinished(const QByteArray& data) override;
 
     QString _source;
@@ -28,7 +28,8 @@ public:
     NetworkShaderPointer getShader(const QUrl& url);
 
 protected:
-    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) override;
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
+        const void* extra) override;
 };
 
 #endif

libraries/model-networking/src/model-networking/TextureCache.cpp

@@ -167,7 +167,7 @@ ScriptableResource* TextureCache::prefetch(const QUrl& url, int type) {
 
 NetworkTexturePointer TextureCache::getTexture(const QUrl& url, Type type, const QByteArray& content) {
     TextureExtra extra = { type, content };
-    return ResourceCache::getResource(url, QUrl(), content.isEmpty(), &extra).staticCast<NetworkTexture>();
+    return ResourceCache::getResource(url, QUrl(), &extra).staticCast<NetworkTexture>();
 }
 
 
@@ -231,8 +231,8 @@ gpu::TexturePointer TextureCache::getImageTexture(const QString& path, Type type
     return gpu::TexturePointer(loader(image, QUrl::fromLocalFile(path).fileName().toStdString()));
 }
 
-QSharedPointer<Resource> TextureCache::createResource(const QUrl& url,
+QSharedPointer<Resource> TextureCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-        const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) {
+    const void* extra) {
     const TextureExtra* textureExtra = static_cast<const TextureExtra*>(extra);
     auto type = textureExtra ? textureExtra->type : Type::DEFAULT_TEXTURE;
     auto content = textureExtra ? textureExtra->content : QByteArray();
@@ -241,7 +241,7 @@ QSharedPointer<Resource> TextureCache::createResource(const QUrl& url,
 }
 
 NetworkTexture::NetworkTexture(const QUrl& url, Type type, const QByteArray& content) :
-    Resource(url, !content.isEmpty()),
+    Resource(url),
     _type(type)
 {
     _textureSource = std::make_shared<gpu::TextureSource>();

libraries/model-networking/src/model-networking/TextureCache.h

@@ -131,8 +131,8 @@ protected:
     // Overload ResourceCache::prefetch to allow specifying texture type for loads
     Q_INVOKABLE ScriptableResource* prefetch(const QUrl& url, int type);
 
-    virtual QSharedPointer<Resource> createResource(const QUrl& url,
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-        const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra);
+        const void* extra);
         
 private:
     TextureCache();

libraries/networking/src/ResourceCache.cpp

@@ -179,7 +179,7 @@ ScriptableResource* ResourceCache::prefetch(const QUrl& url, void* extra) {
 
     result = new ScriptableResource(url);
 
-    auto resource = getResource(url, QUrl(), false, extra);
+    auto resource = getResource(url, QUrl(), extra);
     result->_resource = resource;
     result->setObjectName(url.toString());
 
@@ -316,25 +316,7 @@ void ResourceCache::setRequestLimit(int limit) {
     }
 }
 
-void ResourceCache::getResourceAsynchronously(const QUrl& url) {
+QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl& fallback, void* extra) {
-    qCDebug(networking) << "ResourceCache::getResourceAsynchronously" << url.toString();
-    QWriteLocker locker(&_resourcesToBeGottenLock);
-    _resourcesToBeGotten.enqueue(QUrl(url));
-}
-
-void ResourceCache::checkAsynchronousGets() {
-    assert(QThread::currentThread() == thread());
-    QWriteLocker locker(&_resourcesToBeGottenLock);
-    if (!_resourcesToBeGotten.isEmpty()) {
-        QUrl url = _resourcesToBeGotten.dequeue();
-
-        locker.unlock();
-        getResource(url);
-    }
-}
-
-QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl& fallback,
-                                                    bool delayLoad, void* extra) {
     QSharedPointer<Resource> resource;
     {
         QReadLocker locker(&_resourcesLock);
@@ -346,17 +328,21 @@ QSharedPointer<Resource> ResourceCache::getResource(const QUrl& url, const QUrl&
     }
 
     if (QThread::currentThread() != thread()) {
-        assert(delayLoad);
+        qCDebug(networking) << "Fetching asynchronously:" << url;
-        getResourceAsynchronously(url);
+        QMetaObject::invokeMethod(this, "getResource",
+            Q_ARG(QUrl, url), Q_ARG(QUrl, fallback));
+            // Cannot use extra parameter as it might be freed before the invocation
         return QSharedPointer<Resource>();
     }
 
     if (!url.isValid() && !url.isEmpty() && fallback.isValid()) {
-        return getResource(fallback, QUrl(), delayLoad);
+        return getResource(fallback, QUrl());
     }
 
-    resource = createResource(url, fallback.isValid() ?
+    resource = createResource(
-                              getResource(fallback, QUrl(), true) : QSharedPointer<Resource>(), delayLoad, extra);
+        url,
+        fallback.isValid() ?  getResource(fallback, QUrl()) : QSharedPointer<Resource>(),
+        extra);
     resource->setSelf(resource);
     resource->setCache(this);
     connect(resource.data(), &Resource::updateSize, this, &ResourceCache::updateTotalSize);
@@ -508,7 +494,7 @@ const int DEFAULT_REQUEST_LIMIT = 10;
 int ResourceCache::_requestLimit = DEFAULT_REQUEST_LIMIT;
 int ResourceCache::_requestsActive = 0;
 
-Resource::Resource(const QUrl& url, bool delayLoad) :
+Resource::Resource(const QUrl& url) :
     _url(url),
     _activeUrl(url),
     _request(nullptr) {

libraries/networking/src/ResourceCache.h

@@ -179,9 +179,6 @@ public:
 signals:
     void dirty();
 
-public slots:
-    void checkAsynchronousGets();
-
 protected slots:
     void updateTotalSize(const qint64& deltaSize);
 
@@ -190,6 +187,14 @@ protected slots:
     // and delegate to it (see TextureCache::prefetch(const QUrl&, int).
     ScriptableResource* prefetch(const QUrl& url, void* extra);
 
+    /// Loads a resource from the specified URL and returns it.
+    /// If the caller is on a different thread than the ResourceCache,
+    /// returns an empty smart pointer and loads its asynchronously.
+    /// \param fallback a fallback URL to load if the desired one is unavailable
+    /// \param extra extra data to pass to the creator, if appropriate
+    QSharedPointer<Resource> getResource(const QUrl& url, const QUrl& fallback = QUrl(),
+        void* extra = NULL);
+
 private slots:
     void clearATPAssets();
 
@@ -200,16 +205,9 @@ protected:
     // the QScriptEngine will delete the pointer when it is garbage collected.
     Q_INVOKABLE ScriptableResource* prefetch(const QUrl& url) { return prefetch(url, nullptr); }
 
-    /// Loads a resource from the specified URL.
-    /// \param fallback a fallback URL to load if the desired one is unavailable
-    /// \param delayLoad if true, don't load the resource immediately; wait until load is first requested
-    /// \param extra extra data to pass to the creator, if appropriate
-    QSharedPointer<Resource> getResource(const QUrl& url, const QUrl& fallback = QUrl(),
-                                                     bool delayLoad = false, void* extra = NULL);
-
     /// Creates a new resource.
-    virtual QSharedPointer<Resource> createResource(const QUrl& url,
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback,
-        const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) = 0;
+        const void* extra) = 0;
     
     void addUnusedResource(const QSharedPointer<Resource>& resource);
     void removeUnusedResource(const QSharedPointer<Resource>& resource);
@@ -260,7 +258,7 @@ class Resource : public QObject {
 
 public:
     
-    Resource(const QUrl& url, bool delayLoad = false);
+    Resource(const QUrl& url);
     ~Resource();
     
     /// Returns the key last used to identify this resource in the unused map.

libraries/physics/src/ObjectAction.cpp

@@ -138,7 +138,7 @@ QVariantMap ObjectAction::getArguments() {
 void ObjectAction::debugDraw(btIDebugDraw* debugDrawer) {
 }
 
-void ObjectAction::removeFromSimulation(EntitySimulation* simulation) const {
+void ObjectAction::removeFromSimulation(EntitySimulationPointer simulation) const {
     QUuid myID;
     withReadLock([&]{
         myID = _id;

libraries/physics/src/ObjectAction.h

@@ -29,7 +29,7 @@ public:
     ObjectAction(EntityActionType type, const QUuid& id, EntityItemPointer ownerEntity);
     virtual ~ObjectAction();
 
-    virtual void removeFromSimulation(EntitySimulation* simulation) const override;
+    virtual void removeFromSimulation(EntitySimulationPointer simulation) const override;
     virtual EntityItemWeakPointer getOwnerEntity() const override { return _ownerEntity; }
     virtual void setOwnerEntity(const EntityItemPointer ownerEntity) override { _ownerEntity = ownerEntity; }
 

libraries/physics/src/PhysicalEntitySimulation.cpp

@@ -156,7 +156,7 @@ void PhysicalEntitySimulation::clearEntitiesInternal() {
 void PhysicalEntitySimulation::prepareEntityForDelete(EntityItemPointer entity) {
     assert(entity);
     assert(entity->isDead());
-    entity->clearActions(this);
+    entity->clearActions(getThisPointer());
     removeEntityInternal(entity);
 }
 // end EntitySimulation overrides

libraries/physics/src/PhysicalEntitySimulation.h

@@ -23,7 +23,9 @@
 #include "PhysicsEngine.h"
 #include "EntityMotionState.h"
 
-typedef QSet<EntityMotionState*> SetOfEntityMotionStates;
+class PhysicalEntitySimulation;
+using PhysicalEntitySimulationPointer = std::shared_ptr<PhysicalEntitySimulation>;
+using SetOfEntityMotionStates = QSet<EntityMotionState*>;
 
 class PhysicalEntitySimulation :public EntitySimulation {
 public:

libraries/recording/src/recording/ClipCache.cpp

@@ -9,12 +9,9 @@
 #include "impl/PointerClip.h"
 
 using namespace recording;
-NetworkClipLoader::NetworkClipLoader(const QUrl& url, bool delayLoad)
+NetworkClipLoader::NetworkClipLoader(const QUrl& url) :
-    : Resource(url, delayLoad), _clip(std::make_shared<NetworkClip>(url))
+    Resource(url),
-{
+    _clip(std::make_shared<NetworkClip>(url)) {}
-    
-}
-
 
 void NetworkClip::init(const QByteArray& clipData) {
     _clipData = clipData;
@@ -32,10 +29,10 @@ ClipCache& ClipCache::instance() {
 }
 
 NetworkClipLoaderPointer ClipCache::getClipLoader(const QUrl& url) {
-    return ResourceCache::getResource(url, QUrl(), false, nullptr).staticCast<NetworkClipLoader>();
+    return ResourceCache::getResource(url, QUrl(), nullptr).staticCast<NetworkClipLoader>();
 }
 
-QSharedPointer<Resource> ClipCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) {
+QSharedPointer<Resource> ClipCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, const void* extra) {
-    return QSharedPointer<Resource>(new NetworkClipLoader(url, delayLoad), &Resource::deleter);
+    return QSharedPointer<Resource>(new NetworkClipLoader(url), &Resource::deleter);
 }
 

libraries/recording/src/recording/ClipCache.h

@@ -31,7 +31,7 @@ private:
 
 class NetworkClipLoader : public Resource {
 public:
-    NetworkClipLoader(const QUrl& url, bool delayLoad);
+    NetworkClipLoader(const QUrl& url);
     virtual void downloadFinished(const QByteArray& data) override;
     ClipPointer getClip() { return _clip; }
     bool completed() { return _failedToLoad || isLoaded(); }
@@ -49,7 +49,7 @@ public:
     NetworkClipLoaderPointer getClipLoader(const QUrl& url);
 
 protected:
-    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) override;
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, const void* extra) override;
 };
 
 }