Merge remote-tracking branch 'hifi/master' into android_jump

2025-04-27 06:35:32 +02:00 · 2018-04-03 16:12:17 -03:00 · 2018-04-03 16:12:17 -03:00 · cbf13c9f8c
commit cbf13c9f8c
parent 1ea056a8a9 987aa40783
50 changed files with 1025 additions and 162 deletions
--- a/assignment-client/src/entities/EntityServer.cpp
+++ b/assignment-client/src/entities/EntityServer.cpp
@ -470,7 +470,6 @@ void EntityServer::startDynamicDomainVerification() {
                // Delete the entity if it doesn't pass static certificate verification
                tree->deleteEntity(i.value(), true);
            } else {
-
                QNetworkAccessManager& networkAccessManager = NetworkAccessManager::getInstance();
                QNetworkRequest networkRequest;
                networkRequest.setAttribute(QNetworkRequest::FollowRedirectsAttribute, true);
@ -490,9 +489,13 @@ void EntityServer::startDynamicDomainVerification() {

                    if (networkReply->error() == QNetworkReply::NoError) {
                        if (jsonObject["domain_id"].toString() != thisDomainID) {
-                            qCDebug(entities) << "Entity's cert's domain ID" << jsonObject["domain_id"].toString()
-                                << "doesn't match the current Domain ID" << thisDomainID << "; deleting entity" << i.value();
-                            tree->deleteEntity(i.value(), true);
+                            if (entity->getAge() > (_MAXIMUM_DYNAMIC_DOMAIN_VERIFICATION_TIMER_MS/MSECS_PER_SECOND)) {
+                                qCDebug(entities) << "Entity's cert's domain ID" << jsonObject["domain_id"].toString()
+                                    << "doesn't match the current Domain ID" << thisDomainID << "; deleting entity" << i.value();
+                                tree->deleteEntity(i.value(), true);
+                            } else {
+                                qCDebug(entities) << "Entity failed dynamic domain verification, but was created too recently to necessitate deletion:" << i.value();
+                            }
                        } else {
                            qCDebug(entities) << "Entity passed dynamic domain verification:" << i.value();
                        }
--- a/interface/resources/qml/AudioScopeUI.qml
+++ b/interface/resources/qml/AudioScopeUI.qml
--- a/interface/resources/qml/hifi/commerce/checkout/Checkout.qml
+++ b/interface/resources/qml/hifi/commerce/checkout/Checkout.qml
@ -96,6 +96,7 @@ Rectangle {
                root.activeView = "checkoutFailure";
                UserActivityLogger.commercePurchaseFailure(root.itemId, root.itemAuthor, root.itemPrice, !root.alreadyOwned, result.message);
            } else {
+                root.certificateId = result.data.certificate_id;
                root.itemHref = result.data.download_url;
                if (result.data.categories.indexOf("Wearables") > -1) {
                    root.itemType = "wearable";
@ -188,7 +189,7 @@ Rectangle {
    onItemHrefChanged: {
        if (root.itemHref.indexOf(".fst") > -1) {
            root.itemType = "avatar";
-        } else if (root.itemHref.indexOf('.json.gz') > -1) {
+        } else if (root.itemHref.indexOf('.json.gz') > -1 || root.itemHref.indexOf('.content.zip') > -1) {
            root.itemType = "contentSet";
        } else if (root.itemHref.indexOf('.app.json') > -1) {
            root.itemType = "app";
@ -772,7 +773,7 @@ Rectangle {
                    lightboxPopup.button1text = "CANCEL";
                    lightboxPopup.button1method = "root.visible = false;"
                    lightboxPopup.button2text = "CONFIRM";
-                    lightboxPopup.button2method = "Commerce.replaceContentSet('" + root.itemHref + "');" + 
+                    lightboxPopup.button2method = "Commerce.replaceContentSet('" + root.itemHref + "', '" + root.certificateId + "');" + 
                    "root.visible = false;rezzedNotifContainer.visible = true; rezzedNotifContainerTimer.start();" + 
                    "UserActivityLogger.commerceEntityRezzed('" + root.itemId + "', 'checkout', '" + root.itemType + "');";
                    lightboxPopup.visible = true;
--- a/interface/resources/qml/hifi/commerce/purchases/PurchasedItem.qml
+++ b/interface/resources/qml/hifi/commerce/purchases/PurchasedItem.qml
@ -564,7 +564,7 @@ Item {
            onClicked: {
                Tablet.playSound(TabletEnums.ButtonClick);
                if (root.itemType === "contentSet") {
-                    sendToPurchases({method: 'showReplaceContentLightbox', itemHref: root.itemHref});
+                    sendToPurchases({method: 'showReplaceContentLightbox', itemHref: root.itemHref, certID: root.certificateId});
                } else if (root.itemType === "avatar") {
                    sendToPurchases({method: 'showChangeAvatarLightbox', itemName: root.itemName, itemHref: root.itemHref});
                } else if (root.itemType === "app") {
--- a/interface/resources/qml/hifi/commerce/purchases/Purchases.qml
+++ b/interface/resources/qml/hifi/commerce/purchases/Purchases.qml
@ -486,7 +486,7 @@ Rectangle {
                            lightboxPopup.button1text = "CANCEL";
                            lightboxPopup.button1method = "root.visible = false;"
                            lightboxPopup.button2text = "CONFIRM";
-                            lightboxPopup.button2method = "Commerce.replaceContentSet('" + msg.itemHref + "'); root.visible = false;";
+                            lightboxPopup.button2method = "Commerce.replaceContentSet('" + msg.itemHref + "', '" + msg.certID + "'); root.visible = false;";
                            lightboxPopup.visible = true;
                        } else if (msg.method === "showChangeAvatarLightbox") {
                            lightboxPopup.titleText = "Change Avatar";
@ -792,7 +792,7 @@ Rectangle {
                currentItemType = "avatar";
            } else if (currentCategories.indexOf("Wearables") > -1) {
                currentItemType = "wearable";
-            } else if (currentRootFileUrl.endsWith('.json.gz')) {
+            } else if (currentRootFileUrl.endsWith('.json.gz') || currentRootFileUrl.endsWith('.content.zip')) {
                currentItemType = "contentSet";
            } else if (currentRootFileUrl.endsWith('.app.json')) {
                currentItemType = "app";
--- a/interface/resources/qml/hifi/tablet/NewModelDialog.qml
+++ b/interface/resources/qml/hifi/tablet/NewModelDialog.qml
@ -71,6 +71,14 @@ Rectangle {
            onAccepted: {
                newModelDialog.keyboardEnabled = false;
            }
+
+            onTextChanged : {
+                if (modelURL.text.length === 0){
+                    button1.enabled = false;
+                } else {
+                    button1.enabled = true;
+                }
+            }
            
            MouseArea {
                anchors.fill: parent
@ -200,6 +208,7 @@ Rectangle {
                        id: button1
                        text: qsTr("Add")
                        z: -1
+                        enabled: false
                        onClicked: {
                            newModelDialog.sendToScript({
                                method: "newModelDialogAdd",
--- a/interface/src/Application.cpp
+++ b/interface/src/Application.cpp
@ -7455,7 +7455,7 @@ DisplayPluginPointer Application::getActiveDisplayPlugin() const {
        return _displayPlugin;
    }

-    if (!_displayPlugin) {
+    if (!_aboutToQuit && !_displayPlugin) {
        const_cast<Application*>(this)->updateDisplayMode();
        Q_ASSERT(_displayPlugin);
    }
--- a/interface/src/avatar/MyAvatar.cpp
+++ b/interface/src/avatar/MyAvatar.cpp
@ -67,8 +67,8 @@ using namespace std;

 const float DEFAULT_REAL_WORLD_FIELD_OF_VIEW_DEGREES = 30.0f;

-const float YAW_SPEED_DEFAULT = 100.0f;   // degrees/sec
-const float PITCH_SPEED_DEFAULT = 75.0f; // degrees/sec
+const float YAW_SPEED_DEFAULT = 75.0f;   // degrees/sec
+const float PITCH_SPEED_DEFAULT = 50.0f; // degrees/sec

 const float MAX_BOOST_SPEED = 0.5f * DEFAULT_AVATAR_MAX_WALKING_SPEED; // action motor gets additive boost below this speed
 const float MIN_AVATAR_SPEED = 0.05f;
@ -2227,7 +2227,7 @@ void MyAvatar::updateActionMotor(float deltaTime) {
    }

    float boomChange = getDriveKey(ZOOM);
-    _boomLength += 2.0f * _boomLength * boomChange + boomChange * boomChange;
+    _boomLength += 4.0f * _boomLength * boomChange + boomChange * boomChange;
    _boomLength = glm::clamp<float>(_boomLength, ZOOM_MIN, ZOOM_MAX);
 }

@ -2760,6 +2760,18 @@ bool MyAvatar::isDriveKeyDisabled(DriveKeys key) const {
    }
 }

+void MyAvatar::triggerVerticalRecenter() {
+    _follow.setForceActivateVertical(true);
+}
+
+void MyAvatar::triggerHorizontalRecenter() {
+    _follow.setForceActivateHorizontal(true);
+}
+
+void MyAvatar::triggerRotationRecenter() {
+    _follow.setForceActivateRotation(true);
+}
+
 // old school meat hook style
 glm::mat4 MyAvatar::deriveBodyFromHMDSensor() const {
    glm::vec3 headPosition;
@ -2957,7 +2969,9 @@ void MyAvatar::FollowHelper::decrementTimeRemaining(float dt) {
 bool MyAvatar::FollowHelper::shouldActivateRotation(const MyAvatar& myAvatar, const glm::mat4& desiredBodyMatrix, const glm::mat4& currentBodyMatrix) const {
    const float FOLLOW_ROTATION_THRESHOLD = cosf(PI / 6.0f); // 30 degrees
    glm::vec2 bodyFacing = getFacingDir2D(currentBodyMatrix);
+    
    return glm::dot(-myAvatar.getHeadControllerFacingMovingAverage(), bodyFacing) < FOLLOW_ROTATION_THRESHOLD;
+    
 }

 bool MyAvatar::FollowHelper::shouldActivateHorizontal(const MyAvatar& myAvatar, const glm::mat4& desiredBodyMatrix, const glm::mat4& currentBodyMatrix) const {
@ -2974,6 +2988,7 @@ bool MyAvatar::FollowHelper::shouldActivateHorizontal(const MyAvatar& myAvatar,
    const float MAX_FORWARD_LEAN = 0.15f;
    const float MAX_BACKWARD_LEAN = 0.1f;

+
    if (forwardLeanAmount > 0 && forwardLeanAmount > MAX_FORWARD_LEAN) {
        return true;
    } else if (forwardLeanAmount < 0 && forwardLeanAmount < -MAX_BACKWARD_LEAN) {
@ -2981,6 +2996,7 @@ bool MyAvatar::FollowHelper::shouldActivateHorizontal(const MyAvatar& myAvatar,
    }

    return fabs(lateralLeanAmount) > MAX_LATERAL_LEAN;
+
 }

 bool MyAvatar::FollowHelper::shouldActivateVertical(const MyAvatar& myAvatar, const glm::mat4& desiredBodyMatrix, const glm::mat4& currentBodyMatrix) const {
@ -2988,6 +3004,7 @@ bool MyAvatar::FollowHelper::shouldActivateVertical(const MyAvatar& myAvatar, co
    const float CYLINDER_BOTTOM = -1.5f;

    glm::vec3 offset = extractTranslation(desiredBodyMatrix) - extractTranslation(currentBodyMatrix);
+
    return (offset.y > CYLINDER_TOP) || (offset.y < CYLINDER_BOTTOM);
 }

@ -3005,6 +3022,19 @@ void MyAvatar::FollowHelper::prePhysicsUpdate(MyAvatar& myAvatar, const glm::mat
        if (!isActive(Vertical) && (shouldActivateVertical(myAvatar, desiredBodyMatrix, currentBodyMatrix) || hasDriveInput)) {
            activate(Vertical);
        }
+    } else {
+        if (!isActive(Rotation) && getForceActivateRotation()) {
+            activate(Rotation);
+            setForceActivateRotation(false);
+        }
+        if (!isActive(Horizontal) && getForceActivateHorizontal()) {
+            activate(Horizontal);
+            setForceActivateHorizontal(false);
+        }
+        if (!isActive(Vertical) && getForceActivateVertical()) {
+            activate(Vertical);
+            setForceActivateVertical(false);
+        }
    }

    glm::mat4 desiredWorldMatrix = myAvatar.getSensorToWorldMatrix() * desiredBodyMatrix;
@ -3054,6 +3084,30 @@ glm::mat4 MyAvatar::FollowHelper::postPhysicsUpdate(const MyAvatar& myAvatar, co
    }
 }

+bool MyAvatar::FollowHelper::getForceActivateRotation() const {
+    return _forceActivateRotation;
+}
+
+void MyAvatar::FollowHelper::setForceActivateRotation(bool val) {
+    _forceActivateRotation = val;
+}
+
+bool MyAvatar::FollowHelper::getForceActivateVertical() const {
+    return _forceActivateVertical;
+}
+
+void MyAvatar::FollowHelper::setForceActivateVertical(bool val) {
+    _forceActivateVertical = val;
+}
+
+bool MyAvatar::FollowHelper::getForceActivateHorizontal() const {
+    return _forceActivateHorizontal;
+}
+
+void MyAvatar::FollowHelper::setForceActivateHorizontal(bool val) {
+    _forceActivateHorizontal = val;
+}
+
 float MyAvatar::getAccelerationEnergy() {
    glm::vec3 velocity = getWorldVelocity();
    int changeInVelocity = abs(velocity.length() - priorVelocity.length());
--- a/interface/src/avatar/MyAvatar.h
+++ b/interface/src/avatar/MyAvatar.h
@ -404,6 +404,32 @@ public:
    Q_INVOKABLE void enableDriveKey(DriveKeys key);
    Q_INVOKABLE bool isDriveKeyDisabled(DriveKeys key) const;

+    /**jsdoc
+    *The triggerVerticalRecenter function activates one time the recentering 
+    *behaviour in the vertical direction. This call is only takes effect when the property
+    *MyAvatar.hmdLeanRecenterEnabled is set to false.
+    *@function MyAvatar.triggerVerticalRecenter
+    *
+    */
+
+    /**jsdoc
+    *The triggerHorizontalRecenter function activates one time the recentering behaviour
+    *in the horizontal direction. This call is only takes effect when the property
+    *MyAvatar.hmdLeanRecenterEnabled is set to false.
+    *@function MyAvatar.triggerHorizontalRecenter
+    */
+
+    /**jsdoc
+    *The triggerRotationRecenter function activates one time the recentering behaviour
+    *in the rotation of the root of the avatar. This call is only takes effect when the property
+    *MyAvatar.hmdLeanRecenterEnabled is set to false.
+    *@function MyAvatar.triggerRotationRecenter
+    */
+
+    Q_INVOKABLE void triggerVerticalRecenter();
+    Q_INVOKABLE void triggerHorizontalRecenter();
+    Q_INVOKABLE void triggerRotationRecenter();
+
    eyeContactTarget getEyeContactTarget();

    const MyHead* getMyHead() const;
@ -803,6 +829,15 @@ private:
        bool shouldActivateHorizontal(const MyAvatar& myAvatar, const glm::mat4& desiredBodyMatrix, const glm::mat4& currentBodyMatrix) const;
        void prePhysicsUpdate(MyAvatar& myAvatar, const glm::mat4& bodySensorMatrix, const glm::mat4& currentBodyMatrix, bool hasDriveInput);
        glm::mat4 postPhysicsUpdate(const MyAvatar& myAvatar, const glm::mat4& currentBodyMatrix);
+        bool getForceActivateRotation() const;
+        void setForceActivateRotation(bool val);
+        bool getForceActivateVertical() const;
+        void setForceActivateVertical(bool val);
+        bool getForceActivateHorizontal() const;
+        void setForceActivateHorizontal(bool val);
+        std::atomic<bool> _forceActivateRotation{ false };
+        std::atomic<bool> _forceActivateVertical{ false };
+        std::atomic<bool> _forceActivateHorizontal{ false };
    };
    FollowHelper _follow;

@ -839,6 +874,7 @@ private:

    bool _hmdLeanRecenterEnabled { true };
    bool _sprint { false };
+
    AnimPose _prePhysicsRoomPose;
    std::mutex _holdActionsMutex;
    std::vector<AvatarActionHold*> _holdActions;
--- a/interface/src/commerce/Ledger.cpp
+++ b/interface/src/commerce/Ledger.cpp
@ -293,7 +293,7 @@ void Ledger::account() {
 // The api/failResponse is called just for the side effect of logging.
 void Ledger::updateLocationSuccess(QNetworkReply& reply) { apiResponse("updateLocation", reply); }
 void Ledger::updateLocationFailure(QNetworkReply& reply) { failResponse("updateLocation", reply); }
-void Ledger::updateLocation(const QString& asset_id, const QString location, const bool controlledFailure) {
+void Ledger::updateLocation(const QString& asset_id, const QString& location, const bool& alsoUpdateSiblings, const bool controlledFailure) {
    auto wallet = DependencyManager::get<Wallet>();
    auto walletScriptingInterface = DependencyManager::get<WalletScriptingInterface>();
    uint walletStatus = walletScriptingInterface->getWalletStatus();
@ -308,6 +308,9 @@ void Ledger::updateLocation(const QString& asset_id, const QString location, con
            QJsonObject transaction;
            transaction["certificate_id"] = asset_id;
            transaction["place_name"] = location;
+            if (alsoUpdateSiblings) {
+                transaction["also_update_siblings"] = true;
+            }
            QJsonDocument transactionDoc{ transaction };
            auto transactionString = transactionDoc.toJson(QJsonDocument::Compact);
            signedSend("transaction", transactionString, key, "location", "updateLocationSuccess", "updateLocationFailure", controlledFailure);
--- a/interface/src/commerce/Ledger.h
+++ b/interface/src/commerce/Ledger.h
@ -31,7 +31,7 @@ public:
    void inventory(const QStringList& keys);
    void history(const QStringList& keys, const int& pageNumber);
    void account();
-    void updateLocation(const QString& asset_id, const QString location, const bool controlledFailure = false);
+    void updateLocation(const QString& asset_id, const QString& location, const bool& alsoUpdateSiblings = false, const bool controlledFailure = false);
    void certificateInfo(const QString& certificateId);
    void transferHfcToNode(const QString& hfc_key, const QString& nodeID, const int& amount, const QString& optionalMessage);
    void transferHfcToUsername(const QString& hfc_key, const QString& username, const int& amount, const QString& optionalMessage);
--- a/interface/src/commerce/QmlCommerce.cpp
+++ b/interface/src/commerce/QmlCommerce.cpp
@ -190,7 +190,9 @@ void QmlCommerce::transferHfcToUsername(const QString& username, const int& amou
    ledger->transferHfcToUsername(key, username, amount, optionalMessage);
 }

-void QmlCommerce::replaceContentSet(const QString& itemHref) {
+void QmlCommerce::replaceContentSet(const QString& itemHref, const QString& certificateID) {
+    auto ledger = DependencyManager::get<Ledger>();
+    ledger->updateLocation(certificateID, DependencyManager::get<AddressManager>()->getPlaceName(), true);
    qApp->replaceDomainContent(itemHref);
    QJsonObject messageProperties = {
        { "status", "SuccessfulRequestToReplaceContent" },
--- a/interface/src/commerce/QmlCommerce.h
+++ b/interface/src/commerce/QmlCommerce.h
@ -84,7 +84,7 @@ protected:
    Q_INVOKABLE void transferHfcToNode(const QString& nodeID, const int& amount, const QString& optionalMessage);
    Q_INVOKABLE void transferHfcToUsername(const QString& username, const int& amount, const QString& optionalMessage);

-    Q_INVOKABLE void replaceContentSet(const QString& itemHref);
+    Q_INVOKABLE void replaceContentSet(const QString& itemHref, const QString& certificateID);

    Q_INVOKABLE QString getInstalledApps();
    Q_INVOKABLE bool installApp(const QString& appHref);
--- a/interface/src/scripting/AssetMappingsScriptingInterface.cpp
+++ b/interface/src/scripting/AssetMappingsScriptingInterface.cpp
@ -80,7 +80,7 @@ void AssetMappingsScriptingInterface::uploadFile(QString path, QString mapping,
    auto result = offscreenUi->inputDialog(OffscreenUi::ICON_INFORMATION, "Specify Asset Path",
                                           dropEvent ? dropHelpText : helpText, mapping);

-    if (!result.isValid()) {
+    if (!result.isValid() || result.toString() == "") {
        completedCallback.call({ -1 });
        return;
    }
--- a/interface/src/scripting/AudioDevices.cpp
+++ b/interface/src/scripting/AudioDevices.cpp
@ -10,6 +10,7 @@
 //

 #include <map>
+#include <algorithm>

 #include <shared/QtHelpers.h>
 #include <plugins/DisplayPlugin.h>
@ -182,7 +183,6 @@ void AudioDeviceList::resetDevice(bool contextIsHMD) {
 }

 void AudioDeviceList::onDeviceChanged(const QAudioDeviceInfo& device, bool isHMD) {
-    auto oldDevice = isHMD ? _selectedHMDDevice : _selectedDesktopDevice;
    QAudioDeviceInfo& selectedDevice = isHMD ? _selectedHMDDevice : _selectedDesktopDevice;
    selectedDevice = device;

@ -200,32 +200,137 @@ void AudioDeviceList::onDeviceChanged(const QAudioDeviceInfo& device, bool isHMD
    emit dataChanged(createIndex(0, 0), createIndex(rowCount() - 1, 0));
 }

-void AudioDeviceList::onDevicesChanged(const QList<QAudioDeviceInfo>& devices, bool isHMD) {
-    QAudioDeviceInfo& selectedDevice = isHMD ? _selectedHMDDevice : _selectedDesktopDevice;
+// Function returns 'strings similarity' as a number. The lesser number - the more similar strings are. Absolutely equal strings should return 0.
+// Optimized version kindly provided by Ken
+int levenshteinDistance(const QString& s1, const QString& s2) {
+    const int m = s1.size();
+    const int n = s2.size();

-    const QString& savedDeviceName = isHMD ? _hmdSavedDeviceName : _desktopSavedDeviceName;
+    if (m == 0) {
+        return n;
+    }
+    if (n == 0) {
+        return m;
+    }
+
+    auto cost = (int*)alloca((n + 1) * sizeof(int));
+
+    for (int j = 0; j <= n; j++) {
+        cost[j] = j;
+    }
+
+    for (int i = 0; i < m; i++) {
+
+        int prev = i;
+        cost[0] = i + 1;
+
+        for (int j = 0; j < n; j++) {
+
+            int temp = cost[j + 1];
+            cost[j + 1] = (s1[i] == s2[j]) ? prev : std::min(cost[j], std::min(temp, prev)) + 1;
+            prev = temp;
+        }
+    }
+    return cost[n];
+}
+
+std::shared_ptr<scripting::AudioDevice> getSimilarDevice(const QString& deviceName, const QList<std::shared_ptr<scripting::AudioDevice>>& devices) {
+
+    int minDistance = INT_MAX;
+    int minDistanceIndex = 0;
+
+    for (auto i = 0; i < devices.length(); ++i) {
+        auto distance = levenshteinDistance(deviceName, devices[i]->info.deviceName());
+        if (distance < minDistance) {
+            minDistance = distance;
+            minDistanceIndex = i;
+        }
+    }
+
+    return devices[minDistanceIndex];
+}
+
+void AudioDeviceList::onDevicesChanged(const QList<QAudioDeviceInfo>& devices) {
    beginResetModel();

-    _devices.clear();
+    QList<std::shared_ptr<AudioDevice>> newDevices;
+    bool hmdIsSelected = false;
+    bool desktopIsSelected = false;
+
+    foreach(const QAudioDeviceInfo& deviceInfo, devices) {
+        for (bool isHMD : {false, true}) {
+            auto &backupSelectedDeviceName = isHMD ? _backupSelectedHMDDeviceName : _backupSelectedDesktopDeviceName;
+            if (deviceInfo.deviceName() == backupSelectedDeviceName) {
+                QAudioDeviceInfo& selectedDevice = isHMD ? _selectedHMDDevice : _selectedDesktopDevice;
+                selectedDevice = deviceInfo;
+                backupSelectedDeviceName.clear();
+            }
+        }
+    }

    foreach(const QAudioDeviceInfo& deviceInfo, devices) {
        AudioDevice device;
-        bool &isSelected = isHMD ? device.selectedHMD : device.selectedDesktop;
        device.info = deviceInfo;
        device.display = device.info.deviceName()
            .replace("High Definition", "HD")
            .remove("Device")
            .replace(" )", ")");
-        if (!selectedDevice.isNull()) {
-            isSelected = (device.info == selectedDevice);
-        } else {
-            //no selected device for context. fallback to saved
-            isSelected = (device.info.deviceName() == savedDeviceName);
+
+        for (bool isHMD : {false, true}) {
+            QAudioDeviceInfo& selectedDevice = isHMD ? _selectedHMDDevice : _selectedDesktopDevice;
+            bool &isSelected = isHMD ? device.selectedHMD : device.selectedDesktop;
+
+            if (!selectedDevice.isNull()) {
+                isSelected = (device.info == selectedDevice);
+            }
+            else {
+                //no selected device for context. fallback to saved
+                const QString& savedDeviceName = isHMD ? _hmdSavedDeviceName : _desktopSavedDeviceName;
+                isSelected = (device.info.deviceName() == savedDeviceName);
+            }
+
+            if (isSelected) {
+                if (isHMD) {
+                    hmdIsSelected = isSelected;
+                } else {
+                    desktopIsSelected = isSelected;
+                }
+
+                // check if this device *is not* in old devices list - it means it was just re-plugged so needs to be selected explicitly
+                bool isNewDevice = true;
+                for (auto& oldDevice : _devices) {
+                    if (oldDevice->info.deviceName() == device.info.deviceName()) {
+                        isNewDevice = false;
+                        break;
+                    }
+                }
+
+                if (isNewDevice) {
+                    emit selectedDevicePlugged(device.info, isHMD);
+                }
+            }
        }
+
        qDebug() << "adding audio device:" << device.display << device.selectedDesktop << device.selectedHMD << _mode;
-        _devices.push_back(newDevice(device));
+        newDevices.push_back(newDevice(device));
    }

+    if (!newDevices.isEmpty()) {
+        if (!hmdIsSelected) {
+            _backupSelectedHMDDeviceName = !_selectedHMDDevice.isNull() ? _selectedHMDDevice.deviceName() : _hmdSavedDeviceName;
+            auto device = getSimilarDevice(_backupSelectedHMDDeviceName, newDevices);
+            device->selectedHMD = true;
+            emit selectedDevicePlugged(device->info, true);
+        }
+        if (!desktopIsSelected) {
+            _backupSelectedDesktopDeviceName = !_selectedDesktopDevice.isNull() ? _selectedDesktopDevice.deviceName() : _desktopSavedDeviceName;
+            auto device = getSimilarDevice(_backupSelectedDesktopDeviceName, newDevices);
+            device->selectedDesktop = true;
+            emit selectedDevicePlugged(device->info, false);
+        }
+    }
+
+    _devices.swap(newDevices);
    endResetModel();
 }

@ -271,12 +376,10 @@ AudioDevices::AudioDevices(bool& contextIsHMD) : _contextIsHMD(contextIsHMD) {
    // connections are made after client is initialized, so we must also fetch the devices
    const QList<QAudioDeviceInfo>& devicesInput = client->getAudioDevices(QAudio::AudioInput);
    const QList<QAudioDeviceInfo>& devicesOutput = client->getAudioDevices(QAudio::AudioOutput);
-    //setup HMD devices
-    _inputs.onDevicesChanged(devicesInput, true);
-    _outputs.onDevicesChanged(devicesOutput, true);
-    //setup Desktop devices
-    _inputs.onDevicesChanged(devicesInput, false);
-    _outputs.onDevicesChanged(devicesOutput, false);
+
+    //setup devices
+    _inputs.onDevicesChanged(devicesInput);
+    _outputs.onDevicesChanged(devicesOutput);
 }

 AudioDevices::~AudioDevices() {}
@ -375,11 +478,19 @@ void AudioDevices::onDevicesChanged(QAudio::Mode mode, const QList<QAudioDeviceI

    //set devices for both contexts
    if (mode == QAudio::AudioInput) {
-        _inputs.onDevicesChanged(devices, _contextIsHMD);
-        _inputs.onDevicesChanged(devices, !_contextIsHMD);
+        _inputs.onDevicesChanged(devices);
+
+        static std::once_flag onceAfterInputDevicesChanged;
+        std::call_once(onceAfterInputDevicesChanged, [&] { // we only want 'selectedDevicePlugged' signal to be handled after initial list of input devices was populated
+            connect(&_inputs, &AudioDeviceList::selectedDevicePlugged, this, &AudioDevices::chooseInputDevice);
+        });
    } else { // if (mode == QAudio::AudioOutput)
-        _outputs.onDevicesChanged(devices, _contextIsHMD);
-        _outputs.onDevicesChanged(devices, !_contextIsHMD);
+        _outputs.onDevicesChanged(devices);
+
+        static std::once_flag onceAfterOutputDevicesChanged;
+        std::call_once(onceAfterOutputDevicesChanged, [&] { // we only want 'selectedDevicePlugged' signal to be handled after initial list of output devices was populated
+            connect(&_outputs, &AudioDeviceList::selectedDevicePlugged, this, &AudioDevices::chooseOutputDevice);
+        });
    }
 }

--- a/interface/src/scripting/AudioDevices.h
+++ b/interface/src/scripting/AudioDevices.h
@ -51,10 +51,11 @@ public:

 signals:
    void deviceChanged(const QAudioDeviceInfo& device);
+    void selectedDevicePlugged(const QAudioDeviceInfo& device, bool isHMD);

 protected slots:
    void onDeviceChanged(const QAudioDeviceInfo& device, bool isHMD);
-    void onDevicesChanged(const QList<QAudioDeviceInfo>& devices, bool isHMD);
+    void onDevicesChanged(const QList<QAudioDeviceInfo>& devices);

 protected:
    friend class AudioDevices;
@ -64,6 +65,8 @@ protected:
    const QAudio::Mode _mode;
    QAudioDeviceInfo _selectedDesktopDevice;
    QAudioDeviceInfo _selectedHMDDevice;
+    QString _backupSelectedDesktopDeviceName;
+    QString _backupSelectedHMDDeviceName;
    QList<std::shared_ptr<AudioDevice>> _devices;
    QString _hmdSavedDeviceName;
    QString _desktopSavedDeviceName;
@ -117,13 +120,13 @@ public:
    AudioDevices(bool& contextIsHMD);
    virtual ~AudioDevices();

-    void chooseInputDevice(const QAudioDeviceInfo& device, bool isHMD);
-    void chooseOutputDevice(const QAudioDeviceInfo& device, bool isHMD);
-
 signals:
    void nop();

 private slots:
+    void chooseInputDevice(const QAudioDeviceInfo& device, bool isHMD);
+    void chooseOutputDevice(const QAudioDeviceInfo& device, bool isHMD);
+
    void onContextChanged(const QString& context);
    void onDeviceSelected(QAudio::Mode mode, const QAudioDeviceInfo& device,
                          const QAudioDeviceInfo& previousDevice, bool isHMD);
--- a/interface/src/scripting/WindowScriptingInterface.cpp
+++ b/interface/src/scripting/WindowScriptingInterface.cpp
@ -78,13 +78,17 @@ void WindowScriptingInterface::setFocus() {
    });
 }

-void WindowScriptingInterface::raiseMainWindow() {
+void WindowScriptingInterface::raise() {
    // It's forbidden to call raise() from another thread.
    qApp->postLambdaEvent([] {
        qApp->raise();
    });
 }

+void WindowScriptingInterface::raiseMainWindow() {
+    raise();
+}
+
 /// Display an alert box
 /// \param const QString& message message to display
 /// \return QScriptValue::UndefinedValue
--- a/interface/src/scripting/WindowScriptingInterface.h
+++ b/interface/src/scripting/WindowScriptingInterface.h
@ -68,9 +68,16 @@ public slots:
     */
    void setFocus();

+    /**jsdoc
+     * Raise the Interface window if it is minimized. If raised, the window gains focus.
+     * @function Window.raise
+     */
+    void raise();
+
    /**jsdoc
     * Raise the Interface window if it is minimized. If raised, the window gains focus.
     * @function Window.raiseMainWindow
+     * @deprecated Use {@link Window.raise|raise} instead.
     */
    void raiseMainWindow();

--- a/interface/src/ui/overlays/Overlays.cpp
+++ b/interface/src/ui/overlays/Overlays.cpp
@ -54,6 +54,7 @@ Overlays::Overlays() {
 }

 void Overlays::cleanupAllOverlays() {
+    _shuttingDown = true;
    QMap<OverlayID, Overlay::Pointer> overlaysHUD;
    QMap<OverlayID, Overlay::Pointer> overlaysWorld;
    {
@ -147,6 +148,10 @@ void Overlays::enable() {
 // Note, can't be invoked by scripts, but can be called by the InterfaceParentFinder
 // class on packet processing threads
 Overlay::Pointer Overlays::getOverlay(OverlayID id) const {
+    if (_shuttingDown) {
+        return nullptr;
+    }
+
    QMutexLocker locker(&_mutex);
    if (_overlaysHUD.contains(id)) {
        return _overlaysHUD[id];
@ -157,6 +162,10 @@ Overlay::Pointer Overlays::getOverlay(OverlayID id) const {
 }

 OverlayID Overlays::addOverlay(const QString& type, const QVariant& properties) {
+    if (_shuttingDown) {
+        return UNKNOWN_OVERLAY_ID;
+    }
+
    if (QThread::currentThread() != thread()) {
        OverlayID result;
        PROFILE_RANGE(script, __FUNCTION__);
@ -261,6 +270,10 @@ OverlayID Overlays::addOverlay(const QString& type, const QVariant& properties)
 }

 OverlayID Overlays::addOverlay(const Overlay::Pointer& overlay) {
+    if (_shuttingDown) {
+        return UNKNOWN_OVERLAY_ID;
+    }
+
    OverlayID thisID = OverlayID(QUuid::createUuid());
    overlay->setOverlayID(thisID);
    overlay->setStackOrder(_stackOrder++);
@ -283,6 +296,10 @@ OverlayID Overlays::addOverlay(const Overlay::Pointer& overlay) {
 }

 OverlayID Overlays::cloneOverlay(OverlayID id) {
+    if (_shuttingDown) {
+        return UNKNOWN_OVERLAY_ID;
+    }
+
    if (QThread::currentThread() != thread()) {
        OverlayID result;
        PROFILE_RANGE(script, __FUNCTION__);
@ -301,6 +318,10 @@ OverlayID Overlays::cloneOverlay(OverlayID id) {
 }

 bool Overlays::editOverlay(OverlayID id, const QVariant& properties) {
+    if (_shuttingDown) {
+        return false;
+    }
+
    auto thisOverlay = getOverlay(id);
    if (!thisOverlay) {
        return false;
@ -320,6 +341,10 @@ bool Overlays::editOverlay(OverlayID id, const QVariant& properties) {
 }

 bool Overlays::editOverlays(const QVariant& propertiesById) {
+    if (_shuttingDown) {
+        return false;
+    }
+
    bool defer2DOverlays = QThread::currentThread() != thread();

    QVariantMap deferrred;
@ -351,6 +376,10 @@ bool Overlays::editOverlays(const QVariant& propertiesById) {
 }

 void Overlays::deleteOverlay(OverlayID id) {
+    if (_shuttingDown) {
+        return;
+    }
+
    if (QThread::currentThread() != thread()) {
        QMetaObject::invokeMethod(this, "deleteOverlay", Q_ARG(OverlayID, id));
        return;
@ -374,6 +403,9 @@ void Overlays::deleteOverlay(OverlayID id) {
 }

 QString Overlays::getOverlayType(OverlayID overlayId) {
+    if (_shuttingDown) {
+        return "";
+    }
    if (QThread::currentThread() != thread()) {
        QString result;
        PROFILE_RANGE(script, __FUNCTION__);
@ -404,7 +436,7 @@ QObject* Overlays::getOverlayObject(OverlayID id) {
 }

 OverlayID Overlays::getOverlayAtPoint(const glm::vec2& point) {
-    if (!_enabled) {
+    if (_shuttingDown || !_enabled) {
        return UNKNOWN_OVERLAY_ID;
    }

--- a/interface/src/ui/overlays/Overlays.h
+++ b/interface/src/ui/overlays/Overlays.h
@ -724,6 +724,7 @@ private:
    unsigned int _stackOrder { 1 };

    bool _enabled = true;
+    std::atomic<bool> _shuttingDown{ false };

    PointerEvent calculateOverlayPointerEvent(OverlayID overlayID, PickRay ray, RayToOverlayIntersectionResult rayPickResult,
        QMouseEvent* event, PointerEvent::EventType eventType);
--- a/interface/src/ui/overlays/QmlOverlay.cpp
+++ b/interface/src/ui/overlays/QmlOverlay.cpp
@ -39,18 +39,20 @@ void QmlOverlay::buildQmlElement(const QUrl& url) {

    auto offscreenUi = DependencyManager::get<OffscreenUi>();
    offscreenUi->load(url, [=](QQmlContext* context, QObject* object) {
-        QQuickItem* rawPtr = dynamic_cast<QQuickItem*>(object);
-        // Create a shared ptr with a custom deleter lambda, that calls deleteLater
-        _qmlElement = std::shared_ptr<QQuickItem>(rawPtr, [](QQuickItem* ptr) {
-            if (ptr) {
-                ptr->deleteLater();
-            }
-        });
+        _qmlElement = dynamic_cast<QQuickItem*>(object);
+        connect(_qmlElement, &QObject::destroyed, this, &QmlOverlay::qmlElementDestroyed);
    });
 }

+void QmlOverlay::qmlElementDestroyed() {
+    _qmlElement = nullptr;
+}
+
 QmlOverlay::~QmlOverlay() {
-    _qmlElement.reset();
+    if (_qmlElement) {
+        _qmlElement->deleteLater();
+    }
+    _qmlElement = nullptr;
 }

 // QmlOverlay replaces Overlay's properties with those defined in the QML file used but keeps Overlay2D's properties.
@ -62,15 +64,13 @@ void QmlOverlay::setProperties(const QVariantMap& properties) {

    Overlay2D::setProperties(properties);
    auto bounds = _bounds;
-    std::weak_ptr<QQuickItem> weakQmlElement = _qmlElement;
    // check to see if qmlElement still exists
-    auto qmlElement = weakQmlElement.lock();
-    if (qmlElement) {
-        qmlElement->setX(bounds.left());
-        qmlElement->setY(bounds.top());
-        qmlElement->setWidth(bounds.width());
-        qmlElement->setHeight(bounds.height());
-        QMetaObject::invokeMethod(qmlElement.get(), "updatePropertiesFromScript", Qt::DirectConnection, Q_ARG(QVariant, properties));
+    if (_qmlElement) {
+        _qmlElement->setX(bounds.left());
+        _qmlElement->setY(bounds.top());
+        _qmlElement->setWidth(bounds.width());
+        _qmlElement->setHeight(bounds.height());
+        QMetaObject::invokeMethod(_qmlElement, "updatePropertiesFromScript", Qt::DirectConnection, Q_ARG(QVariant, properties));
    }
 }

--- a/interface/src/ui/overlays/QmlOverlay.h
+++ b/interface/src/ui/overlays/QmlOverlay.h
@ -32,10 +32,11 @@ public:
    void render(RenderArgs* args) override;

 private:
+    Q_INVOKABLE void qmlElementDestroyed();
    Q_INVOKABLE void buildQmlElement(const QUrl& url);

 protected:
-    std::shared_ptr<QQuickItem> _qmlElement;
+    QQuickItem* _qmlElement{ nullptr };
 };

 #endif // hifi_QmlOverlay_h
--- a/libraries/animation/src/Rig.cpp
+++ b/libraries/animation/src/Rig.cpp
@ -1246,6 +1246,7 @@ void Rig::updateHands(bool leftHandEnabled, bool rightHandEnabled, bool hipsEnab
                      const FBXJointShapeInfo& hipsShapeInfo, const FBXJointShapeInfo& spineShapeInfo,
                      const FBXJointShapeInfo& spine1ShapeInfo, const FBXJointShapeInfo& spine2ShapeInfo) {

+    const bool ENABLE_POLE_VECTORS = false;
    const float ELBOW_POLE_VECTOR_BLEND_FACTOR = 0.95f;

    int hipsIndex = indexOfJoint("Hips");
@ -1268,7 +1269,7 @@ void Rig::updateHands(bool leftHandEnabled, bool rightHandEnabled, bool hipsEnab
        int handJointIndex = _animSkeleton->nameToJointIndex("LeftHand");
        int armJointIndex = _animSkeleton->nameToJointIndex("LeftArm");
        int elbowJointIndex = _animSkeleton->nameToJointIndex("LeftForeArm");
-        if (!leftArmEnabled && handJointIndex >= 0 && armJointIndex >= 0 && elbowJointIndex >= 0) {
+        if (ENABLE_POLE_VECTORS && !leftArmEnabled && handJointIndex >= 0 && armJointIndex >= 0 && elbowJointIndex >= 0) {
            glm::vec3 poleVector = calculateElbowPoleVector(handJointIndex, elbowJointIndex, armJointIndex, hipsIndex, true);

            // smooth toward desired pole vector from previous pole vector...  to reduce jitter
@ -1315,7 +1316,7 @@ void Rig::updateHands(bool leftHandEnabled, bool rightHandEnabled, bool hipsEnab
        int handJointIndex = _animSkeleton->nameToJointIndex("RightHand");
        int armJointIndex = _animSkeleton->nameToJointIndex("RightArm");
        int elbowJointIndex = _animSkeleton->nameToJointIndex("RightForeArm");
-        if (!rightArmEnabled && handJointIndex >= 0 && armJointIndex >= 0 && elbowJointIndex >= 0) {
+        if (ENABLE_POLE_VECTORS && !rightArmEnabled && handJointIndex >= 0 && armJointIndex >= 0 && elbowJointIndex >= 0) {
            glm::vec3 poleVector = calculateElbowPoleVector(handJointIndex, elbowJointIndex, armJointIndex, hipsIndex, false);

            // smooth toward desired pole vector from previous pole vector...  to reduce jitter
@ -1555,18 +1556,21 @@ void Rig::updateFromControllerParameters(const ControllerParameters& params, flo
    updateFeet(leftFootEnabled, rightFootEnabled,
               params.primaryControllerPoses[PrimaryControllerType_LeftFoot], params.primaryControllerPoses[PrimaryControllerType_RightFoot]);

+
+    if (headEnabled) {
+        // Blend IK chains toward the joint limit centers, this should stablize head and hand ik.
+        _animVars.set("solutionSource", (int)AnimInverseKinematics::SolutionSource::RelaxToLimitCenterPoses);
+    } else {
+        // Blend IK chains toward the UnderPoses, so some of the animaton motion is present in the IK solution.
+        _animVars.set("solutionSource", (int)AnimInverseKinematics::SolutionSource::RelaxToUnderPoses);
+    }
+
    // if the hips or the feet are being controlled.
    if (hipsEnabled || rightFootEnabled || leftFootEnabled) {
-        // for more predictable IK solve from the center of the joint limits, not from the underpose
-        _animVars.set("solutionSource", (int)AnimInverseKinematics::SolutionSource::RelaxToLimitCenterPoses);
-
        // replace the feet animation with the default pose, this is to prevent unexpected toe wiggling.
        _animVars.set("defaultPoseOverlayAlpha", 1.0f);
        _animVars.set("defaultPoseOverlayBoneSet", (int)AnimOverlay::BothFeetBoneSet);
    } else {
-        // augment the IK with the underPose.
-        _animVars.set("solutionSource", (int)AnimInverseKinematics::SolutionSource::RelaxToUnderPoses);
-
        // feet should follow source animation
        _animVars.unset("defaultPoseOverlayAlpha");
        _animVars.unset("defaultPoseOverlayBoneSet");
--- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp
@ -55,6 +55,7 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
    (&::gpu::gl::GLBackend::do_setUniformBuffer),
    (&::gpu::gl::GLBackend::do_setResourceBuffer),
    (&::gpu::gl::GLBackend::do_setResourceTexture),
+    (&::gpu::gl::GLBackend::do_setResourceTextureTable),
    (&::gpu::gl::GLBackend::do_setResourceFramebufferSwapChainTexture),

    (&::gpu::gl::GLBackend::do_setFramebuffer),
--- a/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackend.h
@ -40,7 +40,6 @@
 #endif


-
 // Let these be configured by the one define picked above
 #ifdef GPU_STEREO_TECHNIQUE_DOUBLED_SIMPLE
 #define GPU_STEREO_DRAWCALL_DOUBLED
@ -102,6 +101,12 @@ public:
    static const int MAX_NUM_RESOURCE_TEXTURES = 16;
    size_t getMaxNumResourceTextures() const { return MAX_NUM_RESOURCE_TEXTURES; }

+    // Texture Tables offers 2 dedicated slot (taken from the ubo slots)
+    static const int MAX_NUM_RESOURCE_TABLE_TEXTURES = 2;
+    static const int RESOURCE_TABLE_TEXTURE_SLOT_OFFSET = TRANSFORM_CAMERA_SLOT + 1;
+    size_t getMaxNumResourceTextureTables() const { return MAX_NUM_RESOURCE_TABLE_TEXTURES; }
+
+
    // Draw Stage
    virtual void do_draw(const Batch& batch, size_t paramOffset) = 0;
    virtual void do_drawIndexed(const Batch& batch, size_t paramOffset) = 0;
@ -130,6 +135,7 @@ public:
    // Resource Stage
    virtual void do_setResourceBuffer(const Batch& batch, size_t paramOffset) final;
    virtual void do_setResourceTexture(const Batch& batch, size_t paramOffset) final;
+    virtual void do_setResourceTextureTable(const Batch& batch, size_t paramOffset);
    virtual void do_setResourceFramebufferSwapChainTexture(const Batch& batch, size_t paramOffset) final;

    // Pipeline Stage
@ -230,6 +236,10 @@ protected:

    void recycle() const override;

+    // FIXME instead of a single flag, create a features struct similar to
+    // https://www.khronos.org/registry/vulkan/specs/1.0/man/html/VkPhysicalDeviceFeatures.html
+    virtual bool supportsBindless() const { return false;  }
+
    static const size_t INVALID_OFFSET = (size_t)-1;
    bool _inRenderTransferPass { false };
    int32_t _uboAlignment { 0 };
@ -389,6 +399,10 @@ protected:
    virtual bool bindResourceBuffer(uint32_t slot, BufferPointer& buffer) = 0;
    virtual void releaseResourceBuffer(uint32_t slot) = 0;

+    // Helper function that provides common code used by do_setResourceTexture and 
+    // do_setResourceTextureTable (in non-bindless mode)
+    void bindResourceTexture(uint32_t slot, const TexturePointer& texture);
+
    // update resource cache and do the gl unbind call with the current gpu::Texture cached at slot s
    void releaseResourceTexture(uint32_t slot);

--- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendPipeline.cpp
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendPipeline.cpp
@ -1,4 +1,4 @@
-//
+//
 //  GLBackendPipeline.cpp
 //  libraries/gpu/src/gpu
 //
@ -9,6 +9,8 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 #include "GLBackend.h"
+#include <gpu/TextureTable.h>
+
 #include "GLShared.h"
 #include "GLPipeline.h"
 #include "GLShader.h"
@ -247,8 +249,11 @@ void GLBackend::do_setResourceTexture(const Batch& batch, size_t paramOffset) {
        return;
    }

-    TexturePointer resourceTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
+    const auto& resourceTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
+    bindResourceTexture(slot, resourceTexture);
+}

+void GLBackend::bindResourceTexture(uint32_t slot, const TexturePointer& resourceTexture) {
    if (!resourceTexture) {
        releaseResourceTexture(slot);
        return;
@ -306,6 +311,19 @@ void GLBackend::setResourceTexture(unsigned int slot, const TexturePointer& reso
    }
 }

+void GLBackend::do_setResourceTextureTable(const Batch& batch, size_t paramOffset) {
+    const auto& textureTablePointer = batch._textureTables.get(batch._params[paramOffset]._uint);
+    if (!textureTablePointer) {
+        return;
+    }
+
+    const auto& textureTable = *textureTablePointer;
+    const auto& textures = textureTable.getTextures();
+    for (GLuint slot = 0; slot < textures.size(); ++slot) {
+        bindResourceTexture(slot, textures[slot]);
+    }
+}
+
 int GLBackend::ResourceStageState::findEmptyTextureSlot() const {
    // start from the end of the slots, try to find an empty one that can be used
    for (auto i = MAX_NUM_RESOURCE_TEXTURES - 1; i > 0; i--) {
@ -315,4 +333,3 @@ int GLBackend::ResourceStageState::findEmptyTextureSlot() const {
    }
    return -1;
 }
-
--- a/libraries/gpu-gl-common/src/gpu/gl/GLBackendShader.cpp
+++ b/libraries/gpu-gl-common/src/gpu/gl/GLBackendShader.cpp
@ -78,6 +78,11 @@ R"SHADER(
 #endif
 };

+// TextureTable specific defines
+static const std::string textureTableVersion {
+    "#extension GL_ARB_bindless_texture : require\n#define GPU_TEXTURE_TABLE_BINDLESS\n"
+};
+
 // Versions specific of the shader
 static const std::array<std::string, GLShader::NumVersions> VERSION_DEFINES { {
    "",
@ -96,9 +101,9 @@ GLShader* GLBackend::compileBackendShader(const Shader& shader, const Shader::Co
        auto& shaderObject = shaderObjects[version];

        std::string shaderDefines = getBackendShaderHeader() + "\n"
+            + (supportsBindless() ? textureTableVersion : "\n")
            + DOMAIN_DEFINES[shader.getType()] + "\n"
            + VERSION_DEFINES[version];
-
        if (handler) {
            bool retest = true;
            std::string currentSrc = shaderSource;
@ -120,7 +125,7 @@ GLShader* GLBackend::compileBackendShader(const Shader& shader, const Shader::Co
            compilationLogs[version].compiled = ::gl::compileShader(shaderDomain, shaderSource, shaderDefines, shaderObject.glshader, compilationLogs[version].message);
        }

-         if (!compilationLogs[version].compiled) {
+        if (!compilationLogs[version].compiled) {
            qCWarning(gpugllogging) << "GLBackend::compileBackendProgram - Shader didn't compile:\n" << compilationLogs[version].message.c_str();
            shader.setCompilationLogs(compilationLogs);
            return nullptr;
--- a/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp
@ -167,7 +167,6 @@ void GL41Texture::syncSampler() const {
    glTexParameteri(_target, GL_TEXTURE_WRAP_R, WRAP_MODES[sampler.getWrapModeW()]);

    glTexParameterfv(_target, GL_TEXTURE_BORDER_COLOR, (const float*)&sampler.getBorderColor());
-    glTexParameteri(_target, GL_TEXTURE_BASE_LEVEL, (uint16)sampler.getMipOffset());

    glTexParameterf(_target, GL_TEXTURE_MIN_LOD, (float)sampler.getMinMip());
    glTexParameterf(_target, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.f : sampler.getMaxMip()));
@ -206,9 +205,6 @@ void GL41FixedAllocationTexture::allocateStorage() const {
 void GL41FixedAllocationTexture::syncSampler() const {
    Parent::syncSampler();
    const Sampler& sampler = _gpuObject.getSampler();
-    auto baseMip = std::max<uint16_t>(sampler.getMipOffset(), sampler.getMinMip());
-
-    glTexParameteri(_target, GL_TEXTURE_BASE_LEVEL, baseMip);
    glTexParameterf(_target, GL_TEXTURE_MIN_LOD, (float)sampler.getMinMip());
    glTexParameterf(_target, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.0f : sampler.getMaxMip()));
 }
@ -610,4 +606,3 @@ GL41ResourceTexture::GL41ResourceTexture(const std::weak_ptr<GLBackend>& backend

 GL41ResourceTexture::~GL41ResourceTexture() {
 }
-
--- a/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45Backend.h
@ -16,9 +16,11 @@
 #include <gpu/gl/GLTexture.h>

 #include <thread>
+#include <gpu/TextureTable.h>

 #define INCREMENTAL_TRANSFER 0
 #define GPU_SSBO_TRANSFORM_OBJECT 1
+#define GPU_BINDLESS_TEXTURES 0

 namespace gpu { namespace gl45 {
    
@ -31,6 +33,9 @@ class GL45Backend : public GLBackend {
    friend class Context;

 public:
+#if GPU_BINDLESS_TEXTURES
+    virtual bool supportsBindless() const override { return true; }
+#endif

 #ifdef GPU_SSBO_TRANSFORM_OBJECT
    static const GLint TRANSFORM_OBJECT_SLOT  { 14 }; // SSBO binding slot
@ -58,8 +63,62 @@ public:
        void generateMips() const override;
        Size copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const override;
        void syncSampler() const override;
+
+#if GPU_BINDLESS_TEXTURES
+        bool isBindless() const {
+            return _bindless.operator bool();
+        }
+
+        struct Bindless {
+            uint64_t handle{ 0 };
+            uint32_t minMip{ 0 };
+            uint32_t sampler{ 0 };
+
+            bool operator==(const Bindless& other) const {
+                return handle == other.handle && minMip == other.minMip && sampler == other.sampler;
+            }
+
+            bool operator!=(const Bindless& other) const {
+                return !(*this == other);
+            }
+
+            operator bool() const {
+                return handle != 0;
+            }
+        };
+
+        virtual const Bindless& getBindless() const;
+        void releaseBindless() const;
+        void recreateBindless() const;
+    private:
+        mutable Bindless _bindless;
+#endif
+
+        static Sampler getInvalidSampler();
+
+        // This stores the texture handle (64 bits) in xy, the min mip available in z, and the sampler ID in w
+        mutable Sampler _cachedSampler{ getInvalidSampler() };
    };

+#if GPU_BINDLESS_TEXTURES 
+    class GL45TextureTable : public GLObject<TextureTable> {
+        static GLuint allocate();
+        using Parent = GLObject<TextureTable>;
+    public:
+        using BindlessArray = std::array<GL45Texture::Bindless, TextureTable::COUNT>;
+
+        GL45TextureTable(const std::weak_ptr<GLBackend>& backend, const TextureTable& texture);
+        ~GL45TextureTable();
+
+        void update(const BindlessArray& newHandles);
+
+        // FIXME instead of making a buffer for each table, there should be a global buffer of all materials
+        // and we should store an offset into that buffer
+        BindlessArray _handles;
+    };
+#endif
+
+
    //
    // Textures that have fixed allocation sizes and cannot be managed at runtime
    //
@ -74,6 +133,7 @@ public:

    protected:
        Size size() const override { return _size; }
+
        void allocateStorage() const;
        void syncSampler() const override;
        const Size _size { 0 };
@ -104,7 +164,6 @@ public:
        friend class GL45Backend;
        using PromoteLambda = std::function<void()>;

-
    protected:
        GL45VariableAllocationTexture(const std::weak_ptr<GLBackend>& backend, const Texture& texture);
        ~GL45VariableAllocationTexture();
@ -114,6 +173,9 @@ public:
        Size copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const override;
        void copyTextureMipsInGPUMem(GLuint srcId, GLuint destId, uint16_t srcMipOffset, uint16_t destMipOffset, uint16_t populatedMips) override;

+#if GPU_BINDLESS_TEXTURES
+        virtual const Bindless& getBindless() const override;
+#endif
    };

    class GL45ResourceTexture : public GL45VariableAllocationTexture {
@ -182,6 +244,7 @@ protected:
    GLuint getQueryID(const QueryPointer& query) override;
    GLQuery* syncGPUObject(const Query& query) override;

+
    // Draw Stage
    void do_draw(const Batch& batch, size_t paramOffset) override;
    void do_drawIndexed(const Batch& batch, size_t paramOffset) override;
@ -213,6 +276,12 @@ protected:

    // Texture Management Stage
    void initTextureManagementStage() override;
+
+#if GPU_BINDLESS_TEXTURES
+    GL45TextureTable* syncGPUObject(const TextureTablePointer& textureTable);
+    // Resource stage
+    void do_setResourceTextureTable(const Batch& batch, size_t paramOffset) override;
+#endif
 };

 } }
--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendShader.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendShader.cpp
@ -165,6 +165,11 @@ void GL45Backend::makeProgramBindings(ShaderObject& shaderObject) {
        shaderObject.transformCameraSlot = gpu::TRANSFORM_CAMERA_SLOT;
    }

+    loc = glGetUniformBlockIndex(glprogram, "gpu_resourceTextureTable0");
+    if (loc >= 0) {
+        glUniformBlockBinding(glprogram, loc, RESOURCE_TABLE_TEXTURE_SLOT_OFFSET);
+    }
+
    (void)CHECK_GL_ERROR();
 }

--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp
@ -20,14 +20,17 @@
 #include <QtCore/QDebug>

 #include <NumericalConstants.h>
+#include <gl/Context.h>
+#include <gpu/TextureTable.h>
 #include <gpu/gl/GLTexelFormat.h>

 using namespace gpu;
 using namespace gpu::gl;
 using namespace gpu::gl45;

-#define SPARSE_PAGE_SIZE_OVERHEAD_ESTIMATE 1.3f
 #define MAX_RESOURCE_TEXTURES_PER_FRAME 2
+#define FORCE_STRICT_TEXTURE 0
+#define ENABLE_SPARSE_TEXTURE 0

 GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texturePointer) {
    if (!texturePointer) {
@ -51,14 +54,18 @@ GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texturePointer) {
                object = new GL45AttachmentTexture(shared_from_this(), texture);
                break;

+#if FORCE_STRICT_TEXTURE
+            case TextureUsageType::RESOURCE:
+#endif
            case TextureUsageType::STRICT_RESOURCE:
                qCDebug(gpugllogging) << "Strict texture " << texture.source().c_str();
                object = new GL45StrictResourceTexture(shared_from_this(), texture);
                break;

+#if !FORCE_STRICT_TEXTURE
            case TextureUsageType::RESOURCE: {
                if (GL45VariableAllocationTexture::_frameTexturesCreated < MAX_RESOURCE_TEXTURES_PER_FRAME) {
-#if 0
+#if ENABLE_SPARSE_TEXTURE
                    if (isTextureManagementSparseEnabled() && GL45Texture::isSparseEligible(texture)) {
                        object = new GL45SparseResourceTexture(shared_from_this(), texture);
                    } else {
@ -76,7 +83,7 @@ GLTexture* GL45Backend::syncGPUObject(const TexturePointer& texturePointer) {
                }
                break;
            }
-
+#endif
            default:
                Q_UNREACHABLE();
        }
@ -114,6 +121,61 @@ void GL45Backend::initTextureManagementStage() {

 using GL45Texture = GL45Backend::GL45Texture;

+
+class GLSamplerCache {
+public:
+    GLuint getGLSampler(const Sampler& sampler) {
+        if (0 == _samplerCache.count(sampler)) {
+            GLuint result = 0;
+            glGenSamplers(1, &result);
+            const auto& fm = GLTexture::FILTER_MODES[sampler.getFilter()];
+            glSamplerParameteri(result, GL_TEXTURE_MIN_FILTER, fm.minFilter);
+            glSamplerParameteri(result, GL_TEXTURE_MAG_FILTER, fm.magFilter);
+            if (sampler.doComparison()) {
+                glSamplerParameteri(result, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE_ARB);
+                glSamplerParameteri(result, GL_TEXTURE_COMPARE_FUNC, COMPARISON_TO_GL[sampler.getComparisonFunction()]);
+            } else {
+                glSamplerParameteri(result, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+            }
+
+            glSamplerParameteri(result, GL_TEXTURE_WRAP_S, GLTexture::WRAP_MODES[sampler.getWrapModeU()]);
+            glSamplerParameteri(result, GL_TEXTURE_WRAP_T, GLTexture::WRAP_MODES[sampler.getWrapModeV()]);
+            glSamplerParameteri(result, GL_TEXTURE_WRAP_R, GLTexture::WRAP_MODES[sampler.getWrapModeW()]);
+
+            glSamplerParameterf(result, GL_TEXTURE_MAX_ANISOTROPY_EXT, sampler.getMaxAnisotropy());
+            glSamplerParameterfv(result, GL_TEXTURE_BORDER_COLOR, (const float*)&sampler.getBorderColor());
+
+            glSamplerParameterf(result, GL_TEXTURE_MIN_LOD, sampler.getMinMip());
+            glSamplerParameterf(result, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.f : sampler.getMaxMip()));
+            _samplerCache[sampler] = result;
+            return result;
+        }
+
+        return _samplerCache[sampler];
+    }
+
+    void releaseGLSampler(GLuint sampler) {
+        // NO OP
+    }
+
+private:
+    std::unordered_map<Sampler, GLuint> _samplerCache;
+};
+
+static GLSamplerCache SAMPLER_CACHE;
+
+
+Sampler GL45Texture::getInvalidSampler() {
+    static Sampler INVALID_SAMPLER;
+    static std::once_flag once;
+    std::call_once(once, [] {
+        Sampler::Desc invalidDesc;
+        invalidDesc._borderColor = vec4(-1.0f);
+        INVALID_SAMPLER = Sampler(invalidDesc);
+    });
+    return INVALID_SAMPLER;
+}
+
 GL45Texture::GL45Texture(const std::weak_ptr<GLBackend>& backend, const Texture& texture)
    : GLTexture(backend, texture, allocate(texture)) {
 }
@ -121,10 +183,10 @@ GL45Texture::GL45Texture(const std::weak_ptr<GLBackend>& backend, const Texture&
 GLuint GL45Texture::allocate(const Texture& texture) {
    GLuint result;
    glCreateTextures(getGLTextureType(texture), 1, &result);
-#ifdef DEBUG
-    auto source = texture.source();
-    glObjectLabel(GL_TEXTURE, result, (GLsizei)source.length(), source.data());
-#endif
+    if (::gl::Context::enableDebugLogger()) {
+        auto source = texture.source();
+        glObjectLabel(GL_TEXTURE, result, (GLsizei)source.length(), source.data());
+    }
    return result;
 }

@ -189,8 +251,50 @@ Size GL45Texture::copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const
    return amountCopied;
 }

+#if GPU_BINDLESS_TEXTURES
+void GL45Texture::releaseBindless() const {
+    // Release the old handler
+    SAMPLER_CACHE.releaseGLSampler(_bindless.sampler);
+    glMakeTextureHandleNonResidentARB(_bindless.handle);
+    _bindless = Bindless();
+}
+
+void GL45Texture::recreateBindless() const {
+    if (isBindless()) {
+        releaseBindless();
+    } else {
+        // Once a texture is about to become bindless, it's base mip level MUST be set to 0
+        glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, 0);
+    }
+
+    _bindless.sampler = SAMPLER_CACHE.getGLSampler(_cachedSampler);
+    _bindless.handle = glGetTextureSamplerHandleARB(_id, _bindless.sampler);
+    glMakeTextureHandleResidentARB(_bindless.handle);
+}
+
+const GL45Texture::Bindless& GL45Texture::getBindless() const {
+    if (!_bindless) {
+        recreateBindless();
+    }
+    return _bindless;
+}
+#endif
+
+
 void GL45Texture::syncSampler() const {
    const Sampler& sampler = _gpuObject.getSampler();
+    if (_cachedSampler == sampler) {
+        return;
+    } 
+
+    _cachedSampler = sampler;
+
+#if GPU_BINDLESS_TEXTURES
+    if (isBindless()) {
+        recreateBindless();
+        return;
+    } 
+#endif

    const auto& fm = FILTER_MODES[sampler.getFilter()];
    glTextureParameteri(_id, GL_TEXTURE_MIN_FILTER, fm.minFilter);
@ -214,6 +318,8 @@ void GL45Texture::syncSampler() const {
    glTextureParameterf(_id, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.f : sampler.getMaxMip()));
 }

+// Fixed allocation textures, used for strict resources & framebuffer attachments
+
 using GL45FixedAllocationTexture = GL45Backend::GL45FixedAllocationTexture;

 GL45FixedAllocationTexture::GL45FixedAllocationTexture(const std::weak_ptr<GLBackend>& backend, const Texture& texture) : GL45Texture(backend, texture), _size(texture.evalTotalSize()) {
@ -238,8 +344,6 @@ void GL45FixedAllocationTexture::allocateStorage() const {
 void GL45FixedAllocationTexture::syncSampler() const {
    Parent::syncSampler();
    const Sampler& sampler = _gpuObject.getSampler();
-    auto baseMip = std::max<uint16_t>(sampler.getMipOffset(), sampler.getMinMip());
-    glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, baseMip);
    glTextureParameterf(_id, GL_TEXTURE_MIN_LOD, (float)sampler.getMinMip());
    glTextureParameterf(_id, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.f : sampler.getMaxMip()));
 }
@ -275,6 +379,9 @@ GL45StrictResourceTexture::GL45StrictResourceTexture(const std::weak_ptr<GLBacke
    if (texture.isAutogenerateMips()) {
        generateMips();
    }
+
+    // Re-sync the sampler to force access to the new mip level
+    syncSampler();
 }

 GL45StrictResourceTexture::~GL45StrictResourceTexture() {
@ -282,3 +389,87 @@ GL45StrictResourceTexture::~GL45StrictResourceTexture() {
    Backend::textureResidentGPUMemSize.update(size(), 0);
 }

+// Encapsulate bindless textures
+#if GPU_BINDLESS_TEXTURES
+using GL45TextureTable = GL45Backend::GL45TextureTable;
+
+GLuint GL45TextureTable::allocate() {
+    GLuint result;
+    glCreateBuffers(1, &result);
+    return result;
+}
+
+GL45TextureTable::GL45TextureTable(const std::weak_ptr<GLBackend>& backend, const TextureTable& textureTable)
+    : Parent(backend, textureTable, allocate()){
+    Backend::setGPUObject(textureTable, this);
+    // FIXME include these in overall buffer storage reporting
+    glNamedBufferStorage(_id, sizeof(uvec4) * TextureTable::COUNT, nullptr, GL_DYNAMIC_STORAGE_BIT);
+}
+
+void GL45TextureTable::update(const BindlessArray& handles) {
+    if (_handles != handles) {
+        _handles = handles;
+        // FIXME include these in overall buffer storage reporting
+        // FIXME use a single shared buffer for bindless data
+        glNamedBufferSubData(_id, 0, sizeof(GL45Texture::Bindless) * TextureTable::COUNT, &_handles[0]);
+    }
+}
+
+GL45TextureTable::~GL45TextureTable() {
+    if (_id) {
+        auto backend = _backend.lock();
+        if (backend) {
+            // FIXME include these in overall buffer storage reporting
+            backend->releaseBuffer(_id, 0);
+        }
+    }
+}
+
+GL45TextureTable* GL45Backend::syncGPUObject(const TextureTablePointer& textureTablePointer) {
+    const auto& textureTable = *textureTablePointer;
+
+    // Find the target handles
+    auto defaultTextures = gpu::TextureTable::getDefault()->getTextures();
+    auto textures = textureTable.getTextures();
+    GL45TextureTable::BindlessArray handles{};
+    for (size_t i = 0; i < textures.size(); ++i) {
+        auto texture = textures[i];
+        if (!texture) {
+            texture = defaultTextures[i];
+        }
+        if (!texture) {
+            continue;
+        }
+        // FIXME what if we have a non-transferrable texture here?
+        auto gltexture = (GL45Texture*)syncGPUObject(texture);
+        if (!gltexture) {
+            continue;
+        }
+        handles[i] = gltexture->getBindless();
+    }
+
+    // If the object hasn't been created, or the object definition is out of date, drop and re-create
+    GL45TextureTable* object = Backend::getGPUObject<GL45TextureTable>(textureTable);
+
+    if (!object) {
+        object = new GL45TextureTable(shared_from_this(), textureTable);
+    }
+
+    object->update(handles);
+
+    return object;
+}
+
+void GL45Backend::do_setResourceTextureTable(const Batch& batch, size_t paramOffset) {
+    auto textureTablePointer = batch._textureTables.get(batch._params[paramOffset]._uint);
+    if (!textureTablePointer) {
+        return;
+    }
+
+    auto slot = batch._params[paramOffset + 1]._uint;
+    GL45TextureTable* glTextureTable = syncGPUObject(textureTablePointer);
+    if (glTextureTable) {
+        glBindBufferBase(GL_UNIFORM_BUFFER, slot + GLBackend::RESOURCE_TABLE_TEXTURE_SLOT_OFFSET, glTextureTable->_id);
+    }
+}
+#endif
--- a/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp
+++ b/libraries/gpu-gl/src/gpu/gl45/GL45BackendVariableTexture.cpp
@ -27,6 +27,7 @@ using namespace gpu;
 using namespace gpu::gl;
 using namespace gpu::gl45;

+using GL45Texture = GL45Backend::GL45Texture;
 using GL45VariableAllocationTexture = GL45Backend::GL45VariableAllocationTexture;

 GL45VariableAllocationTexture::GL45VariableAllocationTexture(const std::weak_ptr<GLBackend>& backend, const Texture& texture) : GL45Texture(backend, texture) {
@ -40,6 +41,17 @@ GL45VariableAllocationTexture::~GL45VariableAllocationTexture() {
    Backend::textureResourcePopulatedGPUMemSize.update(_populatedSize, 0);
 }

+#if GPU_BINDLESS_TEXTURES
+const GL45Texture::Bindless& GL45VariableAllocationTexture::getBindless() const {
+    // The parent call may re-initialize the _bindless member, so we need to call it first
+    const auto& result = Parent::getBindless();
+    // Make sure the referenced structure has the correct minimum available mip value
+    _bindless.minMip = _populatedMip - _allocatedMip;
+    // Now return the result
+    return result;
+}
+#endif
+
 Size GL45VariableAllocationTexture::copyMipFaceLinesFromTexture(uint16_t mip, uint8_t face, const uvec3& size, uint32_t yOffset, GLenum internalFormat, GLenum format, GLenum type, Size sourceSize, const void* sourcePointer) const {
    Size amountCopied = 0;
    amountCopied = Parent::copyMipFaceLinesFromTexture(mip, face, size, yOffset, internalFormat, format, type, sourceSize, sourcePointer);
@ -127,7 +139,13 @@ Size GL45ResourceTexture::copyMipsFromTexture() {

 void GL45ResourceTexture::syncSampler() const {
    Parent::syncSampler();
+#if GPU_BINDLESS_TEXTURES
+    if (!isBindless()) {
+    	glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, _populatedMip - _allocatedMip);
+    }
+#else
    glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, _populatedMip - _allocatedMip);
+#endif
 }

 void GL45ResourceTexture::promote() {
@ -137,6 +155,13 @@ void GL45ResourceTexture::promote() {
    uint16_t targetAllocatedMip = _allocatedMip - std::min<uint16_t>(_allocatedMip, 2);
    targetAllocatedMip = std::max<uint16_t>(_minAllocatedMip, targetAllocatedMip);

+#if GPU_BINDLESS_TEXTURES
+    bool bindless = isBindless();
+    if (bindless) {
+        releaseBindless();
+    }
+#endif
+
    GLuint oldId = _id;
    auto oldSize = _size;
    uint16_t oldAllocatedMip = _allocatedMip;
@ -150,10 +175,17 @@ void GL45ResourceTexture::promote() {
    // copy pre-existing mips
    copyTextureMipsInGPUMem(oldId, _id, oldAllocatedMip, _allocatedMip, _populatedMip);

+#if GPU_BINDLESS_TEXTURES
+    if (bindless) {
+        getBindless();
+    }
+#endif
+
    // destroy the old texture
    glDeleteTextures(1, &oldId);

    // Update sampler
+    _cachedSampler = getInvalidSampler();
    syncSampler();

    // update the memory usage
@ -170,6 +202,13 @@ void GL45ResourceTexture::demote() {
    auto oldSize = _size;
    auto oldPopulatedMip = _populatedMip;

+#if GPU_BINDLESS_TEXTURES
+    bool bindless = isBindless();
+    if (bindless) {
+        releaseBindless();
+    }
+#endif
+
    // allocate new texture
    const_cast<GLuint&>(_id) = allocate(_gpuObject);
    uint16_t oldAllocatedMip = _allocatedMip;
@ -179,10 +218,17 @@ void GL45ResourceTexture::demote() {
    // copy pre-existing mips
    copyTextureMipsInGPUMem(oldId, _id, oldAllocatedMip, _allocatedMip, _populatedMip);

+#if GPU_BINDLESS_TEXTURES
+    if (bindless) {
+        getBindless();
+    }
+#endif
+
    // destroy the old texture
    glDeleteTextures(1, &oldId);

    // Update sampler
+    _cachedSampler = getInvalidSampler();
    syncSampler();

    // update the memory usage
--- a/libraries/gpu/src/gpu/Batch.cpp
+++ b/libraries/gpu/src/gpu/Batch.cpp
@ -75,6 +75,7 @@ Batch::Batch(const Batch& batch_) {

    _buffers._items.swap(batch._buffers._items);
    _textures._items.swap(batch._textures._items);
+    _textureTables._items.swap(batch._textureTables._items);
    _streamFormats._items.swap(batch._streamFormats._items);
    _transforms._items.swap(batch._transforms._items);
    _pipelines._items.swap(batch._pipelines._items);
@ -113,6 +114,7 @@ void Batch::clear() {
    _data.clear();
    _buffers.clear();
    _textures.clear();
+    _textureTables.clear();
    _streamFormats.clear();
    _transforms.clear();
    _pipelines.clear();
@ -337,6 +339,12 @@ void Batch::setResourceTexture(uint32 slot, const TextureView& view) {
    setResourceTexture(slot, view._texture);
 }

+void Batch::setResourceTextureTable(const TextureTablePointer& textureTable, uint32 slot) {
+    ADD_COMMAND(setResourceTextureTable);
+    _params.emplace_back(_textureTables.cache(textureTable));
+    _params.emplace_back(slot);
+}
+
 void Batch::setResourceFramebufferSwapChainTexture(uint32 slot, const FramebufferSwapChainPointer& framebuffer, unsigned int swapChainIndex, unsigned int renderBufferSlot) {
    ADD_COMMAND(setResourceFramebufferSwapChainTexture);

--- a/libraries/gpu/src/gpu/Batch.h
+++ b/libraries/gpu/src/gpu/Batch.h
@ -187,6 +187,7 @@ public:

    void setResourceTexture(uint32 slot, const TexturePointer& texture);
    void setResourceTexture(uint32 slot, const TextureView& view); // not a command, just a shortcut from a TextureView
+    void setResourceTextureTable(const TextureTablePointer& table, uint32 slot = 0);
    void setResourceFramebufferSwapChainTexture(uint32 slot, const FramebufferSwapChainPointer& framebuffer, unsigned int swpaChainIndex, unsigned int renderBufferSlot = 0U); // not a command, just a shortcut from a TextureView

    // Ouput Stage
@ -302,6 +303,7 @@ public:
        COMMAND_setUniformBuffer,
        COMMAND_setResourceBuffer,
        COMMAND_setResourceTexture,
+        COMMAND_setResourceTextureTable,
        COMMAND_setResourceFramebufferSwapChainTexture,

        COMMAND_setFramebuffer,
@ -409,9 +411,10 @@ public:
                return offset;
            }

-            Data get(uint32 offset) const {
+            const Data& get(uint32 offset) const {
                if (offset >= _items.size()) {
-                    return Data();
+                    static const Data EMPTY;
+                    return EMPTY;
                }
                return (_items.data() + offset)->_data;
            }
@ -424,6 +427,7 @@ public:

    typedef Cache<BufferPointer>::Vector BufferCaches;
    typedef Cache<TexturePointer>::Vector TextureCaches;
+    typedef Cache<TextureTablePointer>::Vector TextureTableCaches;
    typedef Cache<Stream::FormatPointer>::Vector StreamFormatCaches;
    typedef Cache<Transform>::Vector TransformCaches;
    typedef Cache<PipelinePointer>::Vector PipelineCaches;
@ -479,6 +483,7 @@ public:

    BufferCaches _buffers;
    TextureCaches _textures;
+    TextureTableCaches _textureTables;
    StreamFormatCaches _streamFormats;
    TransformCaches _transforms;
    PipelineCaches _pipelines;
--- a/libraries/gpu/src/gpu/Forward.h
+++ b/libraries/gpu/src/gpu/Forward.h
@ -91,6 +91,8 @@ namespace gpu {
    using Textures = std::vector<TexturePointer>;
    class TextureView;
    using TextureViews = std::vector<TextureView>;
+    class TextureTable;
+    using TextureTablePointer = std::shared_ptr<TextureTable>;

    struct StereoState {
        bool isStereo() const {
--- a/libraries/gpu/src/gpu/Texture.h
+++ b/libraries/gpu/src/gpu/Texture.h
@ -17,8 +17,10 @@
 #include <QMetaType>
 #include <QUrl>

+#include <functional>
 #include <shared/Storage.h>
 #include <shared/FileCache.h>
+#include <RegisteredMetaTypes.h>
 #include "Forward.h"
 #include "Resource.h"
 #include "Metric.h"
@ -126,12 +128,23 @@ public:
        uint8 _wrapModeV = WRAP_REPEAT;
        uint8 _wrapModeW = WRAP_REPEAT;
            
-        uint8 _mipOffset = 0;
        uint8 _minMip = 0;
        uint8 _maxMip = MAX_MIP_LEVEL;

        Desc() {}
        Desc(const Filter filter, const WrapMode wrap = WRAP_REPEAT) : _filter(filter), _wrapModeU(wrap), _wrapModeV(wrap), _wrapModeW(wrap) {}
+
+        bool operator==(const Desc& other) const {
+            return _borderColor == other._borderColor &&
+                _maxAnisotropy == other._maxAnisotropy &&
+                _filter == other._filter &&
+                _comparisonFunc == other._comparisonFunc &&
+                _wrapModeU == other._wrapModeU &&
+                _wrapModeV == other._wrapModeV &&
+                _wrapModeW == other._wrapModeW &&
+                _minMip == other._minMip &&
+                _maxMip == other._maxMip;
+        }
    };

    Sampler() {}
@ -151,11 +164,17 @@ public:
    ComparisonFunction getComparisonFunction() const { return ComparisonFunction(_desc._comparisonFunc); }
    bool doComparison() const { return getComparisonFunction() != ALWAYS; }

-    uint8 getMipOffset() const { return _desc._mipOffset; }
    uint8 getMinMip() const { return _desc._minMip; }
    uint8 getMaxMip() const { return _desc._maxMip; }

    const Desc& getDesc() const { return _desc; }
+
+    bool operator==(const Sampler& other) const {
+        return _desc == other._desc;
+    }
+    bool operator!=(const Sampler& other) const {
+        return !(*this == other);
+    }
 protected:
    Desc _desc;
 };
@ -666,6 +685,17 @@ typedef std::shared_ptr< TextureSource > TextureSourcePointer;

 };

+namespace std {
+    template<> struct hash<gpu::Sampler> {
+        size_t operator()(const gpu::Sampler& sampler) const noexcept {
+            size_t result = 0;
+            const auto& desc = sampler.getDesc();
+            hash_combine(result, desc._comparisonFunc, desc._filter, desc._maxAnisotropy, desc._maxMip, desc._minMip, desc._wrapModeU, desc._wrapModeV, desc._wrapModeW);
+            return result;
+        }
+    };
+}
+
 Q_DECLARE_METATYPE(gpu::TexturePointer)

 #endif
--- a/libraries/gpu/src/gpu/TextureTable.cpp
+++ b/libraries/gpu/src/gpu/TextureTable.cpp
@ -0,0 +1,54 @@
+//
+//  Created by Bradley Austin Davis on 2017/01/25
+//  Copyright 2013-2017 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
+//
+#include "TextureTable.h"
+#include "Texture.h"
+
+#include <shared/GlobalAppProperties.h>
+using namespace gpu;
+
+
+const size_t TextureTable::COUNT{ TEXTURE_TABLE_COUNT };
+
+TextureTable::TextureTable() { }
+
+TextureTable::TextureTable(const std::initializer_list<TexturePointer>& textures) {
+    auto max = std::min<size_t>(COUNT, textures.size());
+    auto itr = textures.begin();
+    size_t index = 0;
+    while (itr != textures.end() && index < max) {
+        setTexture(index, *itr);
+        ++index;
+    }
+}
+
+TextureTable::TextureTable(const Array& textures) : _textures(textures) {
+}
+
+void TextureTable::setTexture(size_t index, const TexturePointer& texturePointer) {
+    if (index >= COUNT || _textures[index] == texturePointer) {
+        return;
+    }
+    {
+        Lock lock(_mutex);
+        ++_stamp;
+        _textures[index] = texturePointer;
+    }
+}
+
+void TextureTable::setTexture(size_t index, const TextureView& textureView) {
+    setTexture(index, textureView._texture);
+}
+
+TextureTable::Array TextureTable::getTextures() const {
+     Array result; 
+     {
+         Lock lock(_mutex);
+         result = _textures;
+     }
+     return result; 
+}
--- a/libraries/gpu/src/gpu/TextureTable.h
+++ b/libraries/gpu/src/gpu/TextureTable.h
@ -0,0 +1,44 @@
+//
+//  Created by Bradley Austin Davis on 2017/01/25
+//  Copyright 2013-2017 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
+//
+#ifndef hifi_gpu_TextureTable_h
+#define hifi_gpu_TextureTable_h
+
+#include "Forward.h"
+
+#include <array>
+
+#define TEXTURE_TABLE_COUNT 8
+
+namespace gpu {
+
+class TextureTable {
+public:
+    static const size_t COUNT;
+    using Array = std::array<TexturePointer, TEXTURE_TABLE_COUNT>;
+    TextureTable();
+    TextureTable(const std::initializer_list<TexturePointer>& textures);
+    TextureTable(const Array& textures);
+
+    // Only for gpu::Context
+    const GPUObjectPointer gpuObject{};
+
+    void setTexture(size_t index, const TexturePointer& texturePointer);
+    void setTexture(size_t index, const TextureView& texturePointer);
+
+    Array getTextures() const;
+    Stamp getStamp() const { return _stamp; }
+
+private:
+    mutable Mutex _mutex;
+    Array _textures;
+    Stamp _stamp{ 1 };
+};
+
+}
+
+#endif
--- a/libraries/gpu/src/gpu/TextureTable.slh
+++ b/libraries/gpu/src/gpu/TextureTable.slh
@ -0,0 +1,38 @@
+<!
+//  gpu/TextureTable.slh
+//
+//  Created by Sam Gateau on 1/25/17.
+//  Copyright 2013 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
+!>
+<@if not GPU_TEXTURE_TABLE_SLH@>
+<@def GPU_TEXTURE_TABLE_SLH@>
+
+#ifdef GPU_TEXTURE_TABLE_BINDLESS
+#define GPU_TEXTURE_TABLE_MAX_NUM_TEXTURES 8
+
+struct GPUTextureTable {
+    uvec4 _textures[GPU_TEXTURE_TABLE_MAX_NUM_TEXTURES];
+};
+
+#define TextureTable(index, name) layout (std140) uniform gpu_resourceTextureTable##index { GPUTextureTable name; }
+
+#define tableTex(name, slot) sampler2D(name._textures[slot].xy)
+#define tableTexMinLod(name, slot) float(name._textures[slot].z)
+
+#define tableTexValue(name, slot, uv) \
+    tableTexValueLod(tableTex(matTex, albedoMap), tableTexMinLod(matTex, albedoMap), uv)
+    
+vec4 tableTexValueLod(sampler2D sampler, float minLod, vec2 uv) {
+    float queryLod = textureQueryLod(sampler, uv).x;
+    queryLod = max(minLod, queryLod);
+    return textureLod(sampler, uv, queryLod);
+}
+ 
+#else
+
+#endif
+
+<@endif@>
--- a/libraries/gpu/src/gpu/Texture_ktx.cpp
+++ b/libraries/gpu/src/gpu/Texture_ktx.cpp
@ -504,6 +504,8 @@ TexturePointer Texture::build(const ktx::KTXDescriptor& descriptor) {
        gpuktxKeyValue._usage = Texture::Usage::Builder().withColor().withAlpha().build();
    }

+    auto samplerDesc = gpuktxKeyValue._samplerDesc;
+    samplerDesc._maxMip = gpu::Sampler::MAX_MIP_LEVEL;
    auto texture = create(gpuktxKeyValue._usageType,
        type,
        texelFormat,
@ -513,7 +515,7 @@ TexturePointer Texture::build(const ktx::KTXDescriptor& descriptor) {
        1, // num Samples
        header.getNumberOfSlices(),
        header.getNumberOfLevels(),
-        gpuktxKeyValue._samplerDesc);
+        samplerDesc);
    texture->setUsage(gpuktxKeyValue._usage);

    // Assing the mips availables
--- a/libraries/graphics/src/graphics/Material.h
+++ b/libraries/graphics/src/graphics/Material.h
@ -20,6 +20,7 @@
 #include <ColorUtils.h>

 #include <gpu/Resource.h>
+#include <gpu/TextureTable.h>

 class Transform;

@ -361,6 +362,8 @@ public:
    const std::string& getModel() const { return _model; }
    void setModel(const std::string& model) { _model = model; }

+    const gpu::TextureTablePointer& getTextureTable() const { return _textureTable; }
+
 protected:
    std::string _name { "" };

@ -368,6 +371,7 @@ private:
    mutable MaterialKey _key;
    mutable UniformBufferView _schemaBuffer;
    mutable UniformBufferView _texMapArrayBuffer;
+    mutable gpu::TextureTablePointer _textureTable{ std::make_shared<gpu::TextureTable>() };

    TextureMaps _textureMaps;

--- a/libraries/qml/src/qml/impl/SharedObject.cpp
+++ b/libraries/qml/src/qml/impl/SharedObject.cpp
@ -69,6 +69,7 @@ SharedObject::SharedObject() {
    _quickWindow->setColor(QColor(255, 255, 255, 0));
    _quickWindow->setClearBeforeRendering(true);

+
    QObject::connect(qApp, &QCoreApplication::aboutToQuit, this, &SharedObject::onAboutToQuit);
 }

@ -124,6 +125,7 @@ void SharedObject::setRootItem(QQuickItem* rootItem) {
    _renderThread->setObjectName(objectName());
    _renderThread->start();

+
    // Create event handler for the render thread
    _renderObject = new RenderEventHandler(this, _renderThread);
    QCoreApplication::postEvent(this, new OffscreenEvent(OffscreenEvent::Initialize));
@ -152,9 +154,16 @@ void SharedObject::destroy() {
    QObject::disconnect(_renderControl);
    QObject::disconnect(qApp);

-    QMutexLocker lock(&_mutex);
-    _quit = true;
-    QCoreApplication::postEvent(_renderObject, new OffscreenEvent(OffscreenEvent::Quit));
+    {
+        QMutexLocker lock(&_mutex);
+        _quit = true;
+        QCoreApplication::postEvent(_renderObject, new OffscreenEvent(OffscreenEvent::Quit), Qt::HighEventPriority);
+    }
+    // Block until the rendering thread has stopped
+    // FIXME this is undesirable because this is blocking the main thread,
+    // but I haven't found a reliable way to do this only at application 
+    // shutdown
+    _renderThread->wait();
 }


--- a/libraries/render-utils/src/MaterialTextures.slh
+++ b/libraries/render-utils/src/MaterialTextures.slh
@ -48,6 +48,74 @@ TexMapArray getTexMapArray() {

 <@func declareMaterialTextures(withAlbedo, withRoughness, withNormal, withMetallic, withEmissive, withOcclusion, withScattering)@>

+<@include gpu/TextureTable.slh@>
+
+#ifdef GPU_TEXTURE_TABLE_BINDLESS
+
+TextureTable(0, matTex);
+<!
+    ALBEDO = 0,
+    NORMAL, 1
+    METALLIC, 2
+    EMISSIVE_LIGHTMAP, 3
+    ROUGHNESS, 4
+    OCCLUSION, 5
+    SCATTERING, 6
+!>
+
+<@if withAlbedo@>
+#define albedoMap 0
+vec4 fetchAlbedoMap(vec2 uv) {
+    return tableTexValue(matTex, albedoMap, uv);
+}
+<@endif@>
+
+<@if withRoughness@>
+#define roughnessMap 4
+float fetchRoughnessMap(vec2 uv) {
+    return tableTexValue(matTex, roughnessMap, uv).r;
+}
+<@endif@>
+
+<@if withNormal@>
+#define normalMap 1
+vec3 fetchNormalMap(vec2 uv) {
+    return tableTexValue(matTex, normalMap, uv).xyz;
+}
+<@endif@>
+
+<@if withMetallic@>
+#define metallicMap 2
+float fetchMetallicMap(vec2 uv) {
+    return tableTexValue(matTex, metallicMap, uv).r;
+}
+<@endif@>
+
+<@if withEmissive@>
+#define emissiveMap 3
+vec3 fetchEmissiveMap(vec2 uv) {
+    return tableTexValue(matTex, emissiveMap, uv).rgb;
+}
+<@endif@>
+
+<@if withOcclusion@>
+#define occlusionMap 5
+float fetchOcclusionMap(vec2 uv) {
+    return tableTexValue(matTex, occlusionMap, uv).r;
+}
+<@endif@>
+
+<@if withScattering@>
+#define scatteringMap 6
+float fetchScatteringMap(vec2 uv) {
+    float scattering = texture(tableTex(matTex, scatteringMap), uv).r; // boolean scattering for now
+    return max(((scattering - 0.1) / 0.9), 0.0);
+    return tableTexValue(matTex, scatteringMap, uv).r; // boolean scattering for now
+}
+<@endif@>
+
+#else
+
 <@if withAlbedo@>
 uniform sampler2D albedoMap;
 vec4 fetchAlbedoMap(vec2 uv) {
@ -102,6 +170,8 @@ float fetchScatteringMap(vec2 uv) {
 }
 <@endif@>

+#endif
+
 <@endfunc@>


--- a/libraries/render-utils/src/MeshPartPayload.cpp
+++ b/libraries/render-utils/src/MeshPartPayload.cpp
@ -152,7 +152,7 @@ void MeshPartPayload::bindMesh(gpu::Batch& batch) {
    batch.setInputStream(0, _drawMesh->getVertexStream());
 }

-void MeshPartPayload::bindTransform(gpu::Batch& batch, RenderArgs::RenderMode renderMode) const {
+ void MeshPartPayload::bindTransform(gpu::Batch& batch, RenderArgs::RenderMode renderMode) const {
    batch.setModelTransform(_drawTransform);
 }

--- a/libraries/render-utils/src/RenderPipelines.cpp
+++ b/libraries/render-utils/src/RenderPipelines.cpp
@ -612,7 +612,8 @@ void initZPassPipelines(ShapePlumber& shapePlumber, gpu::StatePointer state) {
 #include "RenderPipelines.h"
 #include <model-networking/TextureCache.h>

-void RenderPipelines::bindMaterial(graphics::MaterialPointer material, gpu::Batch& batch, bool enableTextures) {
+// FIXME find a better way to setup the default textures
+void RenderPipelines::bindMaterial(const graphics::MaterialPointer& material, gpu::Batch& batch, bool enableTextures) {
    if (!material) {
        return;
    }
@ -630,84 +631,65 @@ void RenderPipelines::bindMaterial(graphics::MaterialPointer material, gpu::Batc
        numUnlit++;
    }

-    if (!enableTextures) {
-        batch.setResourceTexture(ShapePipeline::Slot::ALBEDO, textureCache->getWhiteTexture());
-        batch.setResourceTexture(ShapePipeline::Slot::MAP::ROUGHNESS, textureCache->getWhiteTexture());
-        batch.setResourceTexture(ShapePipeline::Slot::MAP::NORMAL, textureCache->getBlueTexture());
-        batch.setResourceTexture(ShapePipeline::Slot::MAP::METALLIC, textureCache->getBlackTexture());
-        batch.setResourceTexture(ShapePipeline::Slot::MAP::OCCLUSION, textureCache->getWhiteTexture());
-        batch.setResourceTexture(ShapePipeline::Slot::MAP::SCATTERING, textureCache->getWhiteTexture());
-        batch.setResourceTexture(ShapePipeline::Slot::MAP::EMISSIVE_LIGHTMAP, textureCache->getBlackTexture());
-        return;
-    }
+    const auto& drawMaterialTextures = material->getTextureTable();

    // Albedo
    if (materialKey.isAlbedoMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::ALBEDO_MAP);
-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::ALBEDO, itr->second->getTextureView());
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::ALBEDO, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::ALBEDO, textureCache->getGrayTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::ALBEDO, textureCache->getWhiteTexture());
        }
    }

    // Roughness map
    if (materialKey.isRoughnessMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::ROUGHNESS_MAP);
-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::ROUGHNESS, itr->second->getTextureView());
-
-            // texcoord are assumed to be the same has albedo
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::ROUGHNESS, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::ROUGHNESS, textureCache->getWhiteTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::ROUGHNESS, textureCache->getWhiteTexture());
        }
    }

    // Normal map
    if (materialKey.isNormalMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::NORMAL_MAP);
-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::NORMAL, itr->second->getTextureView());
-
-            // texcoord are assumed to be the same has albedo
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::NORMAL, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::NORMAL, textureCache->getBlueTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::NORMAL, textureCache->getBlueTexture());
        }
    }

    // Metallic map
    if (materialKey.isMetallicMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::METALLIC_MAP);
-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::METALLIC, itr->second->getTextureView());
-
-            // texcoord are assumed to be the same has albedo
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::METALLIC, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::METALLIC, textureCache->getBlackTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::METALLIC, textureCache->getBlackTexture());
        }
    }

    // Occlusion map
    if (materialKey.isOcclusionMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::OCCLUSION_MAP);
-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::OCCLUSION, itr->second->getTextureView());
-
-            // texcoord are assumed to be the same has albedo
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::OCCLUSION, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::OCCLUSION, textureCache->getWhiteTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::OCCLUSION, textureCache->getWhiteTexture());
        }
    }

    // Scattering map
    if (materialKey.isScatteringMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::SCATTERING_MAP);
-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::SCATTERING, itr->second->getTextureView());
-
-            // texcoord are assumed to be the same has albedo
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::SCATTERING, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::SCATTERING, textureCache->getWhiteTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::SCATTERING, textureCache->getWhiteTexture());
        }
    }

@ -715,18 +697,19 @@ void RenderPipelines::bindMaterial(graphics::MaterialPointer material, gpu::Batc
    if (materialKey.isLightmapMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::LIGHTMAP_MAP);

-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::EMISSIVE_LIGHTMAP, itr->second->getTextureView());
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::EMISSIVE_LIGHTMAP, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::EMISSIVE_LIGHTMAP, textureCache->getGrayTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::EMISSIVE_LIGHTMAP, textureCache->getGrayTexture());
        }
    } else if (materialKey.isEmissiveMap()) {
        auto itr = textureMaps.find(graphics::MaterialKey::EMISSIVE_MAP);
-
-        if (itr != textureMaps.end() && itr->second->isDefined()) {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::EMISSIVE_LIGHTMAP, itr->second->getTextureView());
+        if (enableTextures && itr != textureMaps.end() && itr->second->isDefined()) {
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::EMISSIVE_LIGHTMAP, itr->second->getTextureView());
        } else {
-            batch.setResourceTexture(ShapePipeline::Slot::MAP::EMISSIVE_LIGHTMAP, textureCache->getBlackTexture());
+            drawMaterialTextures->setTexture(ShapePipeline::Slot::EMISSIVE_LIGHTMAP, textureCache->getBlackTexture());
        }
    }
+
+    batch.setResourceTextureTable(material->getTextureTable());
 }
--- a/libraries/render-utils/src/RenderPipelines.h
+++ b/libraries/render-utils/src/RenderPipelines.h
@ -15,7 +15,7 @@

 class RenderPipelines {
 public:
-    static void bindMaterial(graphics::MaterialPointer material, gpu::Batch& batch, bool enableTextures);
+    static void bindMaterial(const graphics::MaterialPointer& material, gpu::Batch& batch, bool enableTextures);
 };


--- a/libraries/render/src/render/Item.cpp
+++ b/libraries/render/src/render/Item.cpp
@ -118,9 +118,15 @@ uint32_t Item::fetchMetaSubItemBounds(ItemBounds& subItemBounds, Scene& scene) c
    auto numSubs = fetchMetaSubItems(subItems);

    for (auto id : subItems) {
-        auto& item = scene.getItem(id);
-        if (item.exist()) {
-            subItemBounds.emplace_back(id, item.getBound());
+        // TODO: Adding an extra check here even thought we shouldn't have too.
+        // We have cases when the id returned by fetchMetaSubItems is not allocated
+        if (scene.isAllocatedID(id)) {
+            auto& item = scene.getItem(id);
+            if (item.exist()) {
+                subItemBounds.emplace_back(id, item.getBound());
+            } else {
+                numSubs--;
+            }
        } else {
            numSubs--;
        }
--- a/scripts/developer/utilities/audio/audioScope.js
+++ b/scripts/developer/utilities/audio/audioScope.js
@ -1,4 +1,4 @@
-var qml = Script.resourcesPath() + '/qml/AudioScope.qml';
+var qml = Script.resourcesPath() + '/qml/AudioScopeUI.qml';
 var window = new OverlayWindow({
    title: 'Audio Scope',
    source: qml,
@ -14,4 +14,4 @@ window.closed.connect(function () {
 	AudioScope.setServerEcho(false);
 	AudioScope.selectAudioScopeFiveFrames();
 	Script.stop(); 
-});
+});
--- a/scripts/system/bubble.js
+++ b/scripts/system/bubble.js
@ -89,14 +89,8 @@
        bubbleOverlayTimestamp = nowTimestamp;
        Script.update.connect(update);
        updateConnected = true;
-
-        // Flash button
-        if (!bubbleFlashTimer) {
-            bubbleFlashTimer = Script.setInterval(function () {
-                writeButtonProperties(bubbleButtonFlashState);
-                bubbleButtonFlashState = !bubbleButtonFlashState;
-            }, 500);
-        }
+        writeButtonProperties(bubbleButtonFlashState);
+        bubbleButtonFlashState = !bubbleButtonFlashState;
    }

    // Called from the C++ scripting interface to show the bubble overlay
--- a/scripts/system/controllers/controllerModules/farActionGrabEntity.js
+++ b/scripts/system/controllers/controllerModules/farActionGrabEntity.js
@ -475,7 +475,7 @@ Script.include("/~/system/libraries/Xform.js");
                        entityID = targetEntity.id;
                        targetProps = targetEntity.props;

-                        if (entityIsGrabbable(targetProps)) {
+                        if (entityIsGrabbable(targetProps) || entityIsGrabbable(this.targetObject.entityProps)) {
                            if (!entityIsDistanceGrabbable(targetProps)) {
                                this.targetObject.makeDynamic();
                            }