Merge branch 'master' of github.com:highfidelity/hifi into account-managed-wallet-punchlist2

2025-08-12 22:13:13 +02:00 · 2018-09-26 15:26:52 -07:00 · 2018-09-26 15:26:52 -07:00 · da5f77afcd
commit da5f77afcd
parent 6e2a7c280e 70c7ffcc71
51 changed files with 1095 additions and 536 deletions
--- a/interface/resources/qml/hifi/commerce/marketplaceItemTester/MarketplaceItemTester.qml
+++ b/interface/resources/qml/hifi/commerce/marketplaceItemTester/MarketplaceItemTester.qml
@ -0,0 +1,290 @@
+//
+//  marketplaceItemTester
+//  qml/hifi/commerce/marketplaceItemTester
+//
+//  Load items not in the marketplace for testing purposes
+//
+//  Created by Zach Fox on 2018-09-05
+//  Copyright 2018 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
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtQuick.Controls.Styles 1.4
+import QtQuick.Dialogs 1.0
+import QtQuick.Layouts 1.1
+import Hifi 1.0 as Hifi
+import "../../../styles-uit" as HifiStylesUit
+import "../../../controls-uit" as HifiControlsUit
+
+
+
+Rectangle {
+    id: root
+
+    property string installedApps
+    property var nextResourceObjectId: 0
+    signal sendToScript(var message)
+
+    HifiStylesUit.HifiConstants { id: hifi }
+    ListModel { id: resourceListModel }
+
+    color: hifi.colors.white
+
+    AnimatedImage {
+        id: spinner;
+        source: "spinner.gif"
+        width: 74;
+        height: width;
+        anchors.verticalCenter: parent.verticalCenter;
+        anchors.horizontalCenter: parent.horizontalCenter;
+    }
+
+    function fromScript(message) {
+        switch (message.method) {
+            case "newResourceObjectInTest":
+                var resourceObject = message.resourceObject;
+                resourceListModel.append(resourceObject);
+                spinner.visible = false;
+                break;
+            case "nextObjectIdInTest":
+                nextResourceObjectId = message.id;
+                spinner.visible = false;
+                break;
+        }
+    }
+
+    function buildResourceObj(resource) {
+        resource = resource.trim();
+        var assetType = (resource.match(/\.app\.json$/) ? "application" :
+                         resource.match(/\.fst$/) ? "avatar" :
+                         resource.match(/\.json\.gz$/) ? "content set" :
+                         resource.match(/\.json$/) ? "entity or wearable" :
+                         "unknown");
+        return { "id": nextResourceObjectId++,
+                 "resource": resource,
+                 "assetType": assetType };
+    }
+
+    function installResourceObj(resourceObj) {
+        if ("application" === resourceObj.assetType) {
+            Commerce.installApp(resourceObj.resource);
+        }
+    }
+
+    function addAllInstalledAppsToList() {
+        var i, apps = Commerce.getInstalledApps().split(","), len = apps.length;
+        for(i = 0; i < len - 1; ++i) {
+            if (i in apps) {
+                resourceListModel.append(buildResourceObj(apps[i]));
+            }
+        }
+    }
+
+    function toUrl(resource) {
+        var httpPattern = /^http/i;
+        return httpPattern.test(resource) ? resource : "file:///" + resource;
+    }
+
+    function rezEntity(resource, entityType) {
+        sendToScript({
+            method: 'tester_rezClicked',
+            itemHref: toUrl(resource),
+            itemType: entityType});
+    }
+
+    ListView {
+        anchors.fill: parent
+        anchors.leftMargin: 12
+        anchors.bottomMargin: 40
+        anchors.rightMargin: 12
+        model: resourceListModel
+        spacing: 5
+        interactive: false
+
+        delegate: RowLayout {
+            anchors.left: parent.left
+            width: parent.width
+            spacing: 5
+
+            property var actions: {
+                "forward": function(resource, assetType){
+                    switch(assetType) {
+                        case "application":
+                            Commerce.openApp(resource);
+                            break;
+                        case "avatar":
+                            MyAvatar.useFullAvatarURL(resource);
+                            break;
+                        case "content set":
+                            urlHandler.handleUrl("hifi://localhost/0,0,0");
+                            Commerce.replaceContentSet(toUrl(resource), "");
+                            break;
+                        case "entity":
+                        case "wearable":
+                            rezEntity(resource, assetType);
+                            break;
+                        default:
+                            print("Marketplace item tester unsupported assetType " + assetType);
+                    }
+                },
+                "trash": function(){
+                    if ("application" === assetType) {
+                        Commerce.uninstallApp(resource);
+                    }
+                    sendToScript({
+                        method: "tester_deleteResourceObject",
+                        objectId: resourceListModel.get(index).id});
+                    resourceListModel.remove(index);
+                }
+            }
+
+            Column {
+                Layout.preferredWidth: root.width * .6
+                spacing: 5
+                Text {
+                    text: {
+                        var match = resource.match(/\/([^/]*)$/);
+                        return match ? match[1] : resource;
+                    }
+                    font.pointSize: 12
+                    horizontalAlignment: Text.AlignBottom
+                }
+                Text {
+                    text: resource
+                    font.pointSize: 8
+                    width: root.width * .6
+                    horizontalAlignment: Text.AlignBottom
+                    wrapMode: Text.WrapAnywhere
+                }
+            }
+
+            ComboBox {
+                id: comboBox
+
+                Layout.preferredWidth: root.width * .2
+
+                model: [
+                    "application",
+                    "avatar",
+                    "content set",
+                    "entity",
+                    "wearable",
+                    "unknown"
+                ]
+
+                currentIndex: (("entity or wearable" === assetType) ?
+                    model.indexOf("unknown") : model.indexOf(assetType))
+
+                Component.onCompleted: {
+                    onCurrentIndexChanged.connect(function() {
+                        assetType = model[currentIndex];
+                        sendToScript({
+                            method: "tester_updateResourceObjectAssetType",
+                            objectId: resourceListModel.get(index)["id"],
+                            assetType: assetType });
+                    });
+                }
+            }
+
+            Repeater {
+                model: [ "forward", "trash" ]
+
+                HifiStylesUit.HiFiGlyphs {
+                    property var glyphs: {
+                        "application": hifi.glyphs.install,
+                        "avatar": hifi.glyphs.avatar,
+                        "content set": hifi.glyphs.globe,
+                        "entity": hifi.glyphs.wand,
+                        "trash": hifi.glyphs.trash,
+                        "unknown": hifi.glyphs.circleSlash,
+                        "wearable": hifi.glyphs.hat,
+                    }
+                    text: (("trash" === modelData) ?
+                        glyphs.trash :
+                        glyphs[comboBox.model[comboBox.currentIndex]])
+                    size: ("trash" === modelData) ? 22 : 30
+                    color: hifi.colors.black
+                    horizontalAlignment: Text.AlignHCenter
+                    MouseArea {
+                        anchors.fill: parent
+                        onClicked: {
+                            actions[modelData](resource, comboBox.currentText);
+                        }
+                    }
+                }
+            }
+        }
+
+        headerPositioning: ListView.OverlayHeader
+        header: HifiStylesUit.RalewayRegular {
+            id: rootHeader
+            text: "Marketplace Item Tester"
+            height: 80
+            width: paintedWidth
+            size: 22
+            color: hifi.colors.black
+            anchors.left: parent.left
+            anchors.leftMargin: 12
+        }
+
+        footerPositioning: ListView.OverlayFooter
+        footer: Row {
+            id: rootActions
+            spacing: 20
+            anchors.horizontalCenter: parent.horizontalCenter
+
+            property string currentAction
+            property var actions: {
+                "Load File": function(){
+                    rootActions.currentAction = "load file";
+                    Window.browseChanged.connect(onResourceSelected);
+                    Window.browseAsync("Please select a file (*.app.json *.json *.fst *.json.gz)", "", "Assets (*.app.json *.json *.fst *.json.gz)");
+                },
+                "Load URL": function(){
+                    rootActions.currentAction = "load url";
+                    Window.promptTextChanged.connect(onResourceSelected);
+                    Window.promptAsync("Please enter a URL", "");
+                }
+            }
+
+            function onResourceSelected(resource) {
+                // It is possible that we received the present signal
+                // from something other than our browserAsync window.
+                // Alas, there is nothing we can do about that so charge
+                // ahead as though we are sure the present signal is one
+                // we expect.
+                switch(currentAction) {
+                    case "load file":
+                        Window.browseChanged.disconnect(onResourceSelected);
+                        break
+                    case "load url":
+                        Window.promptTextChanged.disconnect(onResourceSelected);
+                        break;
+                }
+                if (resource) {
+                    var resourceObj = buildResourceObj(resource);
+                    installResourceObj(resourceObj);
+                    sendToScript({
+                        method: 'tester_newResourceObject',
+                        resourceObject: resourceObj });
+                }
+            }
+
+            Repeater {
+                model: [ "Load File", "Load URL" ]
+                HifiControlsUit.Button {
+                    color: hifi.buttons.blue
+                    fontSize: 20
+                    text: modelData
+                    width: root.width / 3
+                    height: 40
+                    onClicked: actions[text]()
+                }
+            }
+        }
+    }
+}
--- a/interface/resources/qml/hifi/commerce/marketplaceItemTester/spinner.gif
+++ b/interface/resources/qml/hifi/commerce/marketplaceItemTester/spinner.gif
--- a/interface/resources/qml/hifi/commerce/purchases/PurchasedItem.qml
+++ b/interface/resources/qml/hifi/commerce/purchases/PurchasedItem.qml
@ -59,7 +59,7 @@ Item {

    Connections {
        target: Commerce;
-        
+
        onContentSetChanged: {
            if (contentSetHref === root.itemHref) {
                showConfirmation = true;
@ -135,7 +135,7 @@ Item {
                anchors.topMargin: 8;
                width: 30;
                height: width;
-            
+
                HiFiGlyphs {
                    id: closeContextMenuGlyph;
                    text: hifi.glyphs.close;
@ -376,7 +376,7 @@ Item {
                }
            }
        }
-        
+
        transform: Rotation {
            id: rotation;
            origin.x: flipable.width/2;
@ -509,7 +509,7 @@ Item {
                    }
                verticalAlignment: Text.AlignTop;
            }
-        
+
            HiFiGlyphs {
                id: statusIcon;
                text: {
@ -588,7 +588,7 @@ Item {
                border.width: 1;
                border.color: "#E2334D";
            }
-            
+
            HiFiGlyphs {
                id: contextMenuGlyph;
                text: hifi.glyphs.verticalEllipsis;
@ -615,7 +615,7 @@ Item {
                }
            }
        }
-        
+
        Rectangle {
            id: rezzedNotifContainer;
            z: 998;
@ -663,13 +663,13 @@ Item {
                    Tablet.playSound(TabletEnums.ButtonHover);
                }
            }
-    
+
            onFocusChanged: {
                if (focus) {
                    Tablet.playSound(TabletEnums.ButtonHover);
                }
            }
-            
+
            onClicked: {
                Tablet.playSound(TabletEnums.ButtonClick);
                if (root.itemType === "contentSet") {
@ -775,7 +775,7 @@ Item {
            // Style
            color: hifi.colors.redAccent;
            horizontalAlignment: Text.AlignRight;
-            
+
            MouseArea {
                anchors.fill: parent;
                hoverEnabled: true;
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@ -1691,21 +1691,21 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
        return DependencyManager::get<OffscreenUi>()->navigationFocused() ? 1 : 0;
    });
    _applicationStateDevice->setInputVariant(STATE_PLATFORM_WINDOWS, []() -> float {
-#if defined(Q_OS_WIN) 
+#if defined(Q_OS_WIN)
        return 1;
 #else
        return 0;
 #endif
    });
    _applicationStateDevice->setInputVariant(STATE_PLATFORM_MAC, []() -> float {
-#if defined(Q_OS_MAC) 
+#if defined(Q_OS_MAC)
        return 1;
 #else
        return 0;
 #endif
    });
    _applicationStateDevice->setInputVariant(STATE_PLATFORM_ANDROID, []() -> float {
-#if defined(Q_OS_ANDROID) 
+#if defined(Q_OS_ANDROID)
        return 1;
 #else
        return 0;
@ -1759,10 +1759,12 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo

    // Make sure we don't time out during slow operations at startup
    updateHeartbeat();
-
    QTimer* settingsTimer = new QTimer();
    moveToNewNamedThread(settingsTimer, "Settings Thread", [this, settingsTimer]{
-        connect(qApp, &Application::beforeAboutToQuit, [this, settingsTimer]{
+        // This needs to run on the settings thread, so we need to pass the `settingsTimer` as the 
+        // receiver object, otherwise it will run on the application thread and trigger a warning
+        // about trying to kill the timer on the main thread.
+        connect(qApp, &Application::beforeAboutToQuit, settingsTimer, [this, settingsTimer]{
            // Disconnect the signal from the save settings
            QObject::disconnect(settingsTimer, &QTimer::timeout, this, &Application::saveSettings);
            // Stop the settings timer
@ -2881,9 +2883,10 @@ void Application::initializeUi() {
        QUrl{ "hifi/commerce/common/CommerceLightbox.qml" },
        QUrl{ "hifi/commerce/common/EmulatedMarketplaceHeader.qml" },
        QUrl{ "hifi/commerce/common/FirstUseTutorial.qml" },
-        QUrl{ "hifi/commerce/common/SortableListModel.qml" },
        QUrl{ "hifi/commerce/common/sendAsset/SendAsset.qml" },
+        QUrl{ "hifi/commerce/common/SortableListModel.qml" },
        QUrl{ "hifi/commerce/inspectionCertificate/InspectionCertificate.qml" },
+        QUrl{ "hifi/commerce/marketplaceItemTester/MarketplaceItemTester.qml"},
        QUrl{ "hifi/commerce/purchases/PurchasedItem.qml" },
        QUrl{ "hifi/commerce/purchases/Purchases.qml" },
        QUrl{ "hifi/commerce/wallet/Help.qml" },
@ -3498,13 +3501,14 @@ bool Application::isServerlessMode() const {
 }

 void Application::setIsInterstitialMode(bool interstitialMode) {
-    Settings settings;
-    bool enableInterstitial = settings.value("enableIntersitialMode", false).toBool();
-    if (_interstitialMode != interstitialMode && enableInterstitial) {
-        _interstitialMode = interstitialMode;
+    bool enableInterstitial = DependencyManager::get<NodeList>()->getDomainHandler().getInterstitialModeEnabled();
+    if (enableInterstitial) {
+        if (_interstitialMode != interstitialMode) {
+            _interstitialMode = interstitialMode;

-        DependencyManager::get<AudioClient>()->setAudioPaused(_interstitialMode);
-        DependencyManager::get<AvatarManager>()->setMyAvatarDataPacketsPaused(_interstitialMode);
+            DependencyManager::get<AudioClient>()->setAudioPaused(_interstitialMode);
+            DependencyManager::get<AvatarManager>()->setMyAvatarDataPacketsPaused(_interstitialMode);
+        }
    }
 }

--- a/interface/src/Application.h
+++ b/interface/src/Application.h
@ -432,7 +432,7 @@ public slots:

    void setIsServerlessMode(bool serverlessDomain);
    void loadServerlessDomain(QUrl domainURL, bool errorDomain = false);
-    void setIsInterstitialMode(bool interstialMode);
+    void setIsInterstitialMode(bool interstitialMode);

    void updateVerboseLogging();

--- a/interface/src/ConnectionMonitor.cpp
+++ b/interface/src/ConnectionMonitor.cpp
@ -41,9 +41,15 @@ void ConnectionMonitor::init() {
    }

    connect(&_timer, &QTimer::timeout, this, [this]() {
-        qDebug() << "ConnectionMonitor: Redirecting to 404 error domain";
        // set in a timeout error
-        emit setRedirectErrorState(REDIRECT_HIFI_ADDRESS, 5);
+        bool enableInterstitial = DependencyManager::get<NodeList>()->getDomainHandler().getInterstitialModeEnabled();
+        if (enableInterstitial) {
+            qDebug() << "ConnectionMonitor: Redirecting to 404 error domain";
+            emit setRedirectErrorState(REDIRECT_HIFI_ADDRESS, "", 5);
+        } else {
+            qDebug() << "ConnectionMonitor: Showing connection failure window";
+            DependencyManager::get<DialogsManager>()->setDomainConnectionFailureVisibility(true);
+        }
    });
 }

@ -53,4 +59,8 @@ void ConnectionMonitor::startTimer() {

 void ConnectionMonitor::stopTimer() {
    _timer.stop();
+    bool enableInterstitial = DependencyManager::get<NodeList>()->getDomainHandler().getInterstitialModeEnabled();
+    if (!enableInterstitial) {
+        DependencyManager::get<DialogsManager>()->setDomainConnectionFailureVisibility(false);
+    }
 }
--- a/interface/src/ConnectionMonitor.h
+++ b/interface/src/ConnectionMonitor.h
@ -24,7 +24,7 @@ public:
    void init();

 signals:
-    void setRedirectErrorState(QUrl errorURL, int reasonCode);
+    void setRedirectErrorState(QUrl errorURL, QString reasonMessage = "", int reasonCode = -1, const QString& extraInfo = "");

 private slots:
    void startTimer();
@ -34,4 +34,4 @@ private:
    QTimer _timer;
 };

-#endif // hifi_ConnectionMonitor_h
+#endif // hifi_ConnectionMonitor_h
--- a/interface/src/avatar/AvatarManager.cpp
+++ b/interface/src/avatar/AvatarManager.cpp
@ -234,11 +234,13 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
        const SortableAvatar& sortData = *it;
        const auto avatar = std::static_pointer_cast<OtherAvatar>(sortData.getAvatar());

-        // TODO: to help us scale to more avatars it would be nice to not have to poll orb state here
-        // if the geometry is loaded then turn off the orb
+        // TODO: to help us scale to more avatars it would be nice to not have to poll this stuff every update
        if (avatar->getSkeletonModel()->isLoaded()) {
            // remove the orb if it is there
            avatar->removeOrb();
+            if (avatar->needsPhysicsUpdate()) {
+                _avatarsToChangeInPhysics.insert(avatar);
+            }
        } else {
            avatar->updateOrbPosition();
        }
@ -456,31 +458,37 @@ void AvatarManager::handleRemovedAvatar(const AvatarSharedPointer& removedAvatar
 }

 void AvatarManager::clearOtherAvatars() {
-    // Remove other avatars from the world but don't actually remove them from _avatarHash
-    // each will either be removed on timeout or will re-added to the world on receipt of update.
-    const render::ScenePointer& scene = qApp->getMain3DScene();
-    render::Transaction transaction;
-
-    QReadLocker locker(&_hashLock);
-    AvatarHash::iterator avatarIterator =  _avatarHash.begin();
-    while (avatarIterator != _avatarHash.end()) {
-        auto avatar = std::static_pointer_cast<Avatar>(avatarIterator.value());
-        if (avatar != _myAvatar) {
-            handleRemovedAvatar(avatar);
-            avatarIterator = _avatarHash.erase(avatarIterator);
-        } else {
-            ++avatarIterator;
-        }
-    }
-    assert(scene);
-    scene->enqueueTransaction(transaction);
    _myAvatar->clearLookAtTargetAvatar();
+
+    // setup a vector of removed avatars outside the scope of the hash lock
+    std::vector<AvatarSharedPointer> removedAvatars;
+
+    {
+        QWriteLocker locker(&_hashLock);
+
+        removedAvatars.reserve(_avatarHash.size());
+
+        auto avatarIterator =  _avatarHash.begin();
+        while (avatarIterator != _avatarHash.end()) {
+            auto avatar = std::static_pointer_cast<Avatar>(avatarIterator.value());
+            if (avatar != _myAvatar) {
+                removedAvatars.push_back(avatar);
+                avatarIterator = _avatarHash.erase(avatarIterator);
+            } else {
+                ++avatarIterator;
+            }
+        }
+    }    
+
+    for (auto& av : removedAvatars) {
+        handleRemovedAvatar(av);
+    }
 }

 void AvatarManager::deleteAllAvatars() {
    assert(_avatarsToChangeInPhysics.empty());

-    QReadLocker locker(&_hashLock);
+    QWriteLocker locker(&_hashLock);
    AvatarHash::iterator avatarIterator =  _avatarHash.begin();
    while (avatarIterator != _avatarHash.end()) {
        auto avatar = std::static_pointer_cast<OtherAvatar>(avatarIterator.value());
--- a/interface/src/avatar/AvatarManager.h
+++ b/interface/src/avatar/AvatarManager.h
@ -204,7 +204,12 @@ private:
    void simulateAvatarFades(float deltaTime);

    AvatarSharedPointer newSharedAvatar() override;
-    void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar, KillAvatarReason removalReason = KillAvatarReason::NoReason) override;
+    
+    // called only from the AvatarHashMap thread - cannot be called while this thread holds the
+    // hash lock, since handleRemovedAvatar needs a write lock on the entity tree and the entity tree
+    // frequently grabs a read lock on the hash to get a given avatar by ID
+    void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar,
+                             KillAvatarReason removalReason = KillAvatarReason::NoReason) override;

    QVector<AvatarSharedPointer> _avatarsToFade;

--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@ -91,6 +91,8 @@ const float MIN_SCALE_CHANGED_DELTA = 0.001f;
 const int MODE_READINGS_RING_BUFFER_SIZE = 500;
 const float CENTIMETERS_PER_METER = 100.0f;

+const QString AVATAR_SETTINGS_GROUP_NAME { "Avatar" };
+
 MyAvatar::MyAvatar(QThread* thread) :
    Avatar(thread),
    _yawSpeed(YAW_SPEED_DEFAULT),
@ -118,7 +120,22 @@ MyAvatar::MyAvatar(QThread* thread) :
    _goToOrientation(),
    _prevShouldDrawHead(true),
    _audioListenerMode(FROM_HEAD),
-    _hmdAtRestDetector(glm::vec3(0), glm::quat())
+    _hmdAtRestDetector(glm::vec3(0), glm::quat()),
+    _dominantHandSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "dominantHand", DOMINANT_RIGHT_HAND),
+    _headPitchSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "", 0.0f),
+    _scaleSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "scale", _targetScale),
+    _yawSpeedSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "yawSpeed", _yawSpeed),
+    _pitchSpeedSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "pitchSpeed", _pitchSpeed),
+    _fullAvatarURLSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "fullAvatarURL",
+                          AvatarData::defaultFullAvatarModelUrl()),
+    _fullAvatarModelNameSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "fullAvatarModelName", _fullAvatarModelName),
+    _animGraphURLSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "animGraphURL", QUrl("")),
+    _displayNameSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "displayName", ""),
+    _collisionSoundURLSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "collisionSoundURL", QUrl(_collisionSoundURL)),
+    _useSnapTurnSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "useSnapTurn", _useSnapTurn),
+    _userHeightSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "userHeight", DEFAULT_AVATAR_HEIGHT),
+    _flyingHMDSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "flyingHMD", _flyingPrefHMD),
+    _avatarEntityCountSetting(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "avatarEntityData" << "size", _flyingPrefHMD)
 {
    _clientTraitsHandler = std::unique_ptr<ClientTraitsHandler>(new ClientTraitsHandler(this));

@ -1135,88 +1152,80 @@ void MyAvatar::restoreRoleAnimation(const QString& role) {
 }

 void MyAvatar::saveAvatarUrl() {
-    Settings settings;
-    settings.beginGroup("Avatar");
-    if (qApp->getSaveAvatarOverrideUrl() || !qApp->getAvatarOverrideUrl().isValid() ) {
-        settings.setValue("fullAvatarURL",
-                          _fullAvatarURLFromPreferences == AvatarData::defaultFullAvatarModelUrl() ?
-                          "" :
-                          _fullAvatarURLFromPreferences.toString());
+    if (qApp->getSaveAvatarOverrideUrl() || !qApp->getAvatarOverrideUrl().isValid()) {
+        _fullAvatarURLSetting.set(_fullAvatarURLFromPreferences == AvatarData::defaultFullAvatarModelUrl() ?
+                                  "" :
+                                  _fullAvatarURLFromPreferences.toString());
+    }
+}
+
+void MyAvatar::resizeAvatarEntitySettingHandles(unsigned int avatarEntityIndex) {
+    // The original Settings interface saved avatar-entity array data like this:
+    // Avatar/avatarEntityData/size: 5
+    // Avatar/avatarEntityData/1/id: ...
+    // Avatar/avatarEntityData/1/properties: ...
+    // ...
+    // Avatar/avatarEntityData/5/id: ...
+    // Avatar/avatarEntityData/5/properties: ...
+    //
+    // Create Setting::Handles to mimic this.
+
+    while (_avatarEntityIDSettings.size() <= avatarEntityIndex) {
+        Setting::Handle<QUuid> idHandle(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "avatarEntityData"
+                                        << QString::number(avatarEntityIndex + 1) << "id", QUuid());
+        _avatarEntityIDSettings.push_back(idHandle);
+        Setting::Handle<QByteArray> dataHandle(QStringList() << AVATAR_SETTINGS_GROUP_NAME << "avatarEntityData"
+                                               << QString::number(avatarEntityIndex + 1) << "properties", QByteArray());
+        _avatarEntityDataSettings.push_back(dataHandle);
    }
-    settings.endGroup();
 }

 void MyAvatar::saveData() {
-    Settings settings;
-    settings.beginGroup("Avatar");
-
-    settings.setValue("dominantHand", _dominantHand);
-    settings.setValue("headPitch", getHead()->getBasePitch());
-
-    settings.setValue("scale", _targetScale);
-
-    settings.setValue("yawSpeed", _yawSpeed);
-    settings.setValue("pitchSpeed", _pitchSpeed);
+    _dominantHandSetting.set(_dominantHand);
+    _headPitchSetting.set(getHead()->getBasePitch());
+    _scaleSetting.set(_targetScale);
+    _yawSpeedSetting.set(_yawSpeed);
+    _pitchSpeedSetting.set(_pitchSpeed);

    // only save the fullAvatarURL if it has not been overwritten on command line
    // (so the overrideURL is not valid), or it was overridden _and_ we specified
    // --replaceAvatarURL (so _saveAvatarOverrideUrl is true)
    if (qApp->getSaveAvatarOverrideUrl() || !qApp->getAvatarOverrideUrl().isValid() ) {
-        settings.setValue("fullAvatarURL",
-                      _fullAvatarURLFromPreferences == AvatarData::defaultFullAvatarModelUrl() ?
-                      "" :
-                      _fullAvatarURLFromPreferences.toString());
+        _fullAvatarURLSetting.set(_fullAvatarURLFromPreferences == AvatarData::defaultFullAvatarModelUrl() ?
+                                  "" :
+                                  _fullAvatarURLFromPreferences.toString());
    }

-    settings.setValue("fullAvatarModelName", _fullAvatarModelName);
-
+    _fullAvatarModelNameSetting.set(_fullAvatarModelName);
    QUrl animGraphUrl = _prefOverrideAnimGraphUrl.get();
-    settings.setValue("animGraphURL", animGraphUrl);
+    _animGraphURLSetting.set(animGraphUrl);
+    _displayNameSetting.set(_displayName);
+    _collisionSoundURLSetting.set(_collisionSoundURL);
+    _useSnapTurnSetting.set(_useSnapTurn);
+    _userHeightSetting.set(getUserHeight());
+    _flyingHMDSetting.set(getFlyingHMDPref());

-    settings.beginWriteArray("attachmentData");
-    for (int i = 0; i < _attachmentData.size(); i++) {
-        settings.setArrayIndex(i);
-        const AttachmentData& attachment = _attachmentData.at(i);
-        settings.setValue("modelURL", attachment.modelURL);
-        settings.setValue("jointName", attachment.jointName);
-        settings.setValue("translation_x", attachment.translation.x);
-        settings.setValue("translation_y", attachment.translation.y);
-        settings.setValue("translation_z", attachment.translation.z);
-        glm::vec3 eulers = safeEulerAngles(attachment.rotation);
-        settings.setValue("rotation_x", eulers.x);
-        settings.setValue("rotation_y", eulers.y);
-        settings.setValue("rotation_z", eulers.z);
-        settings.setValue("scale", attachment.scale);
-        settings.setValue("isSoft", attachment.isSoft);
-    }
-    settings.endArray();
-
-    settings.remove("avatarEntityData");
-    settings.beginWriteArray("avatarEntityData");
-    int avatarEntityIndex = 0;
    auto hmdInterface = DependencyManager::get<HMDScriptingInterface>();
    _avatarEntitiesLock.withReadLock([&] {
-        for (auto entityID : _avatarEntityData.keys()) {
-            if (hmdInterface->getCurrentTabletFrameID() == entityID) {
-                // don't persist the tablet between domains / sessions
-                continue;
-            }
+        QList<QUuid> avatarEntityIDs = _avatarEntityData.keys();
+        unsigned int avatarEntityCount = avatarEntityIDs.size();
+        unsigned int previousAvatarEntityCount = _avatarEntityCountSetting.get(0);
+        resizeAvatarEntitySettingHandles(std::max<unsigned int>(avatarEntityCount, previousAvatarEntityCount));
+        _avatarEntityCountSetting.set(avatarEntityCount);

-            settings.setArrayIndex(avatarEntityIndex);
-            settings.setValue("id", entityID);
-            settings.setValue("properties", _avatarEntityData.value(entityID));
+        unsigned int avatarEntityIndex = 0;
+        for (auto entityID : avatarEntityIDs) {
+            _avatarEntityIDSettings[avatarEntityIndex].set(entityID);
+            _avatarEntityDataSettings[avatarEntityIndex].set(_avatarEntityData.value(entityID));
            avatarEntityIndex++;
        }
+
+        // clean up any left-over (due to the list shrinking) slots
+        for (; avatarEntityIndex < previousAvatarEntityCount; avatarEntityIndex++) {
+            _avatarEntityIDSettings[avatarEntityIndex].remove();
+            _avatarEntityDataSettings[avatarEntityIndex].remove();
+        }
    });
-    settings.endArray();
-
-    settings.setValue("displayName", _displayName);
-    settings.setValue("collisionSoundURL", _collisionSoundURL);
-    settings.setValue("useSnapTurn", _useSnapTurn);
-    settings.setValue("userHeight", getUserHeight());
-    settings.setValue("flyingHMD", getFlyingHMDPref());
-
-    settings.endGroup();
 }

 float loadSetting(Settings& settings, const QString& name, float defaultValue) {
@ -1314,66 +1323,36 @@ void MyAvatar::setEnableInverseKinematics(bool isEnabled) {
 }

 void MyAvatar::loadData() {
-    Settings settings;
-    settings.beginGroup("Avatar");
+    getHead()->setBasePitch(_headPitchSetting.get());

-    getHead()->setBasePitch(loadSetting(settings, "headPitch", 0.0f));
+    _yawSpeed = _yawSpeedSetting.get(_yawSpeed);
+    _pitchSpeed = _pitchSpeedSetting.get(_pitchSpeed);

-    _yawSpeed = loadSetting(settings, "yawSpeed", _yawSpeed);
-    _pitchSpeed = loadSetting(settings, "pitchSpeed", _pitchSpeed);
-
-    _prefOverrideAnimGraphUrl.set(QUrl(settings.value("animGraphURL", "").toString()));
-    _fullAvatarURLFromPreferences = settings.value("fullAvatarURL", AvatarData::defaultFullAvatarModelUrl()).toUrl();
-    _fullAvatarModelName = settings.value("fullAvatarModelName", DEFAULT_FULL_AVATAR_MODEL_NAME).toString();
+    _prefOverrideAnimGraphUrl.set(_prefOverrideAnimGraphUrl.get().toString());
+    _fullAvatarURLFromPreferences = _fullAvatarURLSetting.get(QUrl(AvatarData::defaultFullAvatarModelUrl()));
+    _fullAvatarModelName = _fullAvatarModelNameSetting.get(DEFAULT_FULL_AVATAR_MODEL_NAME).toString();

    useFullAvatarURL(_fullAvatarURLFromPreferences, _fullAvatarModelName);

-    int attachmentCount = settings.beginReadArray("attachmentData");
-    for (int i = 0; i < attachmentCount; i++) {
-        settings.setArrayIndex(i);
-        AttachmentData attachment;
-        attachment.modelURL = settings.value("modelURL").toUrl();
-        attachment.jointName = settings.value("jointName").toString();
-        attachment.translation.x = loadSetting(settings, "translation_x", 0.0f);
-        attachment.translation.y = loadSetting(settings, "translation_y", 0.0f);
-        attachment.translation.z = loadSetting(settings, "translation_z", 0.0f);
-        glm::vec3 eulers;
-        eulers.x = loadSetting(settings, "rotation_x", 0.0f);
-        eulers.y = loadSetting(settings, "rotation_y", 0.0f);
-        eulers.z = loadSetting(settings, "rotation_z", 0.0f);
-        attachment.rotation = glm::quat(eulers);
-        attachment.scale = loadSetting(settings, "scale", 1.0f);
-        attachment.isSoft = settings.value("isSoft").toBool();
-        // old attachments are stored and loaded/converted later when rig is ready
-        _oldAttachmentData.append(attachment);
-    }
-    settings.endArray();
-
-    int avatarEntityCount = settings.beginReadArray("avatarEntityData");
+    int avatarEntityCount = _avatarEntityCountSetting.get(0);
    for (int i = 0; i < avatarEntityCount; i++) {
-        settings.setArrayIndex(i);
-        QUuid entityID = settings.value("id").toUuid();
+        resizeAvatarEntitySettingHandles(i);
        // QUuid entityID = QUuid::createUuid(); // generate a new ID
-        QByteArray properties = settings.value("properties").toByteArray();
+        QUuid entityID = _avatarEntityIDSettings[i].get(QUuid());
+        QByteArray properties = _avatarEntityDataSettings[i].get();
        updateAvatarEntity(entityID, properties);
    }
-    settings.endArray();
-    if (avatarEntityCount == 0) {
-        // HACK: manually remove empty 'avatarEntityData' else legacy data may persist in settings file
-        settings.remove("avatarEntityData");
-    }

    // Flying preferences must be loaded before calling setFlyingEnabled()
    Setting::Handle<bool> firstRunVal { Settings::firstRun, true };
-    setFlyingHMDPref(firstRunVal.get() ? false : settings.value("flyingHMD").toBool());
+    setFlyingHMDPref(firstRunVal.get() ? false : _flyingHMDSetting.get());
    setFlyingEnabled(getFlyingEnabled());

-    setDisplayName(settings.value("displayName").toString());
-    setCollisionSoundURL(settings.value("collisionSoundURL", DEFAULT_AVATAR_COLLISION_SOUND_URL).toString());
-    setSnapTurn(settings.value("useSnapTurn", _useSnapTurn).toBool());
-    setDominantHand(settings.value("dominantHand", _dominantHand).toString().toLower());
-    setUserHeight(settings.value("userHeight", DEFAULT_AVATAR_HEIGHT).toDouble());
-    settings.endGroup();
+    setDisplayName(_displayNameSetting.get());
+    setCollisionSoundURL(_collisionSoundURLSetting.get(QUrl(DEFAULT_AVATAR_COLLISION_SOUND_URL)).toString());
+    setSnapTurn(_useSnapTurnSetting.get());
+    setDominantHand(_dominantHandSetting.get(DOMINANT_RIGHT_HAND).toLower());
+    setUserHeight(_userHeightSetting.get(DEFAULT_AVATAR_HEIGHT));

    setEnableMeshVisible(Menu::getInstance()->isOptionChecked(MenuOption::MeshVisible));
    _follow.setToggleHipsFollowing (Menu::getInstance()->isOptionChecked(MenuOption::ToggleHipsFollowing));
@ -1442,6 +1421,7 @@ AttachmentData MyAvatar::loadAttachmentData(const QUrl& modelURL, const QString&
    return attachment;
 }

+
 int MyAvatar::parseDataFromBuffer(const QByteArray& buffer) {
    qCDebug(interfaceapp) << "Error: ignoring update packet for MyAvatar"
        << " packetLength = " << buffer.size();
@ -2899,10 +2879,7 @@ void MyAvatar::restrictScaleFromDomainSettings(const QJsonObject& domainSettings
    }

    // Set avatar current scale
-    Settings settings;
-    settings.beginGroup("Avatar");
-    _targetScale = loadSetting(settings, "scale", 1.0f);
-
+    _targetScale = _scaleSetting.get();
    // clamp the desired _targetScale by the domain limits NOW, don't try to gracefully animate.  Because
    // this might cause our avatar to become embedded in the terrain.
    _targetScale = getDomainLimitedScale();
@ -2914,7 +2891,6 @@ void MyAvatar::restrictScaleFromDomainSettings(const QJsonObject& domainSettings

    setModelScale(_targetScale);
    rebuildCollisionShape();
-    settings.endGroup();

    _haveReceivedHeightLimitsFromDomain = true;
 }
@ -2925,10 +2901,7 @@ void MyAvatar::leaveDomain() {
 }

 void MyAvatar::saveAvatarScale() {
-    Settings settings;
-    settings.beginGroup("Avatar");
-    settings.setValue("scale", _targetScale);
-    settings.endGroup();
+    _scaleSetting.set(_targetScale);
 }

 void MyAvatar::clearScaleRestriction() {
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@ -550,6 +550,7 @@ public:
    float getHMDRollControlRate() const { return _hmdRollControlRate; }

    // get/set avatar data
+    void resizeAvatarEntitySettingHandles(unsigned int avatarEntityIndex);
    void saveData();
    void loadData();

@ -1806,6 +1807,23 @@ private:

    bool _haveReceivedHeightLimitsFromDomain { false };
    int _disableHandTouchCount { 0 };
+
+    Setting::Handle<QString> _dominantHandSetting;
+    Setting::Handle<float> _headPitchSetting;
+    Setting::Handle<float> _scaleSetting;
+    Setting::Handle<float> _yawSpeedSetting;
+    Setting::Handle<float> _pitchSpeedSetting;
+    Setting::Handle<QUrl> _fullAvatarURLSetting;
+    Setting::Handle<QUrl> _fullAvatarModelNameSetting;
+    Setting::Handle<QUrl> _animGraphURLSetting;
+    Setting::Handle<QString> _displayNameSetting;
+    Setting::Handle<QUrl> _collisionSoundURLSetting;
+    Setting::Handle<bool> _useSnapTurnSetting;
+    Setting::Handle<float> _userHeightSetting;
+    Setting::Handle<bool> _flyingHMDSetting;
+    Setting::Handle<int> _avatarEntityCountSetting;
+    std::vector<Setting::Handle<QUuid>> _avatarEntityIDSettings;
+    std::vector<Setting::Handle<QByteArray>> _avatarEntityDataSettings;
 };

 QScriptValue audioListenModeToScriptValue(QScriptEngine* engine, const AudioListenerMode& audioListenerMode);
--- a/interface/src/avatar/OtherAvatar.cpp
+++ b/interface/src/avatar/OtherAvatar.cpp
@ -119,6 +119,11 @@ bool OtherAvatar::shouldBeInPhysicsSimulation() const {
    return (_workloadRegion < workload::Region::R3 && !isDead());
 }

+bool OtherAvatar::needsPhysicsUpdate() const {
+    constexpr uint32_t FLAGS_OF_INTEREST = Simulation::DIRTY_SHAPE | Simulation::DIRTY_MASS | Simulation::DIRTY_POSITION;
+    return (_motionState && (bool)(_motionState->getIncomingDirtyFlags() & FLAGS_OF_INTEREST));
+}
+
 void OtherAvatar::rebuildCollisionShape() {
    if (_motionState) {
        _motionState->addDirtyFlags(Simulation::DIRTY_SHAPE | Simulation::DIRTY_MASS);
--- a/interface/src/avatar/OtherAvatar.h
+++ b/interface/src/avatar/OtherAvatar.h
@ -43,6 +43,7 @@ public:

    void setWorkloadRegion(uint8_t region);
    bool shouldBeInPhysicsSimulation() const;
+    bool needsPhysicsUpdate() const;

    friend AvatarManager;

--- a/interface/src/commerce/QmlCommerce.cpp
+++ b/interface/src/commerce/QmlCommerce.cpp
@ -199,12 +199,18 @@ void QmlCommerce::transferAssetToUsername(const QString& username,
 }

 void QmlCommerce::replaceContentSet(const QString& itemHref, const QString& certificateID) {
-    auto ledger = DependencyManager::get<Ledger>();
-    ledger->updateLocation(certificateID, DependencyManager::get<AddressManager>()->getPlaceName(), true);
+    if (!certificateID.isEmpty()) {
+        auto ledger = DependencyManager::get<Ledger>();
+        ledger->updateLocation(
+            certificateID,
+            DependencyManager::get<AddressManager>()->getPlaceName(),
+            true);
+    }
    qApp->replaceDomainContent(itemHref);
-    QJsonObject messageProperties = { { "status", "SuccessfulRequestToReplaceContent" }, { "content_set_url", itemHref } };
+    QJsonObject messageProperties = {
+        { "status", "SuccessfulRequestToReplaceContent" },
+        { "content_set_url", itemHref } };
    UserActivityLogger::getInstance().logAction("replace_domain_content", messageProperties);
-
    emit contentSetChanged(itemHref);
 }

@ -228,6 +234,7 @@ QString QmlCommerce::getInstalledApps(const QString& justInstalledAppID) {
        // Thus, we protect against deleting the .app.json from the user's disk (below)
        // by skipping that check for the app we just installed.
        if ((justInstalledAppID != "") && ((justInstalledAppID + ".app.json") == appFileName)) {
+            installedAppsFromMarketplace += appFileName + ",";
            continue;
        }

--- a/interface/src/raypick/LaserPointer.cpp
+++ b/interface/src/raypick/LaserPointer.cpp
@ -35,6 +35,14 @@ void LaserPointer::editRenderStatePath(const std::string& state, const QVariant&
    }
 }

+PickResultPointer LaserPointer::getPickResultCopy(const PickResultPointer& pickResult) const {
+    auto rayPickResult = std::dynamic_pointer_cast<RayPickResult>(pickResult);
+    if (!rayPickResult) {
+        return std::make_shared<RayPickResult>();
+    }
+    return std::make_shared<RayPickResult>(*rayPickResult.get());
+}
+
 QVariantMap LaserPointer::toVariantMap() const {
    QVariantMap qVariantMap;

--- a/interface/src/raypick/LaserPointer.h
+++ b/interface/src/raypick/LaserPointer.h
@ -47,6 +47,8 @@ public:
    static std::shared_ptr<StartEndRenderState> buildRenderState(const QVariantMap& propMap);

 protected:
+    PickResultPointer getPickResultCopy(const PickResultPointer& pickResult) const override;
+
    void editRenderStatePath(const std::string& state, const QVariant& pathProps) override;

    glm::vec3 getPickOrigin(const PickResultPointer& pickResult) const override;
--- a/interface/src/raypick/ParabolaPointer.cpp
+++ b/interface/src/raypick/ParabolaPointer.cpp
@ -30,6 +30,14 @@ ParabolaPointer::ParabolaPointer(const QVariant& rayProps, const RenderStateMap&
 {
 }

+PickResultPointer ParabolaPointer::getPickResultCopy(const PickResultPointer& pickResult) const {
+    auto parabolaPickResult = std::dynamic_pointer_cast<ParabolaPickResult>(pickResult);
+    if (!parabolaPickResult) {
+        return std::make_shared<ParabolaPickResult>();
+    }
+    return std::make_shared<ParabolaPickResult>(*parabolaPickResult.get());
+}
+
 void ParabolaPointer::editRenderStatePath(const std::string& state, const QVariant& pathProps) {
    auto renderState = std::static_pointer_cast<RenderState>(_renderStates[state]);
    if (renderState) {
--- a/interface/src/raypick/ParabolaPointer.h
+++ b/interface/src/raypick/ParabolaPointer.h
@ -102,6 +102,8 @@ public:
    static std::shared_ptr<StartEndRenderState> buildRenderState(const QVariantMap& propMap);

 protected:
+    virtual PickResultPointer getPickResultCopy(const PickResultPointer& pickResult) const override;
+
    void editRenderStatePath(const std::string& state, const QVariant& pathProps) override;

    glm::vec3 getPickOrigin(const PickResultPointer& pickResult) const override;
--- a/interface/src/raypick/StylusPointer.cpp
+++ b/interface/src/raypick/StylusPointer.cpp
@ -147,6 +147,14 @@ bool StylusPointer::shouldTrigger(const PickResultPointer& pickResult) {
    return false;
 }

+PickResultPointer StylusPointer::getPickResultCopy(const PickResultPointer& pickResult) const {
+    auto stylusPickResult = std::dynamic_pointer_cast<StylusPickResult>(pickResult);
+    if (!stylusPickResult) {
+        return std::make_shared<StylusPickResult>();
+    }
+    return std::make_shared<StylusPickResult>(*stylusPickResult.get());
+}
+
 Pointer::PickedObject StylusPointer::getHoveredObject(const PickResultPointer& pickResult) {
    auto stylusPickResult = std::static_pointer_cast<const StylusPickResult>(pickResult);
    if (!stylusPickResult) {
--- a/interface/src/raypick/StylusPointer.h
+++ b/interface/src/raypick/StylusPointer.h
@ -42,6 +42,7 @@ protected:
    Buttons getPressedButtons(const PickResultPointer& pickResult) override;
    bool shouldHover(const PickResultPointer& pickResult) override;
    bool shouldTrigger(const PickResultPointer& pickResult) override;
+    virtual PickResultPointer getPickResultCopy(const PickResultPointer& pickResult) const override;

    PointerEvent buildPointerEvent(const PickedObject& target, const PickResultPointer& pickResult, const std::string& button = "", bool hover = true) override;

--- a/interface/src/scripting/WindowScriptingInterface.cpp
+++ b/interface/src/scripting/WindowScriptingInterface.cpp
@ -180,6 +180,14 @@ void WindowScriptingInterface::setPreviousBrowseAssetLocation(const QString& loc
    Setting::Handle<QVariant>(LAST_BROWSE_ASSETS_LOCATION_SETTING).set(location);
 }

+bool WindowScriptingInterface::getInterstitialModeEnabled() const {
+    return DependencyManager::get<NodeList>()->getDomainHandler().getInterstitialModeEnabled();
+}
+
+void WindowScriptingInterface::setInterstitialModeEnabled(bool enableInterstitialMode) {
+    DependencyManager::get<NodeList>()->getDomainHandler().setInterstitialModeEnabled(enableInterstitialMode);
+}
+
 bool  WindowScriptingInterface::isPointOnDesktopWindow(QVariant point) {
    auto offscreenUi = DependencyManager::get<OffscreenUi>();
    return offscreenUi->isPointOnDesktopWindow(point);
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@ -49,6 +49,7 @@ class WindowScriptingInterface : public QObject, public Dependency {
    Q_PROPERTY(int innerHeight READ getInnerHeight)
    Q_PROPERTY(int x READ getX)
    Q_PROPERTY(int y READ getY)
+    Q_PROPERTY(bool interstitialModeEnabled READ getInterstitialModeEnabled WRITE setInterstitialModeEnabled)

 public:
    WindowScriptingInterface();
@ -758,6 +759,9 @@ private:
    QString getPreviousBrowseAssetLocation() const;
    void setPreviousBrowseAssetLocation(const QString& location);

+    bool getInterstitialModeEnabled() const;
+    void setInterstitialModeEnabled(bool enableInterstitialMode);
+
    void ensureReticleVisible() const;

    int createMessageBox(QString title, QString text, int buttons, int defaultButton);
--- a/libraries/audio-client/src/AudioClient.cpp
+++ b/libraries/audio-client/src/AudioClient.cpp
@ -100,6 +100,13 @@ QList<QAudioDeviceInfo> getAvailableDevices(QAudio::Mode mode) {

 // now called from a background thread, to keep blocking operations off the audio thread
 void AudioClient::checkDevices() {
+    // Make sure we're not shutting down
+    Lock timerMutex(_checkDevicesMutex);
+    // If we HAVE shut down after we were queued, but prior to execution, early exit
+    if (nullptr == _checkDevicesTimer) {
+        return;
+    }
+
    auto inputDevices = getAvailableDevices(QAudio::AudioInput);
    auto outputDevices = getAvailableDevices(QAudio::AudioOutput);

@ -278,9 +285,6 @@ void AudioClient::customDeleter() {
    _shouldRestartInputSetup = false;
 #endif
    stop();
-    _checkDevicesTimer->stop();
-    _checkPeakValuesTimer->stop();
-
    deleteLater();
 }

@ -653,12 +657,26 @@ void AudioClient::start() {
 }

 void AudioClient::stop() {
-
    qCDebug(audioclient) << "AudioClient::stop(), requesting switchInputToAudioDevice() to shut down";
    switchInputToAudioDevice(QAudioDeviceInfo(), true);

    qCDebug(audioclient) << "AudioClient::stop(), requesting switchOutputToAudioDevice() to shut down";
    switchOutputToAudioDevice(QAudioDeviceInfo(), true);
+
+    // Stop triggering the checks
+    QObject::disconnect(_checkPeakValuesTimer, &QTimer::timeout, nullptr, nullptr);
+    QObject::disconnect(_checkDevicesTimer, &QTimer::timeout, nullptr, nullptr);
+
+    // Destruction of the pointers will occur when the parent object (this) is destroyed)
+    {
+        Lock lock(_checkDevicesMutex);
+        _checkDevicesTimer = nullptr;
+    }
+    {
+        Lock lock(_checkPeakValuesMutex);
+        _checkPeakValuesTimer = nullptr;
+    }
+
 #if defined(Q_OS_ANDROID)
    _checkInputTimer.stop();
    disconnect(&_checkInputTimer, &QTimer::timeout, 0, 0);
--- a/libraries/audio-client/src/AudioClient.h
+++ b/libraries/audio-client/src/AudioClient.h
@ -447,7 +447,9 @@ private:
    bool _shouldRestartInputSetup { true }; // Should we restart the input device because of an unintended stop?
 #endif
    
+    Mutex _checkDevicesMutex;
    QTimer* _checkDevicesTimer { nullptr };
+    Mutex _checkPeakValuesMutex;
    QTimer* _checkPeakValuesTimer { nullptr };

    bool _isRecording { false };
--- a/libraries/audio-client/src/AudioPeakValues.cpp
+++ b/libraries/audio-client/src/AudioPeakValues.cpp
@ -40,6 +40,12 @@ void release(IAudioClient* audioClient) {
 }

 void AudioClient::checkPeakValues() {
+    // Guard against running during shutdown
+    Lock timerMutex(_checkPeakValuesMutex);
+    if (nullptr == _checkPeakValuesTimer) {
+        return;
+    }
+
    // prepare the windows environment
    CoInitialize(NULL);

--- a/libraries/audio/src/Sound.cpp
+++ b/libraries/audio/src/Sound.cpp
@ -43,8 +43,11 @@ void soundSharedPointerFromScriptValue(const QScriptValue& object, SharedSoundPo
    }
 }

-SoundScriptingInterface::SoundScriptingInterface(SharedSoundPointer sound) : _sound(sound) {
-    QObject::connect(sound.data(), &Sound::ready, this, &SoundScriptingInterface::ready);
+SoundScriptingInterface::SoundScriptingInterface(const SharedSoundPointer& sound) : _sound(sound) {
+    // During shutdown we can sometimes get an empty sound pointer back
+    if (_sound) {
+        QObject::connect(_sound.data(), &Sound::ready, this, &SoundScriptingInterface::ready);
+    }
 }

 Sound::Sound(const QUrl& url, bool isStereo, bool isAmbisonic) :
--- a/libraries/audio/src/Sound.h
+++ b/libraries/audio/src/Sound.h
@ -105,11 +105,11 @@ class SoundScriptingInterface : public QObject {
    Q_PROPERTY(float duration READ getDuration)

 public:
-    SoundScriptingInterface(SharedSoundPointer sound);
-    SharedSoundPointer getSound() { return _sound; }
+    SoundScriptingInterface(const SharedSoundPointer& sound);
+    const SharedSoundPointer& getSound() { return _sound; }

-    bool isReady() const { return _sound->isReady(); }
-    float getDuration() { return _sound->getDuration(); }
+    bool isReady() const { return _sound ? _sound->isReady() : false; }
+    float getDuration() { return _sound ? _sound->getDuration() : 0.0f; }

 /**jsdoc
 * Triggered when the sound has been downloaded and is ready to be played.
--- a/libraries/avatars/src/AvatarHashMap.cpp
+++ b/libraries/avatars/src/AvatarHashMap.cpp
@ -66,6 +66,22 @@ void AvatarReplicas::removeReplicas(const QUuid& parentID) {
    }
 }

+std::vector<AvatarSharedPointer> AvatarReplicas::takeReplicas(const QUuid& parentID) {
+    std::vector<AvatarSharedPointer> replicas;
+
+    auto it = _replicasMap.find(parentID);
+
+    if (it != _replicasMap.end()) {
+        // take a copy of the replica shared pointers for this parent
+        replicas.swap(it->second);
+
+        // erase the replicas for this parent from our map
+        _replicasMap.erase(it);
+    }
+
+    return replicas;
+}
+
 void AvatarReplicas::processAvatarIdentity(const QUuid& parentID, const QByteArray& identityData, bool& identityChanged, bool& displayNameChanged) {
    if (_replicasMap.find(parentID) != _replicasMap.end()) {
        auto &replicas = _replicasMap[parentID];
@ -386,24 +402,31 @@ void AvatarHashMap::processKillAvatar(QSharedPointer<ReceivedMessage> message, S
 }

 void AvatarHashMap::removeAvatar(const QUuid& sessionUUID, KillAvatarReason removalReason) {
-    QWriteLocker locker(&_hashLock);
+    std::vector<AvatarSharedPointer> removedAvatars;

-    auto replicaIDs = _replicas.getReplicaIDs(sessionUUID);
-    _replicas.removeReplicas(sessionUUID);
-    for (auto id : replicaIDs) {
-        auto removedReplica = _avatarHash.take(id);
-        if (removedReplica) {
-            handleRemovedAvatar(removedReplica, removalReason);
+    {
+        QWriteLocker locker(&_hashLock);
+
+        auto replicas = _replicas.takeReplicas(sessionUUID);
+
+        for (auto& replica : replicas) {
+            auto removedReplica = _avatarHash.take(replica->getID());
+            if (removedReplica) {
+                removedAvatars.push_back(removedReplica);
+            }
+        }
+
+        _pendingAvatars.remove(sessionUUID);
+        auto removedAvatar = _avatarHash.take(sessionUUID);
+
+        if (removedAvatar) {
+            removedAvatars.push_back(removedAvatar);
        }
    }

-    _pendingAvatars.remove(sessionUUID);
-    auto removedAvatar = _avatarHash.take(sessionUUID);
-
-    if (removedAvatar) {
+    for (auto& removedAvatar: removedAvatars) {
        handleRemovedAvatar(removedAvatar, removalReason);
    }
-
 }

 void AvatarHashMap::handleRemovedAvatar(const AvatarSharedPointer& removedAvatar, KillAvatarReason removalReason) {
@ -421,11 +444,18 @@ void AvatarHashMap::sessionUUIDChanged(const QUuid& sessionUUID, const QUuid& ol
 }

 void AvatarHashMap::clearOtherAvatars() {
-    QWriteLocker locker(&_hashLock);
+    QList<AvatarSharedPointer> removedAvatars;

-    for (auto& av : _avatarHash) {
-        handleRemovedAvatar(av);
+    {
+        QWriteLocker locker(&_hashLock);
+
+        // grab a copy of the current avatars so we can call handleRemoveAvatar for them
+        removedAvatars = _avatarHash.values();
+
+        _avatarHash.clear();
    }

-    _avatarHash.clear();
+    for (auto& av : removedAvatars) {
+        handleRemovedAvatar(av);
+    }
 }
--- a/libraries/avatars/src/AvatarHashMap.h
+++ b/libraries/avatars/src/AvatarHashMap.h
@ -49,6 +49,7 @@ public:
    void parseDataFromBuffer(const QUuid& parentID, const QByteArray& buffer);
    void processAvatarIdentity(const QUuid& parentID, const QByteArray& identityData, bool& identityChanged, bool& displayNameChanged);
    void removeReplicas(const QUuid& parentID);
+    std::vector<AvatarSharedPointer> takeReplicas(const QUuid& parentID);
    void processTrait(const QUuid& parentID, AvatarTraits::TraitType traitType, QByteArray traitBinaryData);
    void processDeletedTraitInstance(const QUuid& parentID, AvatarTraits::TraitType traitType, AvatarTraits::TraitInstanceID instanceID);
    void processTraitInstance(const QUuid& parentID, AvatarTraits::TraitType traitType,
@ -179,7 +180,7 @@ protected:
        bool& isNew);
    virtual AvatarSharedPointer findAvatar(const QUuid& sessionUUID) const; // uses a QReadLocker on the hashLock
    virtual void removeAvatar(const QUuid& sessionUUID, KillAvatarReason removalReason = KillAvatarReason::NoReason);
-
+    
    virtual void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar, KillAvatarReason removalReason = KillAvatarReason::NoReason);
    
    AvatarHash _avatarHash;
--- a/libraries/networking/src/AddressManager.h
+++ b/libraries/networking/src/AddressManager.h
@ -140,8 +140,7 @@ public:
     * </table>
     * @typedef {number} location.LookupTrigger
     */
-    enum LookupTrigger
-    {
+    enum LookupTrigger {
        UserInput,
        Back,
        Forward,
@ -207,9 +206,8 @@ public slots:
    // functions and signals that should be exposed are moved to a scripting interface class.
    //
    // we currently expect this to be called from NodeList once handleLookupString has been called with a path
-    bool goToViewpointForPath(const QString& viewpointString, const QString& pathString) {
-        return handleViewpoint(viewpointString, false, DomainPathResponse, false, pathString);
-    }
+    bool goToViewpointForPath(const QString& viewpointString, const QString& pathString)
+        { return handleViewpoint(viewpointString, false, DomainPathResponse, false, pathString); }

    /**jsdoc
     * Go back to the previous location in your navigation history, if there is one.
@ -231,8 +229,7 @@ public slots:
     *     location history is correctly maintained.
     */
    void goToLocalSandbox(QString path = "", LookupTrigger trigger = LookupTrigger::StartupFromSettings) {
-        handleUrl(SANDBOX_HIFI_ADDRESS + path, trigger);
-    }
+        handleUrl(SANDBOX_HIFI_ADDRESS + path, trigger); }

    /**jsdoc
     * Go to the default "welcome" metaverse address.
@ -364,8 +361,7 @@ signals:
     * location.locationChangeRequired.connect(onLocationChangeRequired);
     */
    void locationChangeRequired(const glm::vec3& newPosition,
-                                bool hasOrientationChange,
-                                const glm::quat& newOrientation,
+                                bool hasOrientationChange, const glm::quat& newOrientation,
                                bool shouldFaceLocation);

    /**jsdoc
@ -448,11 +444,8 @@ private:

    bool handleNetworkAddress(const QString& lookupString, LookupTrigger trigger, bool& hostChanged);
    void handlePath(const QString& path, LookupTrigger trigger, bool wasPathOnly = false);
-    bool handleViewpoint(const QString& viewpointString,
-                         bool shouldFace,
-                         LookupTrigger trigger,
-                         bool definitelyPathOnly = false,
-                         const QString& pathString = QString());
+    bool handleViewpoint(const QString& viewpointString, bool shouldFace, LookupTrigger trigger,
+                         bool definitelyPathOnly = false, const QString& pathString = QString());
    bool handleUsername(const QString& lookupString);
    bool handleDomainID(const QString& host);

--- a/libraries/networking/src/DomainHandler.cpp
+++ b/libraries/networking/src/DomainHandler.cpp
@ -15,6 +15,10 @@

 #include <PathUtils.h>

+#include <shared/QtHelpers.h>
+
+#include <QThread>
+
 #include <QtCore/QJsonDocument>
 #include <QtCore/QDataStream>

@ -134,6 +138,18 @@ void DomainHandler::hardReset() {
    _pendingPath.clear();
 }

+bool DomainHandler::getInterstitialModeEnabled() const {
+    return _interstitialModeSettingLock.resultWithReadLock<bool>([&] {
+        return _enableInterstitialMode.get();
+    });
+}
+
+void DomainHandler::setInterstitialModeEnabled(bool enableInterstitialMode) {
+    _interstitialModeSettingLock.withWriteLock([&] {
+        _enableInterstitialMode.set(enableInterstitialMode);
+    });
+}
+
 void DomainHandler::setErrorDomainURL(const QUrl& url) {
    _errorDomainURL = url;
    return;
@ -340,11 +356,15 @@ void DomainHandler::loadedErrorDomain(std::map<QString, QString> namedPaths) {
    DependencyManager::get<AddressManager>()->goToViewpointForPath(viewpoint, QString());
 }

-void DomainHandler::setRedirectErrorState(QUrl errorUrl, int reasonCode) {
-    _errorDomainURL = errorUrl;
+void DomainHandler::setRedirectErrorState(QUrl errorUrl, QString reasonMessage, int reasonCode, const QString& extraInfo) {
    _lastDomainConnectionError = reasonCode;
-    _isInErrorState = true;
-    emit redirectToErrorDomainURL(_errorDomainURL);
+    if (getInterstitialModeEnabled()) {
+        _errorDomainURL = errorUrl;
+        _isInErrorState = true;
+        emit redirectToErrorDomainURL(_errorDomainURL);
+    } else {
+        emit domainConnectionRefused(reasonMessage, reasonCode, extraInfo);
+    }
 }

 void DomainHandler::requestDomainSettings() {
@ -485,13 +505,9 @@ void DomainHandler::processDomainServerConnectionDeniedPacket(QSharedPointer<Rec
 #if defined(Q_OS_ANDROID)
        emit domainConnectionRefused(reasonMessage, (int)reasonCode, extraInfo);
 #else
-        if (reasonCode == ConnectionRefusedReason::ProtocolMismatch || reasonCode == ConnectionRefusedReason::NotAuthorized) {
-            // ingest the error - this is a "hard" connection refusal.
-            setRedirectErrorState(_errorDomainURL, (int)reasonCode);
-        } else {
-            emit domainConnectionRefused(reasonMessage, (int)reasonCode, extraInfo);
-        }
-        _lastDomainConnectionError = (int)reasonCode;
+
+        // ingest the error - this is a "hard" connection refusal.
+        setRedirectErrorState(_errorDomainURL, reasonMessage, (int)reasonCode, extraInfo);
 #endif
    }

--- a/libraries/networking/src/DomainHandler.h
+++ b/libraries/networking/src/DomainHandler.h
@ -19,6 +19,9 @@
 #include <QtCore/QUrl>
 #include <QtNetwork/QHostInfo>

+#include <shared/ReadWriteLockable.h>
+#include <SettingHandle.h>
+
 #include "HifiSockAddr.h"
 #include "NetworkPeer.h"
 #include "NLPacket.h"
@ -83,6 +86,8 @@ public:
    bool isConnected() const { return _isConnected; }
    void setIsConnected(bool isConnected);
    bool isServerless() const { return _domainURL.scheme() != URL_SCHEME_HIFI; }
+    bool getInterstitialModeEnabled() const;
+    void setInterstitialModeEnabled(bool enableInterstitialMode);

    void connectedToServerless(std::map<QString, QString> namedPaths);

@ -171,7 +176,7 @@ public slots:
    void processDomainServerConnectionDeniedPacket(QSharedPointer<ReceivedMessage> message);

    // sets domain handler in error state.
-    void setRedirectErrorState(QUrl errorUrl, int reasonCode);
+    void setRedirectErrorState(QUrl errorUrl, QString reasonMessage = "", int reason = -1, const QString& extraInfo = "");

    bool isInErrorState() { return _isInErrorState; }

@ -224,6 +229,8 @@ private:
    QJsonObject _settingsObject;
    QString _pendingPath;
    QTimer _settingsTimer;
+    mutable ReadWriteLockable _interstitialModeSettingLock;
+    Setting::Handle<bool> _enableInterstitialMode{ "enableInterstitialMode", false };

    QSet<QString> _domainConnectionRefusals;
    bool _hasCheckedForAccessToken { false };
--- a/libraries/pointers/src/Pointer.cpp
+++ b/libraries/pointers/src/Pointer.cpp
@ -68,7 +68,8 @@ void Pointer::update(unsigned int pointerID) {
    // This only needs to be a read lock because update won't change any of the properties that can be modified from scripts
    withReadLock([&] {
        auto pickResult = getPrevPickResult();
-        auto visualPickResult = getVisualPickResult(pickResult);
+        // Pointer needs its own PickResult object so it doesn't modify the cached pick result
+        auto visualPickResult = getVisualPickResult(getPickResultCopy(pickResult));
        updateVisuals(visualPickResult);
        generatePointerEvents(pointerID, visualPickResult);
    });
--- a/libraries/pointers/src/Pointer.h
+++ b/libraries/pointers/src/Pointer.h
@ -91,6 +91,7 @@ protected:

    virtual bool shouldHover(const PickResultPointer& pickResult) { return true; }
    virtual bool shouldTrigger(const PickResultPointer& pickResult) { return true; }
+    virtual PickResultPointer getPickResultCopy(const PickResultPointer& pickResult) const = 0;
    virtual PickResultPointer getVisualPickResult(const PickResultPointer& pickResult) { return pickResult; };

    static const float POINTER_MOVE_DELAY;
--- a/libraries/render-utils/src/HighlightEffect.cpp
+++ b/libraries/render-utils/src/HighlightEffect.cpp
@ -37,6 +37,8 @@ namespace gr {

 #define OUTLINE_STENCIL_MASK    1

+extern void initZPassPipelines(ShapePlumber& plumber, gpu::StatePointer state);
+
 HighlightRessources::HighlightRessources() {
 }

@ -180,6 +182,7 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c

            auto maskPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder);
            auto maskSkinnedPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder.withSkinned());
+            auto maskSkinnedDQPipeline = _shapePlumber->pickPipeline(args, defaultKeyBuilder.withSkinned().withDualQuatSkinned());

            // Setup camera, projection and viewport for all items
            batch.setViewportTransform(args->_viewport);
@ -187,14 +190,17 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
            batch.setProjectionJitter(jitter.x, jitter.y);
            batch.setViewTransform(viewMat);

-            std::vector<ShapeKey> skinnedShapeKeys{};
+            std::vector<ShapeKey> skinnedShapeKeys;
+            std::vector<ShapeKey> skinnedDQShapeKeys;

            // Iterate through all inShapes and render the unskinned
            args->_shapePipeline = maskPipeline;
            batch.setPipeline(maskPipeline->pipeline);
            for (const auto& items : inShapes) {
                itemBounds.insert(itemBounds.end(), items.second.begin(), items.second.end());
-                if (items.first.isSkinned()) {
+                if (items.first.isSkinned() && items.first.isDualQuatSkinned()) {
+                    skinnedDQShapeKeys.push_back(items.first);
+                } else if (items.first.isSkinned()) {
                    skinnedShapeKeys.push_back(items.first);
                } else {
                    renderItems(renderContext, items.second);
@ -202,10 +208,21 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
            }

            // Reiterate to render the skinned
-            args->_shapePipeline = maskSkinnedPipeline;
-            batch.setPipeline(maskSkinnedPipeline->pipeline);
-            for (const auto& key : skinnedShapeKeys) {
-                renderItems(renderContext, inShapes.at(key));
+            if (skinnedShapeKeys.size() > 0) {
+                args->_shapePipeline = maskSkinnedPipeline;
+                batch.setPipeline(maskSkinnedPipeline->pipeline);
+                for (const auto& key : skinnedShapeKeys) {
+                    renderItems(renderContext, inShapes.at(key));
+                }
+            }
+
+            // Reiterate to render the DQ skinned
+            if (skinnedDQShapeKeys.size() > 0) {
+                args->_shapePipeline = maskSkinnedDQPipeline;
+                batch.setPipeline(maskSkinnedDQPipeline->pipeline);
+                for (const auto& key : skinnedDQShapeKeys) {
+                    renderItems(renderContext, inShapes.at(key));
+                }
            }

            args->_shapePipeline = nullptr;
@ -488,7 +505,7 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren
        state->setDepthTest(true, true, gpu::LESS_EQUAL);
        state->setColorWriteMask(false, false, false, false);

-        initMaskPipelines(*shapePlumber, state);
+        initZPassPipelines(*shapePlumber, state);
    }
    auto sharedParameters = std::make_shared<HighlightSharedParameters>();

@ -548,16 +565,4 @@ const render::Varying DrawHighlightTask::addSelectItemJobs(JobModel& task, const
    const auto selectedMetasAndOpaques = task.addJob<SelectItems>("OpaqueSelection", selectMetaAndOpaqueInput);
    const auto selectItemInput = SelectItems::Inputs(transparents, selectedMetasAndOpaques, selectionName).asVarying();
    return task.addJob<SelectItems>("TransparentSelection", selectItemInput);
-}
-
-void DrawHighlightTask::initMaskPipelines(render::ShapePlumber& shapePlumber, gpu::StatePointer state) {
-    gpu::ShaderPointer modelProgram = gpu::Shader::createProgram(shader::render_utils::program::model_shadow);
-    shapePlumber.addPipeline(
-        ShapeKey::Filter::Builder().withoutSkinned(),
-        modelProgram, state);
-
-    gpu::ShaderPointer skinProgram = gpu::Shader::createProgram(shader::render_utils::program::skin_model_shadow);
-    shapePlumber.addPipeline(
-        ShapeKey::Filter::Builder().withSkinned(),
-        skinProgram, state);
-}
+}
--- a/libraries/render-utils/src/HighlightEffect.h
+++ b/libraries/render-utils/src/HighlightEffect.h
@ -208,8 +208,6 @@ public:
    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs);

 private:
-
-    static void initMaskPipelines(render::ShapePlumber& plumber, gpu::StatePointer state);
    static const render::Varying addSelectItemJobs(JobModel& task, const render::Varying& selectionName, const RenderFetchCullSortTask::BucketList& items);

 };
--- a/libraries/render-utils/src/Model.cpp
+++ b/libraries/render-utils/src/Model.cpp
@ -1281,92 +1281,6 @@ QStringList Model::getJointNames() const {
    return isActive() ? getFBXGeometry().getJointNames() : QStringList();
 }

-class Blender : public QRunnable {
-public:
-
-    Blender(ModelPointer model, int blendNumber, const Geometry::WeakPointer& geometry, const QVector<float>& blendshapeCoefficients);
-
-    virtual void run() override;
-
-private:
-
-    ModelPointer _model;
-    int _blendNumber;
-    Geometry::WeakPointer _geometry;
-    QVector<float> _blendshapeCoefficients;
-};
-
-Blender::Blender(ModelPointer model, int blendNumber, const Geometry::WeakPointer& geometry, const QVector<float>& blendshapeCoefficients) :
-    _model(model),
-    _blendNumber(blendNumber),
-    _geometry(geometry),
-    _blendshapeCoefficients(blendshapeCoefficients) {
-}
-
-void Blender::run() {
-    QVector<glm::vec3> vertices;
-    QVector<NormalType> normalsAndTangents;
-    if (_model && _model->isLoaded()) {
-        DETAILED_PROFILE_RANGE_EX(simulation_animation, __FUNCTION__, 0xFFFF0000, 0, { { "url", _model->getURL().toString() } });
-        int offset = 0;
-        int normalsAndTangentsOffset = 0;
-        auto meshes = _model->getFBXGeometry().meshes;
-        int meshIndex = 0;
-        foreach (const FBXMesh& mesh, meshes) {
-            auto modelMeshNormalsAndTangents = _model->_normalsAndTangents.find(meshIndex++);
-            if (mesh.blendshapes.isEmpty() || modelMeshNormalsAndTangents == _model->_normalsAndTangents.end()) {
-                continue;
-            }
-
-            vertices += mesh.vertices;
-            normalsAndTangents += modelMeshNormalsAndTangents->second;
-            glm::vec3* meshVertices = vertices.data() + offset;
-            NormalType* meshNormalsAndTangents = normalsAndTangents.data() + normalsAndTangentsOffset;
-            offset += mesh.vertices.size();
-            normalsAndTangentsOffset += modelMeshNormalsAndTangents->second.size();
-            const float NORMAL_COEFFICIENT_SCALE = 0.01f;
-            for (int i = 0, n = qMin(_blendshapeCoefficients.size(), mesh.blendshapes.size()); i < n; i++) {
-                float vertexCoefficient = _blendshapeCoefficients.at(i);
-                const float EPSILON = 0.0001f;
-                if (vertexCoefficient < EPSILON) {
-                    continue;
-                }
-                float normalCoefficient = vertexCoefficient * NORMAL_COEFFICIENT_SCALE;
-                const FBXBlendshape& blendshape = mesh.blendshapes.at(i);
-                tbb::parallel_for(tbb::blocked_range<int>(0, blendshape.indices.size()), [&](const tbb::blocked_range<int>& range) {
-                    for (auto j = range.begin(); j < range.end(); j++) {
-                        int index = blendshape.indices.at(j);
-                        meshVertices[index] += blendshape.vertices.at(j) * vertexCoefficient;
-
-                        glm::vec3 normal = mesh.normals.at(index) + blendshape.normals.at(j) * normalCoefficient;
-                        glm::vec3 tangent;
-                        if (index < mesh.tangents.size()) {
-                            tangent = mesh.tangents.at(index);
-                            if ((int)j < blendshape.tangents.size()) {
-                                tangent += blendshape.tangents.at(j) * normalCoefficient;
-                            }
-                        }
-#if FBX_PACK_NORMALS
-                        glm::uint32 finalNormal;
-                        glm::uint32 finalTangent;
-                        buffer_helpers::packNormalAndTangent(normal, tangent, finalNormal, finalTangent);
-#else
-                        const auto& finalNormal = normal;
-                        const auto& finalTangent = tangent;
-#endif
-                        meshNormalsAndTangents[2 * index] = finalNormal;
-                        meshNormalsAndTangents[2 * index + 1] = finalTangent;
-                    }
-                });
-            }
-        }
-    }
-    // post the result to the ModelBlender, which will dispatch to the model if still alive
-    QMetaObject::invokeMethod(DependencyManager::get<ModelBlender>().data(), "setBlendedVertices",
-                              Q_ARG(ModelPointer, _model), Q_ARG(int, _blendNumber), Q_ARG(QVector<glm::vec3>, vertices),
-                              Q_ARG(QVector<NormalType>, normalsAndTangents));
-}
-
 void Model::setScaleToFit(bool scaleToFit, const glm::vec3& dimensions, bool forceRescale) {
    if (forceRescale || _scaleToFit != scaleToFit || _scaleToFitDimensions != dimensions) {
        _scaleToFit = scaleToFit;
@ -1531,44 +1445,6 @@ void Model::updateClusterMatrices() {
    }
 }

-bool Model::maybeStartBlender() {
-    if (isLoaded()) {
-        const FBXGeometry& fbxGeometry = getFBXGeometry();
-        if (fbxGeometry.hasBlendedMeshes()) {
-            QThreadPool::globalInstance()->start(new Blender(getThisPointer(), ++_blendNumber, _renderGeometry, _blendshapeCoefficients));
-            return true;
-        }
-    }
-    return false;
-}
-
-void Model::setBlendedVertices(int blendNumber, const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents) {
-    if (!isLoaded() || blendNumber < _appliedBlendNumber || !_blendedVertexBuffersInitialized) {
-        return;
-    }
-    _appliedBlendNumber = blendNumber;
-    const FBXGeometry& fbxGeometry = getFBXGeometry();
-    int index = 0;
-    int normalAndTangentIndex = 0;
-    for (int i = 0; i < fbxGeometry.meshes.size(); i++) {
-        const FBXMesh& mesh = fbxGeometry.meshes.at(i);
-        auto meshNormalsAndTangents = _normalsAndTangents.find(i);
-        const auto& buffer = _blendedVertexBuffers.find(i);
-        if (mesh.blendshapes.isEmpty() || meshNormalsAndTangents == _normalsAndTangents.end() || buffer == _blendedVertexBuffers.end()) {
-            continue;
-        }
-
-        const auto vertexCount = mesh.vertices.size();
-        const auto verticesSize = vertexCount * sizeof(glm::vec3);
-        buffer->second->resize(mesh.vertices.size() * sizeof(glm::vec3) + meshNormalsAndTangents->second.size() * sizeof(NormalType));
-        buffer->second->setSubData(0, verticesSize, (gpu::Byte*) vertices.constData() + index * sizeof(glm::vec3));
-        buffer->second->setSubData(verticesSize, meshNormalsAndTangents->second.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data() + normalAndTangentIndex * sizeof(NormalType));
-
-        index += vertexCount;
-        normalAndTangentIndex += meshNormalsAndTangents->second.size();
-    }
-}
-
 void Model::deleteGeometry() {
    _deleteGeometryCounter++;
    _blendedVertexBuffers.clear();
@ -1605,42 +1481,6 @@ const render::ItemIDs& Model::fetchRenderItemIDs() const {
    return _modelMeshRenderItemIDs;
 }

-void Model::initializeBlendshapes(const FBXMesh& mesh, int index) {
-    _blendedVertexBuffers[index] = std::make_shared<gpu::Buffer>();
-    QVector<NormalType> normalsAndTangents;
-    normalsAndTangents.resize(2 * mesh.normals.size());
-
-    // Interleave normals and tangents
-    // Parallel version for performance
-    tbb::parallel_for(tbb::blocked_range<int>(0, mesh.normals.size()), [&](const tbb::blocked_range<int>& range) {
-        auto normalsRange = std::make_pair(mesh.normals.begin() + range.begin(), mesh.normals.begin() + range.end());
-        auto tangentsRange = std::make_pair(mesh.tangents.begin() + range.begin(), mesh.tangents.begin() + range.end());
-        auto normalsAndTangentsIt = normalsAndTangents.begin() + 2 * range.begin();
-
-        for (auto normalIt = normalsRange.first, tangentIt = tangentsRange.first;
-            normalIt != normalsRange.second;
-            ++normalIt, ++tangentIt) {
-#if FBX_PACK_NORMALS
-            glm::uint32 finalNormal;
-            glm::uint32 finalTangent;
-            buffer_helpers::packNormalAndTangent(*normalIt, *tangentIt, finalNormal, finalTangent);
-#else
-            const auto& finalNormal = *normalIt;
-            const auto& finalTangent = *tangentIt;
-#endif
-            *normalsAndTangentsIt = finalNormal;
-            ++normalsAndTangentsIt;
-            *normalsAndTangentsIt = finalTangent;
-            ++normalsAndTangentsIt;
-        }
-    });
-    const auto verticesSize = mesh.vertices.size() * sizeof(glm::vec3);
-    _blendedVertexBuffers[index]->resize(mesh.vertices.size() * sizeof(glm::vec3) + normalsAndTangents.size() * sizeof(NormalType));
-    _blendedVertexBuffers[index]->setSubData(0, verticesSize, (const gpu::Byte*) mesh.vertices.constData());
-    _blendedVertexBuffers[index]->setSubData(verticesSize, normalsAndTangents.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data());
-    _normalsAndTangents[index] = normalsAndTangents;
-}
-
 void Model::createRenderItemSet() {
    assert(isLoaded());
    const auto& meshes = _renderGeometry->getMeshes();
@ -1774,6 +1614,164 @@ public:
    }
 };

+
+class Blender : public QRunnable {
+public:
+
+    Blender(ModelPointer model, int blendNumber, const Geometry::WeakPointer& geometry, const QVector<float>& blendshapeCoefficients);
+
+    virtual void run() override;
+
+private:
+
+    ModelPointer _model;
+    int _blendNumber;
+    Geometry::WeakPointer _geometry;
+    QVector<float> _blendshapeCoefficients;
+};
+
+Blender::Blender(ModelPointer model, int blendNumber, const Geometry::WeakPointer& geometry, const QVector<float>& blendshapeCoefficients) :
+    _model(model),
+    _blendNumber(blendNumber),
+    _geometry(geometry),
+    _blendshapeCoefficients(blendshapeCoefficients) {
+}
+
+void Blender::run() {
+    QVector<glm::vec3> vertices;
+    QVector<NormalType> normalsAndTangents;
+    if (_model && _model->isLoaded()) {
+        DETAILED_PROFILE_RANGE_EX(simulation_animation, __FUNCTION__, 0xFFFF0000, 0, { { "url", _model->getURL().toString() } });
+        int offset = 0;
+        int normalsAndTangentsOffset = 0;
+        auto meshes = _model->getFBXGeometry().meshes;
+        int meshIndex = 0;
+        foreach(const FBXMesh& mesh, meshes) {
+            auto modelMeshNormalsAndTangents = _model->_normalsAndTangents.find(meshIndex++);
+            if (mesh.blendshapes.isEmpty() || modelMeshNormalsAndTangents == _model->_normalsAndTangents.end()) {
+                continue;
+            }
+
+            vertices += mesh.vertices;
+            normalsAndTangents += modelMeshNormalsAndTangents->second;
+            glm::vec3* meshVertices = vertices.data() + offset;
+            NormalType* meshNormalsAndTangents = normalsAndTangents.data() + normalsAndTangentsOffset;
+            offset += mesh.vertices.size();
+            normalsAndTangentsOffset += modelMeshNormalsAndTangents->second.size();
+            const float NORMAL_COEFFICIENT_SCALE = 0.01f;
+            for (int i = 0, n = qMin(_blendshapeCoefficients.size(), mesh.blendshapes.size()); i < n; i++) {
+                float vertexCoefficient = _blendshapeCoefficients.at(i);
+                const float EPSILON = 0.0001f;
+                if (vertexCoefficient < EPSILON) {
+                    continue;
+                }
+                float normalCoefficient = vertexCoefficient * NORMAL_COEFFICIENT_SCALE;
+                const FBXBlendshape& blendshape = mesh.blendshapes.at(i);
+                tbb::parallel_for(tbb::blocked_range<int>(0, blendshape.indices.size()), [&](const tbb::blocked_range<int>& range) {
+                    for (auto j = range.begin(); j < range.end(); j++) {
+                        int index = blendshape.indices.at(j);
+                        meshVertices[index] += blendshape.vertices.at(j) * vertexCoefficient;
+
+                        glm::vec3 normal = mesh.normals.at(index) + blendshape.normals.at(j) * normalCoefficient;
+                        glm::vec3 tangent;
+                        if (index < mesh.tangents.size()) {
+                            tangent = mesh.tangents.at(index);
+                            if ((int)j < blendshape.tangents.size()) {
+                                tangent += blendshape.tangents.at(j) * normalCoefficient;
+                            }
+                        }
+#if FBX_PACK_NORMALS
+                        glm::uint32 finalNormal;
+                        glm::uint32 finalTangent;
+                        buffer_helpers::packNormalAndTangent(normal, tangent, finalNormal, finalTangent);
+#else
+                        const auto& finalNormal = normal;
+                        const auto& finalTangent = tangent;
+#endif
+                        meshNormalsAndTangents[2 * index] = finalNormal;
+                        meshNormalsAndTangents[2 * index + 1] = finalTangent;
+                    }
+                });
+            }
+        }
+    }
+    // post the result to the ModelBlender, which will dispatch to the model if still alive
+    QMetaObject::invokeMethod(DependencyManager::get<ModelBlender>().data(), "setBlendedVertices",
+        Q_ARG(ModelPointer, _model), Q_ARG(int, _blendNumber), Q_ARG(QVector<glm::vec3>, vertices),
+        Q_ARG(QVector<NormalType>, normalsAndTangents));
+}
+
+bool Model::maybeStartBlender() {
+    if (isLoaded()) {
+        QThreadPool::globalInstance()->start(new Blender(getThisPointer(), ++_blendNumber, _renderGeometry, _blendshapeCoefficients));
+        return true;
+    }
+    return false;
+}
+
+void Model::setBlendedVertices(int blendNumber, const QVector<glm::vec3>& vertices, const QVector<NormalType>& normalsAndTangents) {
+    if (!isLoaded() || blendNumber < _appliedBlendNumber || !_blendedVertexBuffersInitialized) {
+        return;
+    }
+    _appliedBlendNumber = blendNumber;
+    const FBXGeometry& fbxGeometry = getFBXGeometry();
+    int index = 0;
+    int normalAndTangentIndex = 0;
+    for (int i = 0; i < fbxGeometry.meshes.size(); i++) {
+        const FBXMesh& mesh = fbxGeometry.meshes.at(i);
+        auto meshNormalsAndTangents = _normalsAndTangents.find(i);
+        const auto& buffer = _blendedVertexBuffers.find(i);
+        if (mesh.blendshapes.isEmpty() || meshNormalsAndTangents == _normalsAndTangents.end() || buffer == _blendedVertexBuffers.end()) {
+            continue;
+        }
+
+        const auto vertexCount = mesh.vertices.size();
+        const auto verticesSize = vertexCount * sizeof(glm::vec3);
+        buffer->second->resize(mesh.vertices.size() * sizeof(glm::vec3) + meshNormalsAndTangents->second.size() * sizeof(NormalType));
+        buffer->second->setSubData(0, verticesSize, (gpu::Byte*) vertices.constData() + index * sizeof(glm::vec3));
+        buffer->second->setSubData(verticesSize, meshNormalsAndTangents->second.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data() + normalAndTangentIndex * sizeof(NormalType));
+
+        index += vertexCount;
+        normalAndTangentIndex += meshNormalsAndTangents->second.size();
+    }
+}
+
+void Model::initializeBlendshapes(const FBXMesh& mesh, int index) {
+    _blendedVertexBuffers[index] = std::make_shared<gpu::Buffer>();
+    QVector<NormalType> normalsAndTangents;
+    normalsAndTangents.resize(2 * mesh.normals.size());
+
+    // Interleave normals and tangents
+    // Parallel version for performance
+    tbb::parallel_for(tbb::blocked_range<int>(0, mesh.normals.size()), [&](const tbb::blocked_range<int>& range) {
+        auto normalsRange = std::make_pair(mesh.normals.begin() + range.begin(), mesh.normals.begin() + range.end());
+        auto tangentsRange = std::make_pair(mesh.tangents.begin() + range.begin(), mesh.tangents.begin() + range.end());
+        auto normalsAndTangentsIt = normalsAndTangents.begin() + 2 * range.begin();
+
+        for (auto normalIt = normalsRange.first, tangentIt = tangentsRange.first;
+            normalIt != normalsRange.second;
+            ++normalIt, ++tangentIt) {
+#if FBX_PACK_NORMALS
+            glm::uint32 finalNormal;
+            glm::uint32 finalTangent;
+            buffer_helpers::packNormalAndTangent(*normalIt, *tangentIt, finalNormal, finalTangent);
+#else
+            const auto& finalNormal = *normalIt;
+            const auto& finalTangent = *tangentIt;
+#endif
+            *normalsAndTangentsIt = finalNormal;
+            ++normalsAndTangentsIt;
+            *normalsAndTangentsIt = finalTangent;
+            ++normalsAndTangentsIt;
+        }
+    });
+    const auto verticesSize = mesh.vertices.size() * sizeof(glm::vec3);
+    _blendedVertexBuffers[index]->resize(mesh.vertices.size() * sizeof(glm::vec3) + normalsAndTangents.size() * sizeof(NormalType));
+    _blendedVertexBuffers[index]->setSubData(0, verticesSize, (const gpu::Byte*) mesh.vertices.constData());
+    _blendedVertexBuffers[index]->setSubData(verticesSize, normalsAndTangents.size() * sizeof(NormalType), (const gpu::Byte*) normalsAndTangents.data());
+    _normalsAndTangents[index] = normalsAndTangents;
+}
+
 ModelBlender::ModelBlender() :
    _pendingBlenders(0) {
 }
@ -1783,14 +1781,23 @@ ModelBlender::~ModelBlender() {

 void ModelBlender::noteRequiresBlend(ModelPointer model) {
    Lock lock(_mutex);
-    if (_pendingBlenders < QThread::idealThreadCount()) {
-        if (model->maybeStartBlender()) {
-            _pendingBlenders++;
-            return;
-        }
+    if (_modelsRequiringBlendsSet.find(model) == _modelsRequiringBlendsSet.end()) {
+        _modelsRequiringBlendsQueue.push(model);
+        _modelsRequiringBlendsSet.insert(model);
    }

-    _modelsRequiringBlends.insert(model);
+    if (_pendingBlenders < QThread::idealThreadCount()) {
+        while (!_modelsRequiringBlendsQueue.empty()) {
+            auto weakPtr = _modelsRequiringBlendsQueue.front();
+            _modelsRequiringBlendsQueue.pop();
+            _modelsRequiringBlendsSet.erase(weakPtr);
+            ModelPointer nextModel = weakPtr.lock();
+            if (nextModel && nextModel->maybeStartBlender()) {
+                _pendingBlenders++;
+                return;
+            }
+        }
+    }
 }

 void ModelBlender::setBlendedVertices(ModelPointer model, int blendNumber, QVector<glm::vec3> vertices, QVector<NormalType> normalsAndTangents) {
@ -1800,20 +1807,15 @@ void ModelBlender::setBlendedVertices(ModelPointer model, int blendNumber, QVect
    {
        Lock lock(_mutex);
        _pendingBlenders--;
-        _modelsRequiringBlends.erase(model);
-        std::set<ModelWeakPointer, std::owner_less<ModelWeakPointer>> modelsToErase;
-        for (auto i = _modelsRequiringBlends.begin(); i != _modelsRequiringBlends.end(); i++) {
-            auto weakPtr = *i;
+        while (!_modelsRequiringBlendsQueue.empty()) {
+            auto weakPtr = _modelsRequiringBlendsQueue.front();
+            _modelsRequiringBlendsQueue.pop();
+            _modelsRequiringBlendsSet.erase(weakPtr);
            ModelPointer nextModel = weakPtr.lock();
            if (nextModel && nextModel->maybeStartBlender()) {
                _pendingBlenders++;
                break;
-            } else {
-                modelsToErase.insert(weakPtr);
            }
        }
-        for (auto& weakPtr : modelsToErase) {
-            _modelsRequiringBlends.erase(weakPtr);
-        }
    }
 }
--- a/libraries/render-utils/src/Model.h
+++ b/libraries/render-utils/src/Model.h
@ -530,7 +530,8 @@ private:
    ModelBlender();
    virtual ~ModelBlender();

-    std::set<ModelWeakPointer, std::owner_less<ModelWeakPointer>> _modelsRequiringBlends;
+    std::queue<ModelWeakPointer> _modelsRequiringBlendsQueue;
+    std::set<ModelWeakPointer, std::owner_less<ModelWeakPointer>> _modelsRequiringBlendsSet;
    int _pendingBlenders;
    Mutex _mutex;

--- a/libraries/shared/src/SettingManager.cpp
+++ b/libraries/shared/src/SettingManager.cpp
@ -52,7 +52,7 @@ namespace Setting {
            if (_pendingChanges.contains(key) && _pendingChanges[key] != UNSET_VALUE) {
                loadedValue = _pendingChanges[key];
            } else {
-                loadedValue = value(key);
+                loadedValue = _qSettings.value(key);
            }
            if (loadedValue.isValid()) {
                handle->setVariant(loadedValue);
@ -92,32 +92,115 @@ namespace Setting {
    }

    void Manager::saveAll() {
-        bool forceSync = false;
        withWriteLock([&] {
+            bool forceSync = false;
            for (auto key : _pendingChanges.keys()) {
                auto newValue = _pendingChanges[key];
-                auto savedValue = value(key, UNSET_VALUE);
+                auto savedValue = _qSettings.value(key, UNSET_VALUE);
                if (newValue == savedValue) {
                    continue;
                }
+                forceSync = true;
                if (newValue == UNSET_VALUE || !newValue.isValid()) {
-                    forceSync = true;
-                    remove(key);
+                    _qSettings.remove(key);
                } else {
-                    forceSync = true;
-                    setValue(key, newValue);
+                    _qSettings.setValue(key, newValue);
                }
            }
            _pendingChanges.clear();
-        });

-        if (forceSync) {
-            sync();
-        }
+            if (forceSync) {
+                _qSettings.sync();
+            }
+        });

        // Restart timer
        if (_saveTimer) {
            _saveTimer->start();
        }
    }
+
+    QString Manager::fileName() const {
+        return resultWithReadLock<QString>([&] {
+            return _qSettings.fileName();
+        });
+    }
+
+    void Manager::remove(const QString &key) {
+        withWriteLock([&] {
+            _qSettings.remove(key);
+        });
+    }
+
+    QStringList Manager::childGroups() const {
+        return resultWithReadLock<QStringList>([&] {
+            return _qSettings.childGroups();
+        });
+    }
+
+    QStringList Manager::childKeys() const {
+        return resultWithReadLock<QStringList>([&] {
+            return _qSettings.childKeys();
+        });
+    }
+
+    QStringList Manager::allKeys() const {
+        return resultWithReadLock<QStringList>([&] {
+            return _qSettings.allKeys();
+        });
+    }
+
+    bool Manager::contains(const QString &key) const {
+        return resultWithReadLock<bool>([&] {
+            return _qSettings.contains(key);
+        });
+    }
+
+    int Manager::beginReadArray(const QString &prefix) {
+        return resultWithReadLock<int>([&] {
+            return _qSettings.beginReadArray(prefix);
+        });
+    }
+
+    void Manager::beginGroup(const QString &prefix) {
+        withWriteLock([&] {
+            _qSettings.beginGroup(prefix);
+        });
+    }
+
+    void Manager::beginWriteArray(const QString &prefix, int size) {
+        withWriteLock([&] {
+            _qSettings.beginWriteArray(prefix, size);
+        });
+    }
+
+    void Manager::endArray() {
+        withWriteLock([&] {
+            _qSettings.endArray();
+        });
+    }
+
+    void Manager::endGroup() {
+        withWriteLock([&] {
+            _qSettings.endGroup();
+        });
+    }
+
+    void Manager::setArrayIndex(int i) {
+        withWriteLock([&] {
+            _qSettings.setArrayIndex(i);
+        });
+    }
+
+    void Manager::setValue(const QString &key, const QVariant &value) {
+        withWriteLock([&] {
+            _qSettings.setValue(key, value);
+        });
+    }
+
+    QVariant Manager::value(const QString &key, const QVariant &defaultValue) const {
+        return resultWithReadLock<QVariant>([&] {
+            return _qSettings.value(key, defaultValue);
+        });
+    }
 }
--- a/libraries/shared/src/SettingManager.h
+++ b/libraries/shared/src/SettingManager.h
@ -23,12 +23,28 @@
 namespace Setting {
    class Interface;

-    class Manager : public QSettings, public ReadWriteLockable, public Dependency {
+    class Manager : public QObject, public ReadWriteLockable, public Dependency {
        Q_OBJECT

    public:
        void customDeleter() override;

+        // thread-safe proxies into QSettings
+        QString fileName() const;
+        void remove(const QString &key);
+        QStringList childGroups() const;
+        QStringList childKeys() const;
+        QStringList allKeys() const;
+        bool contains(const QString &key) const;
+        int beginReadArray(const QString &prefix);
+        void beginGroup(const QString &prefix);
+        void beginWriteArray(const QString &prefix, int size = -1);
+        void endArray();
+        void endGroup();
+        void setArrayIndex(int i);
+        void setValue(const QString &key, const QVariant &value);
+        QVariant value(const QString &key, const QVariant &defaultValue = QVariant()) const;
+
    protected:
        ~Manager();
        void registerHandle(Interface* handle);
@ -52,6 +68,9 @@ namespace Setting {
        friend class Interface;
        friend void cleanupSettingsSaveThread();
        friend void setupSettingsSaveThread();
+
+
+        QSettings _qSettings;
    };
 }

--- a/libraries/shared/src/SharedUtil.cpp
+++ b/libraries/shared/src/SharedUtil.cpp
@ -19,8 +19,8 @@
 #include <time.h>
 #include <mutex>
 #include <thread>
-#include <set>
 #include <unordered_map>
+#include <chrono>

 #include <glm/glm.hpp>

@ -127,82 +127,10 @@ void usecTimestampNowForceClockSkew(qint64 clockSkew) {
    ::usecTimestampNowAdjust = clockSkew;
 }

-static std::atomic<qint64> TIME_REFERENCE { 0 }; // in usec
-static std::once_flag usecTimestampNowIsInitialized;
-static QElapsedTimer timestampTimer;
-
 quint64 usecTimestampNow(bool wantDebug) {
-    std::call_once(usecTimestampNowIsInitialized, [&] {
-        TIME_REFERENCE = QDateTime::currentMSecsSinceEpoch() * USECS_PER_MSEC; // ms to usec
-        timestampTimer.start();
-    });
-    
-    quint64 now;
-    quint64 nsecsElapsed = timestampTimer.nsecsElapsed();
-    quint64 usecsElapsed = nsecsElapsed / NSECS_PER_USEC;  // nsec to usec
-    
-    // QElapsedTimer may not advance if the CPU has gone to sleep. In which case it
-    // will begin to deviate from real time. We detect that here, and reset if necessary
-    quint64 msecsCurrentTime = QDateTime::currentMSecsSinceEpoch();
-    quint64 msecsEstimate = (TIME_REFERENCE + usecsElapsed) / USECS_PER_MSEC; // usecs to msecs
-    int possibleSkew = msecsEstimate - msecsCurrentTime;
-    const int TOLERANCE = 10 * MSECS_PER_SECOND; // up to 10 seconds of skew is tolerated
-    if (abs(possibleSkew) > TOLERANCE) {
-        // reset our TIME_REFERENCE and timer
-        TIME_REFERENCE = QDateTime::currentMSecsSinceEpoch() * USECS_PER_MSEC; // ms to usec
-        timestampTimer.restart();
-        now = TIME_REFERENCE + ::usecTimestampNowAdjust;
-
-        if (wantDebug) {
-            qCDebug(shared) << "usecTimestampNow() - resetting QElapsedTimer. ";
-            qCDebug(shared) << "    msecsCurrentTime:" << msecsCurrentTime;
-            qCDebug(shared) << "       msecsEstimate:" << msecsEstimate;
-            qCDebug(shared) << "        possibleSkew:" << possibleSkew;
-            qCDebug(shared) << "           TOLERANCE:" << TOLERANCE;
-            
-            qCDebug(shared) << "        nsecsElapsed:" << nsecsElapsed;
-            qCDebug(shared) << "        usecsElapsed:" << usecsElapsed;
-
-            QDateTime currentLocalTime = QDateTime::currentDateTime();
-
-            quint64 msecsNow = now / 1000; // usecs to msecs
-            QDateTime nowAsString;
-            nowAsString.setMSecsSinceEpoch(msecsNow);
-
-            qCDebug(shared) << "                 now:" << now;
-            qCDebug(shared) << "            msecsNow:" << msecsNow;
-
-            qCDebug(shared) << "         nowAsString:" << nowAsString.toString("yyyy-MM-dd hh:mm:ss.zzz");
-            qCDebug(shared) << "    currentLocalTime:" << currentLocalTime.toString("yyyy-MM-dd hh:mm:ss.zzz");
-        }
-    } else {
-        now = TIME_REFERENCE + usecsElapsed + ::usecTimestampNowAdjust;
-    }
-
-    if (wantDebug) {
-        QDateTime currentLocalTime = QDateTime::currentDateTime();
-
-        quint64 msecsNow = now / 1000; // usecs to msecs
-        QDateTime nowAsString;
-        nowAsString.setMSecsSinceEpoch(msecsNow);
-
-        quint64 msecsTimeReference = TIME_REFERENCE / 1000; // usecs to msecs
-        QDateTime timeReferenceAsString;
-        timeReferenceAsString.setMSecsSinceEpoch(msecsTimeReference);
-
-        qCDebug(shared) << "usecTimestampNow() - details... ";
-        qCDebug(shared) << "           TIME_REFERENCE:" << TIME_REFERENCE;
-        qCDebug(shared) << "    timeReferenceAsString:" << timeReferenceAsString.toString("yyyy-MM-dd hh:mm:ss.zzz");
-        qCDebug(shared) << "   usecTimestampNowAdjust:" << usecTimestampNowAdjust;
-        qCDebug(shared) << "             nsecsElapsed:" << nsecsElapsed;
-        qCDebug(shared) << "             usecsElapsed:" << usecsElapsed;
-        qCDebug(shared) << "                      now:" << now;
-        qCDebug(shared) << "                 msecsNow:" << msecsNow;
-        qCDebug(shared) << "              nowAsString:" << nowAsString.toString("yyyy-MM-dd hh:mm:ss.zzz");
-        qCDebug(shared) << "         currentLocalTime:" << currentLocalTime.toString("yyyy-MM-dd hh:mm:ss.zzz");
-    }
-    
-    return now;
+    using namespace std::chrono;
+    static const auto unixEpoch = system_clock::from_time_t(0);
+    return duration_cast<microseconds>(system_clock::now() - unixEpoch).count() + usecTimestampNowAdjust;
 }

 float secTimestampNow() {
--- a/scripts/system/commerce/wallet.js
+++ b/scripts/system/commerce/wallet.js
@ -500,6 +500,35 @@ function walletClosed() {
 //
 // Manage the connection between the button and the window.
 //
+var DEVELOPER_MENU = "Developer";
+var MARKETPLACE_ITEM_TESTER_LABEL = "Marketplace Item Tester";
+var MARKETPLACE_ITEM_TESTER_QML_SOURCE = "hifi/commerce/marketplaceItemTester/MarketplaceItemTester.qml";
+function installMarketplaceItemTester() {
+    if (!Menu.menuExists(DEVELOPER_MENU)) {
+       Menu.addMenu(DEVELOPER_MENU);
+    }
+    if (!Menu.menuItemExists(DEVELOPER_MENU, MARKETPLACE_ITEM_TESTER_LABEL)) {
+        Menu.addMenuItem({ menuName: DEVELOPER_MENU,
+                           menuItemName: MARKETPLACE_ITEM_TESTER_LABEL,
+                           isCheckable: false })
+    }
+
+    Menu.menuItemEvent.connect(function (menuItem) {
+        if (menuItem === MARKETPLACE_ITEM_TESTER_LABEL) {
+            var tablet = Tablet.getTablet("com.highfidelity.interface.tablet.system");
+            tablet.loadQMLSource(MARKETPLACE_ITEM_TESTER_QML_SOURCE);
+        }
+    });
+}
+
+function uninstallMarketplaceItemTester() {
+    if (Menu.menuExists(DEVELOPER_MENU) &&
+        Menu.menuItemExists(DEVELOPER_MENU, MARKETPLACE_ITEM_TESTER_LABEL)
+    ) {
+        Menu.removeMenuItem(DEVELOPER_MENU, MARKETPLACE_ITEM_TESTER_LABEL);
+    }
+}
+
 var BUTTON_NAME = "WALLET";
 var WALLET_QML_SOURCE = "hifi/commerce/wallet/Wallet.qml";
 var ui;
@ -513,7 +542,9 @@ function startup() {
        onMessage: fromQml
    });
    GlobalServices.myUsernameChanged.connect(onUsernameChanged);
+    installMarketplaceItemTester();
 }
+
 var isUpdateOverlaysWired = false;
 function off() {
    Users.usernameFromIDReply.disconnect(usernameFromIDReply);
@ -528,9 +559,11 @@ function off() {
    }
    removeOverlays();
 }
+
 function shutdown() {
    GlobalServices.myUsernameChanged.disconnect(onUsernameChanged);
    deleteSendMoneyParticleEffect();
+    uninstallMarketplaceItemTester();
    off();
 }

--- a/scripts/system/controllers/controllerModules/highlightNearbyEntities.js
+++ b/scripts/system/controllers/controllerModules/highlightNearbyEntities.js
@ -37,7 +37,7 @@
        this.highlightedEntities = [];

        this.parameters = dispatcherUtils.makeDispatcherModuleParameters(
-            120,
+            480,
            this.hand === dispatcherUtils.RIGHT_HAND ? ["rightHand"] : ["leftHand"],
            [],
            100);
--- a/scripts/system/controllers/controllerModules/inEditMode.js
+++ b/scripts/system/controllers/controllerModules/inEditMode.js
@ -29,7 +29,7 @@ Script.include("/~/system/libraries/utils.js");
        this.reticleMaxY;

        this.parameters = makeDispatcherModuleParameters(
-            200,
+            160,
            this.hand === RIGHT_HAND ? ["rightHand", "rightHandEquip", "rightHandTrigger"] : ["leftHand", "leftHandEquip", "leftHandTrigger"],
            [],
            100,
--- a/scripts/system/controllers/controllerModules/inVREditMode.js
+++ b/scripts/system/controllers/controllerModules/inVREditMode.js
@ -21,7 +21,7 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
        this.disableModules = false;
        var NO_HAND_LASER = -1; // Invalid hand parameter so that default laser is not displayed.
        this.parameters = makeDispatcherModuleParameters(
-            240, // Not too high otherwise the tablet laser doesn't work.
+            200, // Not too high otherwise the tablet laser doesn't work.
            this.hand === RIGHT_HAND
                ? ["rightHand", "rightHandEquip", "rightHandTrigger"]
                : ["leftHand", "leftHandEquip", "leftHandTrigger"],
--- a/scripts/system/controllers/controllerModules/nearActionGrabEntity.js
+++ b/scripts/system/controllers/controllerModules/nearActionGrabEntity.js
@ -26,7 +26,7 @@ Script.include("/~/system/libraries/cloneEntityUtils.js");
        this.hapticTargetID = null;

        this.parameters = makeDispatcherModuleParameters(
-            140,
+            500,
            this.hand === RIGHT_HAND ? ["rightHand"] : ["leftHand"],
            [],
            100);
--- a/scripts/system/controllers/controllerModules/nearGrabHyperLinkEntity.js
+++ b/scripts/system/controllers/controllerModules/nearGrabHyperLinkEntity.js
@ -21,7 +21,7 @@
        this.hyperlink = "";

        this.parameters = makeDispatcherModuleParameters(
-            125,
+            485,
            this.hand === RIGHT_HAND ? ["rightHand"] : ["leftHand"],
            [],
            100);
--- a/scripts/system/controllers/controllerModules/nearParentGrabEntity.js
+++ b/scripts/system/controllers/controllerModules/nearParentGrabEntity.js
@ -57,7 +57,7 @@ Script.include("/~/system/libraries/controllers.js");
        this.cloneAllowed = true;

        this.parameters = makeDispatcherModuleParameters(
-            140,
+            500,
            this.hand === RIGHT_HAND ? ["rightHand"] : ["leftHand"],
            [],
            100);
--- a/scripts/system/controllers/controllerModules/nearTrigger.js
+++ b/scripts/system/controllers/controllerModules/nearTrigger.js
@ -29,7 +29,7 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
        this.startSent = false;

        this.parameters = makeDispatcherModuleParameters(
-            120,
+            480,
            this.hand === RIGHT_HAND ? ["rightHandTrigger", "rightHand"] : ["leftHandTrigger", "leftHand"],
            [],
            100);
--- a/scripts/system/controllers/controllerModules/webSurfaceLaserInput.js
+++ b/scripts/system/controllers/controllerModules/webSurfaceLaserInput.js
@ -121,7 +121,7 @@ Script.include("/~/system/libraries/controllers.js");
                                   controllerData.triggerValues[this.otherHand] <= TRIGGER_OFF_VALUE;
            var allowThisModule = !otherModuleRunning || isTriggerPressed;

-            if (allowThisModule && this.isPointingAtTriggerable(controllerData, isTriggerPressed, false)) {
+            if ((allowThisModule && this.isPointingAtTriggerable(controllerData, isTriggerPressed, false)) && !this.grabModuleWantsNearbyOverlay(controllerData)) {
                this.updateAllwaysOn();
                if (isTriggerPressed) {
                    this.dominantHandOverride = true; // Override dominant hand.
--- a/scripts/system/marketplaces/marketplaces.js
+++ b/scripts/system/marketplaces/marketplaces.js
@ -20,13 +20,14 @@ var AppUi = Script.require('appUi');
 Script.include("/~/system/libraries/gridTool.js");
 Script.include("/~/system/libraries/connectionUtils.js");

-var METAVERSE_SERVER_URL = Account.metaverseServerURL;
-var MARKETPLACES_URL = Script.resolvePath("../html/marketplaces.html");
-var MARKETPLACES_INJECT_SCRIPT_URL = Script.resolvePath("../html/js/marketplacesInject.js");
 var MARKETPLACE_CHECKOUT_QML_PATH = "hifi/commerce/checkout/Checkout.qml";
+var MARKETPLACE_INSPECTIONCERTIFICATE_QML_PATH = "hifi/commerce/inspectionCertificate/InspectionCertificate.qml";
+var MARKETPLACE_ITEM_TESTER_QML_PATH = "hifi/commerce/marketplaceItemTester/MarketplaceItemTester.qml";
 var MARKETPLACE_PURCHASES_QML_PATH = "hifi/commerce/purchases/Purchases.qml";
 var MARKETPLACE_WALLET_QML_PATH = "hifi/commerce/wallet/Wallet.qml";
-var MARKETPLACE_INSPECTIONCERTIFICATE_QML_PATH = "hifi/commerce/inspectionCertificate/InspectionCertificate.qml";
+var MARKETPLACES_INJECT_SCRIPT_URL = Script.resolvePath("../html/js/marketplacesInject.js");
+var MARKETPLACES_URL = Script.resolvePath("../html/marketplaces.html");
+var METAVERSE_SERVER_URL = Account.metaverseServerURL;
 var REZZING_SOUND = SoundCache.getSound(Script.resolvePath("../assets/sounds/rezzing.wav"));

 // Event bridge messages.
@ -797,7 +798,7 @@ function deleteSendAssetParticleEffect() {
    }
    sendAssetRecipient = null;
 }
-    
+
 var savedDisablePreviewOption = Menu.isOptionChecked("Disable Preview");
 var UI_FADE_TIMEOUT_MS = 150;
 function maybeEnableHMDPreview() {
@ -809,6 +810,13 @@ function maybeEnableHMDPreview() {
    }, UI_FADE_TIMEOUT_MS);
 }

+var resourceObjectsInTest = [];
+function signalNewResourceObjectInTest(resourceObject) {
+    ui.tablet.sendToQml({
+        method: "newResourceObjectInTest",
+        resourceObject: resourceObject });
+}
+
 var onQmlMessageReceived = function onQmlMessageReceived(message) {
    if (message.messageSrc === "HTML") {
        return;
@ -866,8 +874,20 @@ var onQmlMessageReceived = function onQmlMessageReceived(message) {
        break;
    case 'checkout_rezClicked':
    case 'purchases_rezClicked':
+    case 'tester_rezClicked':
        rezEntity(message.itemHref, message.itemType);
        break;
+    case 'tester_newResourceObject':
+        var resourceObject = message.resourceObject;
+        resourceObjectsInTest[resourceObject.id] = resourceObject;
+        signalNewResourceObjectInTest(resourceObject);
+        break;
+    case 'tester_updateResourceObjectAssetType':
+        resourceObjectsInTest[message.objectId].assetType = message.assetType;
+        break;
+    case 'tester_deleteResourceObject':
+        delete resourceObjectsInTest[message.objectId];
+        break;
    case 'header_marketplaceImageClicked':
    case 'purchases_backClicked':
        openMarketplace(message.referrerURL);
@ -890,10 +910,6 @@ var onQmlMessageReceived = function onQmlMessageReceived(message) {
        openLoginWindow();
        break;
    case 'disableHmdPreview':
-        if (!savedDisablePreviewOption) {
-            savedDisablePreviewOption = Menu.isOptionChecked("Disable Preview");
-        }
-
        if (!savedDisablePreviewOption) {
            DesktopPreviewProvider.setPreviewDisabledReason("SECURE_SCREEN");
            Menu.setIsOptionChecked("Disable Preview", true);
@ -1011,34 +1027,60 @@ var onQmlMessageReceived = function onQmlMessageReceived(message) {
    }
 };

+function pushResourceObjectsInTest() {
+    var maxObjectId = -1;
+    for (var objectId in resourceObjectsInTest) {
+        signalNewResourceObjectInTest(resourceObjectsInTest[objectId]);
+        maxObjectId = (maxObjectId < objectId) ? parseInt(objectId) : maxObjectId;
+    }
+    // N.B. Thinking about removing the following sendToQml? Be sure
+    // that the marketplace item tester QML has heard from us, at least
+    // so that it can indicate to the user that all of the resoruce
+    // objects in test have been transmitted to it.
+    ui.tablet.sendToQml({ method: "nextObjectIdInTest", id: maxObjectId + 1 });
+}
+
 // Function Name: onTabletScreenChanged()
 //
 // Description:
 //   -Called when the TabletScriptingInterface::screenChanged() signal is emitted. The "type" argument can be either the string
 //    value of "Home", "Web", "Menu", "QML", or "Closed". The "url" argument is only valid for Web and QML.
-var onMarketplaceScreen = false;
-var onWalletScreen = false;
+
 var onCommerceScreen = false;
 var onInspectionCertificateScreen = false;
+var onMarketplaceItemTesterScreen = false;
+var onMarketplaceScreen = false;
+var onWalletScreen = false;
 var onTabletScreenChanged = function onTabletScreenChanged(type, url) {
    ui.setCurrentVisibleScreenMetadata(type, url);
    onMarketplaceScreen = type === "Web" && url.indexOf(MARKETPLACE_URL) !== -1;
    onInspectionCertificateScreen = type === "QML" && url.indexOf(MARKETPLACE_INSPECTIONCERTIFICATE_QML_PATH) !== -1;
    var onWalletScreenNow = url.indexOf(MARKETPLACE_WALLET_QML_PATH) !== -1;
-    var onCommerceScreenNow = type === "QML" &&
-        (url.indexOf(MARKETPLACE_CHECKOUT_QML_PATH) !== -1 || url === MARKETPLACE_PURCHASES_QML_PATH ||
-        onInspectionCertificateScreen);
+    var onCommerceScreenNow = type === "QML" && (
+        url.indexOf(MARKETPLACE_CHECKOUT_QML_PATH) !== -1 ||
+        url === MARKETPLACE_PURCHASES_QML_PATH ||
+        url.indexOf(MARKETPLACE_INSPECTIONCERTIFICATE_QML_PATH) !== -1);
+    var onMarketplaceItemTesterScreenNow = (
+        url.indexOf(MARKETPLACE_ITEM_TESTER_QML_PATH) !== -1 ||
+        url === MARKETPLACE_ITEM_TESTER_QML_PATH);

-    // exiting wallet or commerce screen
-    if ((!onWalletScreenNow && onWalletScreen) || (!onCommerceScreenNow && onCommerceScreen)) {
+    if ((!onWalletScreenNow && onWalletScreen) ||
+        (!onCommerceScreenNow && onCommerceScreen) ||
+        (!onMarketplaceItemTesterScreenNow && onMarketplaceScreen)
+    ) {
+        // exiting wallet, commerce, or marketplace item tester screen
        maybeEnableHMDPreview();
    }

    onCommerceScreen = onCommerceScreenNow;
    onWalletScreen = onWalletScreenNow;
-    wireQmlEventBridge(onCommerceScreen || onWalletScreen);
+    onMarketplaceItemTesterScreen = onMarketplaceItemTesterScreenNow;
+    wireQmlEventBridge(onCommerceScreen || onWalletScreen || onMarketplaceItemTesterScreen);

    if (url === MARKETPLACE_PURCHASES_QML_PATH) {
+        // FIXME? Is there a race condition here in which the event
+        // bridge may not be up yet? If so, Script.setTimeout(..., 750)
+        // may help avoid the condition.
        ui.tablet.sendToQml({
            method: 'updatePurchases',
            referrerURL: referrerURL,
@ -1076,6 +1118,14 @@ var onTabletScreenChanged = function onTabletScreenChanged(type, url) {
        });
        off();
    }
+
+    if (onMarketplaceItemTesterScreen) {
+        // Why setTimeout? The QML event bridge, wired above, requires a
+        // variable amount of time to come up, in practice less than
+        // 750ms.
+        Script.setTimeout(pushResourceObjectsInTest, 750);
+    }
+
    console.debug(ui.buttonName + " app reports: Tablet screen changed.\nNew screen type: " + type +
        "\nNew screen URL: " + url + "\nCurrent app open status: " + ui.isOpen + "\n");
 };