Merge branch 'master' of git://github.com/highfidelity/hifi into csm

assignment-client/CMakeLists.txt

@@ -13,9 +13,25 @@ setup_memory_debugger()
 link_hifi_libraries(
   audio avatars octree gpu model fbx entities
   networking animation recording shared script-engine embedded-webserver
-  controllers physics plugins midi baking image
+  controllers physics plugins midi image
 )
 
+add_dependencies(${TARGET_NAME} oven)
+
+if (WIN32)
+  add_custom_command(
+    TARGET ${TARGET_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+            $<TARGET_FILE_DIR:oven>
+            $<TARGET_FILE_DIR:${TARGET_NAME}>)
+else()
+  add_custom_command(
+    TARGET ${TARGET_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E create_symlink
+            $<TARGET_FILE:oven>
+            $<TARGET_FILE_DIR:${TARGET_NAME}>/oven)
+endif()
+
 if (WIN32)
   package_libraries_for_deployment()
 endif()

assignment-client/src/assets/AssetServer.cpp

@@ -29,11 +29,10 @@
 #include <QtCore/QUrlQuery>
 
 #include <ClientServerUtils.h>
-#include <FBXBaker.h>
-#include <JSBaker.h>
 #include <NodeType.h>
 #include <SharedUtil.h>
 #include <PathUtils.h>
+#include <image/Image.h>
 
 #include "AssetServerLogging.h"
 #include "BakeAssetTask.h"
@@ -250,7 +249,7 @@ AssetServer::AssetServer(ReceivedMessage& message) :
     image::setNormalTexturesCompressionEnabled(true);
     image::setCubeTexturesCompressionEnabled(true);
 
-    BAKEABLE_TEXTURE_EXTENSIONS = TextureBaker::getSupportedFormats();
+    BAKEABLE_TEXTURE_EXTENSIONS = image::getSupportedFormats();
     qDebug() << "Supported baking texture formats:" << BAKEABLE_MODEL_EXTENSIONS;
 
     // Most of the work will be I/O bound, reading from disk and constructing packet objects,
@@ -416,6 +415,9 @@ void AssetServer::completeSetup() {
     if (assetsFilesizeLimit != 0 && assetsFilesizeLimit < MAX_UPLOAD_SIZE) {
         _filesizeLimit = assetsFilesizeLimit * BITS_PER_MEGABITS;
     }
+
+    PathUtils::removeTemporaryApplicationDirs();
+    PathUtils::removeTemporaryApplicationDirs("Oven");
 }
 
 void AssetServer::cleanupUnmappedFiles() {

assignment-client/src/assets/BakeAssetTask.cpp

@@ -11,11 +11,18 @@
 
 #include "BakeAssetTask.h"
 
-#include <QtCore/QThread>
+#include <mutex>
+
+#include <QtCore/QThread>
+#include <QCoreApplication>
 
-#include <FBXBaker.h>
 #include <PathUtils.h>
-#include <JSBaker.h>
+
+static const int OVEN_STATUS_CODE_SUCCESS { 0 };
+static const int OVEN_STATUS_CODE_FAIL { 1 };
+static const int OVEN_STATUS_CODE_ABORT { 2 };
+
+std::once_flag registerMetaTypesFlag;
 
 BakeAssetTask::BakeAssetTask(const AssetHash& assetHash, const AssetPath& assetPath, const QString& filePath) :
     _assetHash(assetHash),
@@ -23,6 +30,10 @@ BakeAssetTask::BakeAssetTask(const AssetHash& assetHash, const AssetPath& assetP
     _filePath(filePath)
 {
 
+    std::call_once(registerMetaTypesFlag, []() {
+        qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");
+        qRegisterMetaType<QProcess::ExitStatus>("QProcess::ExitStatus");
+    });
 }
 
 void cleanupTempFiles(QString tempOutputDir, std::vector<QString> files) {
@@ -41,67 +52,76 @@ void cleanupTempFiles(QString tempOutputDir, std::vector<QString> files) {
 };
 
 void BakeAssetTask::run() {
-    _isBaking.store(true);
-
-    qRegisterMetaType<QVector<QString> >("QVector<QString>");
-    TextureBakerThreadGetter fn = []() -> QThread* { return QThread::currentThread();  };
-
-    QString tempOutputDir;
-
-    if (_assetPath.endsWith(".fbx")) {
-        tempOutputDir = PathUtils::generateTemporaryDir();
-        _baker = std::unique_ptr<FBXBaker> {
-            new FBXBaker(QUrl("file:///" + _filePath), fn, tempOutputDir)
-        };
-    } else if (_assetPath.endsWith(".js", Qt::CaseInsensitive)) {
-        _baker = std::unique_ptr<JSBaker>{
-            new JSBaker(QUrl("file:///" + _filePath), PathUtils::generateTemporaryDir())
-        };
-    } else {
-        tempOutputDir = PathUtils::generateTemporaryDir();
-        _baker = std::unique_ptr<TextureBaker> {
-            new TextureBaker(QUrl("file:///" + _filePath), image::TextureUsage::CUBE_TEXTURE,
-                             tempOutputDir)
-        };
+    if (_isBaking.exchange(true)) {
+        qWarning() << "Tried to start bake asset task while already baking";
+        return;
     }
 
-    QEventLoop loop;
-    connect(_baker.get(), &Baker::finished, &loop, &QEventLoop::quit);
-    connect(_baker.get(), &Baker::aborted, &loop, &QEventLoop::quit);
-    QMetaObject::invokeMethod(_baker.get(), "bake", Qt::QueuedConnection);
-    loop.exec();
+    QString tempOutputDir = PathUtils::generateTemporaryDir();
+    auto base = QFileInfo(QCoreApplication::applicationFilePath()).absoluteDir();
+    QString path = base.absolutePath() + "/oven";
+    QString extension = _assetPath.mid(_assetPath.lastIndexOf('.') + 1);
+    QStringList args {
+        "-i", _filePath,
+        "-o", tempOutputDir,
+        "-t", extension,
+    };
 
-    if (_baker->wasAborted()) {
-        qDebug() << "Aborted baking: " << _assetHash << _assetPath;
+    _ovenProcess.reset(new QProcess());
 
-        _wasAborted.store(true);
+    connect(_ovenProcess.get(), static_cast<void(QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
+            this, [this, tempOutputDir](int exitCode, QProcess::ExitStatus exitStatus) {
+        qDebug() << "Baking process finished: " << exitCode << exitStatus;
 
-        cleanupTempFiles(tempOutputDir, _baker->getOutputFiles());
+        if (exitStatus == QProcess::CrashExit) {
+            if (_wasAborted) {
+                emit bakeAborted(_assetHash, _assetPath);
+            } else {
+                QString errors = "Fatal error occurred while baking";
+                emit bakeFailed(_assetHash, _assetPath, errors);
+            }
+        } else if (exitCode == OVEN_STATUS_CODE_SUCCESS) {
+            QDir outputDir = tempOutputDir;
+            auto files = outputDir.entryInfoList(QDir::Files);
+            QVector<QString> outputFiles;
+            for (auto& file : files) {
+                outputFiles.push_back(file.absoluteFilePath());
+            }
 
-        emit bakeAborted(_assetHash, _assetPath);
-    } else if (_baker->hasErrors()) {
-        qDebug() << "Failed to bake: " << _assetHash << _assetPath << _baker->getErrors();
+            emit bakeComplete(_assetHash, _assetPath, tempOutputDir, outputFiles);
+        } else if (exitStatus == QProcess::NormalExit && exitCode == OVEN_STATUS_CODE_ABORT) {
+            _wasAborted.store(true);
+            emit bakeAborted(_assetHash, _assetPath);
+        } else {
+            QString errors;
+            if (exitCode == OVEN_STATUS_CODE_FAIL) {
+                QDir outputDir = tempOutputDir;
+                auto errorFilePath = outputDir.absoluteFilePath("errors.txt");
+                QFile errorFile { errorFilePath };
+                if (errorFile.open(QIODevice::ReadOnly)) {
+                    errors = errorFile.readAll();
+                    errorFile.close();
+                } else {
+                    errors = "Unknown error occurred while baking";
+                }
+            }
+            emit bakeFailed(_assetHash, _assetPath, errors);
+        }
 
-        auto errors = _baker->getErrors().join('\n'); // Join error list into a single string for convenience
-
-        _didFinish.store(true);
-
-        cleanupTempFiles(tempOutputDir, _baker->getOutputFiles());
+    });
 
+    qDebug() << "Starting oven for " << _assetPath;
+    _ovenProcess->start(path, args, QIODevice::ReadOnly);
+    if (!_ovenProcess->waitForStarted(-1)) {
+        QString errors = "Oven process failed to start";
         emit bakeFailed(_assetHash, _assetPath, errors);
-    } else {
-        auto vectorOutputFiles = QVector<QString>::fromStdVector(_baker->getOutputFiles());
-
-        qDebug() << "Finished baking: " << _assetHash << _assetPath << vectorOutputFiles;
-
-        _didFinish.store(true);
-
-        emit bakeComplete(_assetHash, _assetPath, tempOutputDir, vectorOutputFiles);
+        return;
     }
+    _ovenProcess->waitForFinished();
 }
 
 void BakeAssetTask::abort() {
-    if (_baker) {
-        _baker->abort();
+    if (!_wasAborted.exchange(true)) {
+        _ovenProcess->terminate();
     }
 }

assignment-client/src/assets/BakeAssetTask.h

@@ -17,9 +17,10 @@
 #include <QtCore/QDebug>
 #include <QtCore/QObject>
 #include <QtCore/QRunnable>
+#include <QDir>
+#include <QProcess>
 
 #include <AssetUtils.h>
-#include <Baker.h>
 
 class BakeAssetTask : public QObject, public QRunnable {
     Q_OBJECT
@@ -32,7 +33,6 @@ public:
 
     void abort();
     bool wasAborted() const { return _wasAborted.load(); }
-    bool didFinish() const { return _didFinish.load(); }
 
 signals:
     void bakeComplete(QString assetHash, QString assetPath, QString tempOutputDir, QVector<QString> outputFiles);
@@ -44,9 +44,8 @@ private:
     AssetHash _assetHash;
     AssetPath _assetPath;
     QString _filePath;
-    std::unique_ptr<Baker> _baker;
+    std::unique_ptr<QProcess> _ovenProcess { nullptr };
     std::atomic<bool> _wasAborted { false };
-    std::atomic<bool> _didFinish { false };
 };
 
 #endif // hifi_BakeAssetTask_h

assignment-client/src/avatars/AvatarMixer.cpp

@@ -870,8 +870,8 @@ AvatarMixerClientData* AvatarMixer::getOrCreateClientData(SharedNodePointer node
         node->setLinkedData(std::unique_ptr<NodeData> { new AvatarMixerClientData(node->getUUID()) });
         clientData = dynamic_cast<AvatarMixerClientData*>(node->getLinkedData());
         auto& avatar = clientData->getAvatar();
-        avatar.setDomainMinimumScale(_domainMinimumScale);
-        avatar.setDomainMaximumScale(_domainMaximumScale);
+        avatar.setDomainMinimumHeight(_domainMinimumHeight);
+        avatar.setDomainMaximumHeight(_domainMaximumHeight);
     }
 
     return clientData;
@@ -939,21 +939,21 @@ void AvatarMixer::parseDomainServerSettings(const QJsonObject& domainSettings) {
 
     const QString AVATARS_SETTINGS_KEY = "avatars";
 
-    static const QString MIN_SCALE_OPTION = "min_avatar_scale";
-    float settingMinScale = domainSettings[AVATARS_SETTINGS_KEY].toObject()[MIN_SCALE_OPTION].toDouble(MIN_AVATAR_SCALE);
-    _domainMinimumScale = glm::clamp(settingMinScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE);
+    static const QString MIN_HEIGHT_OPTION = "min_avatar_height";
+    float settingMinHeight = domainSettings[AVATARS_SETTINGS_KEY].toObject()[MIN_HEIGHT_OPTION].toDouble(MIN_AVATAR_HEIGHT);
+    _domainMinimumHeight = glm::clamp(settingMinHeight, MIN_AVATAR_HEIGHT, MAX_AVATAR_HEIGHT);
 
-    static const QString MAX_SCALE_OPTION = "max_avatar_scale";
-    float settingMaxScale = domainSettings[AVATARS_SETTINGS_KEY].toObject()[MAX_SCALE_OPTION].toDouble(MAX_AVATAR_SCALE);
-    _domainMaximumScale = glm::clamp(settingMaxScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE);
+    static const QString MAX_HEIGHT_OPTION = "max_avatar_height";
+    float settingMaxHeight = domainSettings[AVATARS_SETTINGS_KEY].toObject()[MAX_HEIGHT_OPTION].toDouble(MAX_AVATAR_HEIGHT);
+    _domainMaximumHeight = glm::clamp(settingMaxHeight, MIN_AVATAR_HEIGHT, MAX_AVATAR_HEIGHT);
 
     // make sure that the domain owner didn't flip min and max
-    if (_domainMinimumScale > _domainMaximumScale) {
-        std::swap(_domainMinimumScale, _domainMaximumScale);
+    if (_domainMinimumHeight > _domainMaximumHeight) {
+        std::swap(_domainMinimumHeight, _domainMaximumHeight);
     }
 
-    qCDebug(avatars) << "This domain requires a minimum avatar scale of" << _domainMinimumScale
-                     << "and a maximum avatar scale of" << _domainMaximumScale;
+    qCDebug(avatars) << "This domain requires a minimum avatar height of" << _domainMinimumHeight
+                     << "and a maximum avatar height of" << _domainMaximumHeight;
 
     const QString AVATAR_WHITELIST_DEFAULT{ "" };
     static const QString AVATAR_WHITELIST_OPTION = "avatar_whitelist";

assignment-client/src/avatars/AvatarMixer.h

@@ -90,8 +90,8 @@ private:
 
     float _maxKbpsPerNode = 0.0f;
 
-    float _domainMinimumScale { MIN_AVATAR_SCALE };
-    float _domainMaximumScale { MAX_AVATAR_SCALE };
+    float _domainMinimumHeight { MIN_AVATAR_HEIGHT };
+    float _domainMaximumHeight { MAX_AVATAR_HEIGHT };
 
     RateCounter<> _broadcastRate;
     p_high_resolution_clock::time_point _lastDebugMessage;

assignment-client/src/avatars/AvatarMixerClientData.cpp

@@ -25,6 +25,23 @@ AvatarMixerClientData::AvatarMixerClientData(const QUuid& nodeID) :
     _avatar->setID(nodeID);
 }
 
+uint64_t AvatarMixerClientData::getLastOtherAvatarEncodeTime(QUuid otherAvatar) const {
+    std::unordered_map<QUuid, uint64_t>::const_iterator itr = _lastOtherAvatarEncodeTime.find(otherAvatar);
+    if (itr != _lastOtherAvatarEncodeTime.end()) {
+        return itr->second;
+    }
+    return 0;
+}
+
+void AvatarMixerClientData::setLastOtherAvatarEncodeTime(const QUuid& otherAvatar, const uint64_t& time) {
+    std::unordered_map<QUuid, uint64_t>::iterator itr = _lastOtherAvatarEncodeTime.find(otherAvatar);
+    if (itr != _lastOtherAvatarEncodeTime.end()) {
+        itr->second = time;
+    } else {
+        _lastOtherAvatarEncodeTime.emplace(std::pair<QUuid, uint64_t>(otherAvatar, time));
+    }
+}
+
 void AvatarMixerClientData::queuePacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer node) {
     if (!_packetQueue.node) {
         _packetQueue.node = node;

assignment-client/src/avatars/AvatarMixerClientData.h

@@ -110,16 +110,10 @@ public:
     bool getRequestsDomainListData() { return _requestsDomainListData; }
     void setRequestsDomainListData(bool requesting) { _requestsDomainListData = requesting; }
 
-    ViewFrustum getViewFrustom() const { return _currentViewFrustum; }
+    ViewFrustum getViewFrustum() const { return _currentViewFrustum; }
 
-    quint64 getLastOtherAvatarEncodeTime(QUuid otherAvatar) {
-        quint64 result = 0;
-        if (_lastOtherAvatarEncodeTime.find(otherAvatar) != _lastOtherAvatarEncodeTime.end()) {
-            result = _lastOtherAvatarEncodeTime[otherAvatar];
-        }
-        _lastOtherAvatarEncodeTime[otherAvatar] = usecTimestampNow();
-        return result;
-    }
+    uint64_t getLastOtherAvatarEncodeTime(QUuid otherAvatar) const;
+    void setLastOtherAvatarEncodeTime(const QUuid& otherAvatar, const uint64_t& time);
 
     QVector<JointData>& getLastOtherAvatarSentJoints(QUuid otherAvatar) {
         _lastOtherAvatarSentJoints[otherAvatar].resize(_avatar->getJointCount());
@@ -143,7 +137,7 @@ private:
 
     // this is a map of the last time we encoded an "other" avatar for
     // sending to "this" node
-    std::unordered_map<QUuid, quint64> _lastOtherAvatarEncodeTime;
+    std::unordered_map<QUuid, uint64_t> _lastOtherAvatarEncodeTime;
     std::unordered_map<QUuid, QVector<JointData>> _lastOtherAvatarSentJoints;
 
     uint64_t _identityChangeTimestamp;

assignment-client/src/avatars/AvatarMixerSlave.cpp

@@ -22,6 +22,7 @@
 #include <NodeList.h>
 #include <Node.h>
 #include <OctreeConstants.h>
+#include <PrioritySortUtil.h>
 #include <udt/PacketHeaders.h>
 #include <SharedUtil.h>
 #include <StDev.h>
@@ -32,6 +33,10 @@
 #include "AvatarMixerClientData.h"
 #include "AvatarMixerSlave.h"
 
+namespace PrioritySortUtil {
+    // we declare this callback here but override it later
+    std::function<uint64_t(const AvatarSharedPointer&)> getAvatarAgeCallback = [] (const AvatarSharedPointer& avatar) { return 0; };
+}
 
 void AvatarMixerSlave::configure(ConstIter begin, ConstIter end) {
     _begin = begin;
@@ -184,10 +189,8 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
 
 
     // setup list of AvatarData as well as maps to map betweeen the AvatarData and the original nodes
-    // for calling the AvatarData::sortAvatars() function and getting our sorted list of client nodes
-    QList<AvatarSharedPointer> avatarList;
+    std::vector<AvatarSharedPointer> avatarsToSort;
     std::unordered_map<AvatarSharedPointer, SharedNodePointer> avatarDataToNodes;
-
     std::for_each(_begin, _end, [&](const SharedNodePointer& otherNode) {
         // make sure this is an agent that we have avatar data for before considering it for inclusion
         if (otherNode->getType() == NodeType::Agent
@@ -195,36 +198,61 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
             const AvatarMixerClientData* otherNodeData = reinterpret_cast<const AvatarMixerClientData*>(otherNode->getLinkedData());
 
             AvatarSharedPointer otherAvatar = otherNodeData->getAvatarSharedPointer();
-            avatarList << otherAvatar;
+            avatarsToSort.push_back(otherAvatar);
             avatarDataToNodes[otherAvatar] = otherNode;
         }
     });
 
-    AvatarSharedPointer thisAvatar = nodeData->getAvatarSharedPointer();
-    ViewFrustum cameraView = nodeData->getViewFrustom();
-    std::priority_queue<AvatarPriority> sortedAvatars;
-    AvatarData::sortAvatars(avatarList, cameraView, sortedAvatars,
-                            [&](AvatarSharedPointer avatar)->uint64_t {
-        auto avatarNode = avatarDataToNodes[avatar];
-        assert(avatarNode); // we can't have gotten here without the avatarData being a valid key in the map
-        return nodeData->getLastBroadcastTime(avatarNode->getUUID());
-    }, [&](AvatarSharedPointer avatar)->float{
-        glm::vec3 nodeBoxHalfScale = (avatar->getWorldPosition() - avatar->getGlobalBoundingBoxCorner() * avatar->getSensorToWorldScale());
-        return glm::max(nodeBoxHalfScale.x, glm::max(nodeBoxHalfScale.y, nodeBoxHalfScale.z));
-    }, [&](AvatarSharedPointer avatar)->bool {
+    // now that we've assembled the avatarDataToNodes map we can replace PrioritySortUtil::getAvatarAgeCallback
+    // with the true implementation
+    PrioritySortUtil::getAvatarAgeCallback = [&] (const AvatarSharedPointer& avatar) {
+            auto avatarNode = avatarDataToNodes[avatar];
+            assert(avatarNode); // we can't have gotten here without the avatarData being a valid key in the map
+            return nodeData->getLastOtherAvatarEncodeTime(avatarNode->getUUID());
+        };
+
+    class SortableAvatar: public PrioritySortUtil::Sortable {
+    public:
+        SortableAvatar() = delete;
+        SortableAvatar(const AvatarSharedPointer& avatar) : _avatar(avatar) {}
+        glm::vec3 getPosition() const override { return _avatar->getWorldPosition(); }
+        float getRadius() const override {
+            glm::vec3 nodeBoxHalfScale = (_avatar->getWorldPosition() - _avatar->getGlobalBoundingBoxCorner() * _avatar->getSensorToWorldScale());
+            return glm::max(nodeBoxHalfScale.x, glm::max(nodeBoxHalfScale.y, nodeBoxHalfScale.z));
+        }
+        uint64_t getTimestamp() const override {
+            // use the callback implemented above
+            return PrioritySortUtil::getAvatarAgeCallback(_avatar);
+        }
+        const AvatarSharedPointer& getAvatar() const { return _avatar; }
+
+    private:
+        AvatarSharedPointer _avatar;
+    };
+
+    // prepare to sort
+    ViewFrustum cameraView = nodeData->getViewFrustum();
+    PrioritySortUtil::PriorityQueue<SortableAvatar> sortedAvatars(cameraView,
+            AvatarData::_avatarSortCoefficientSize,
+            AvatarData::_avatarSortCoefficientCenter,
+            AvatarData::_avatarSortCoefficientAge);
+
+    // ignore or sort
+    const AvatarSharedPointer& thisAvatar = nodeData->getAvatarSharedPointer();
+    for (const auto& avatar : avatarsToSort) {
         if (avatar == thisAvatar) {
-            return true; // ignore ourselves...
+            // don't echo updates to self
+            continue;
         }
 
         bool shouldIgnore = false;
-
-        // We will also ignore other nodes for a couple of different reasons:
+        // We ignore other nodes for a couple of reasons:
         //   1) ignore bubbles and ignore specific node
         //   2) the node hasn't really updated it's frame data recently, this can
         //      happen if for example the avatar is connected on a desktop and sending
         //      updates at ~30hz. So every 3 frames we skip a frame.
-        auto avatarNode = avatarDataToNodes[avatar];
 
+        auto avatarNode = avatarDataToNodes[avatar];
         assert(avatarNode); // we can't have gotten here without the avatarData being a valid key in the map
 
         const AvatarMixerClientData* avatarNodeData = reinterpret_cast<const AvatarMixerClientData*>(avatarNode->getLinkedData());
@@ -240,7 +268,6 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
             || (avatarNode->isIgnoringNodeWithID(node->getUUID()) && !getsAnyIgnored)) {
             shouldIgnore = true;
         } else {
-
             // Check to see if the space bubble is enabled
             // Don't bother with these checks if the other avatar has their bubble enabled and we're gettingAnyIgnored
             if (node->isIgnoreRadiusEnabled() || (avatarNode->isIgnoreRadiusEnabled() && !getsAnyIgnored)) {
@@ -267,8 +294,6 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
                 nodeData->removeFromRadiusIgnoringSet(node, avatarNode->getUUID());
             }
         }
-        quint64 endIgnoreCalculation = usecTimestampNow();
-        _stats.ignoreCalculationElapsedTime += (endIgnoreCalculation - startIgnoreCalculation);
 
         if (!shouldIgnore) {
             AvatarDataSequenceNumber lastSeqToReceiver = nodeData->getLastBroadcastSequenceNumber(avatarNode->getUUID());
@@ -292,20 +317,21 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
                 ++numAvatarsWithSkippedFrames;
             }
         }
-        return shouldIgnore;
-    });
+        quint64 endIgnoreCalculation = usecTimestampNow();
+        _stats.ignoreCalculationElapsedTime += (endIgnoreCalculation - startIgnoreCalculation);
+
+        if (!shouldIgnore) {
+            // sort this one for later
+            sortedAvatars.push(SortableAvatar(avatar));
+        }
+    }
 
     // loop through our sorted avatars and allocate our bandwidth to them accordingly
-    int avatarRank = 0;
 
-    // this is overly conservative, because it includes some avatars we might not consider
     int remainingAvatars = (int)sortedAvatars.size();
-
     while (!sortedAvatars.empty()) {
-        AvatarPriority sortData = sortedAvatars.top();
+        const auto& avatarData = sortedAvatars.top().getAvatar();
         sortedAvatars.pop();
-        const auto& avatarData = sortData.avatar;
-        avatarRank++;
         remainingAvatars--;
 
         auto otherNode = avatarDataToNodes[avatarData];
@@ -332,10 +358,8 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
             nodeData->setLastBroadcastTime(otherNode->getUUID(), usecTimestampNow());
         }
 
+        // determine if avatar is in view which determines how much data to send
         glm::vec3 otherPosition = otherAvatar->getClientGlobalPosition();
-
-        
-        // determine if avatar is in view, to determine how much data to include...
         glm::vec3 otherNodeBoxScale = (otherPosition - otherNodeData->getGlobalBoundingBoxCorner()) * 2.0f * otherAvatar->getSensorToWorldScale();
         AABox otherNodeBox(otherNodeData->getGlobalBoundingBoxCorner(), otherNodeBoxScale);
         bool isInView = nodeData->otherAvatarInView(otherNodeBox);
@@ -405,14 +429,18 @@ void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node)
                 // set the last sent sequence number for this sender on the receiver
                 nodeData->setLastBroadcastSequenceNumber(otherNode->getUUID(),
                                                          otherNodeData->getLastReceivedSequenceNumber());
+                nodeData->setLastOtherAvatarEncodeTime(otherNode->getUUID(), usecTimestampNow());
             }
+        } else {
+            // TODO? this avatar is not included now, and will probably not be included next frame.
+            // It would be nice if we could tweak its future sort priority to put it at the back of the list.
         }
 
         avatarPacketList->endSegment();
 
         quint64 endAvatarDataPacking = usecTimestampNow();
         _stats.avatarDataPackingElapsedTime += (endAvatarDataPacking - startAvatarDataPacking);
-    };
+    }
 
     quint64 startPacketSending = usecTimestampNow();
 

cmake/macros/GenerateInstallers.cmake

@@ -29,10 +29,6 @@ macro(GENERATE_INSTALLERS)
 
 
   if (WIN32)
-    # Do not install the Visual Studio C runtime libraries.  The installer will do this automatically
-    set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
-    
-    include(InstallRequiredSystemLibraries)
     set(CPACK_NSIS_MUI_ICON "${HF_CMAKE_DIR}/installer/installer.ico")
 
     # install and reference the Add/Remove icon
@@ -49,6 +45,10 @@ macro(GENERATE_INSTALLERS)
     set(_UNINSTALLER_HEADER_BAD_PATH "${HF_CMAKE_DIR}/installer/uninstaller-header.bmp")
     set(UNINSTALLER_HEADER_IMAGE "")
     fix_path_for_nsis(${_UNINSTALLER_HEADER_BAD_PATH} UNINSTALLER_HEADER_IMAGE)
+
+    # grab the latest VC redist (2017) and add it to the installer, our NSIS template
+    # will call it during the install
+    install(CODE "file(DOWNLOAD https://go.microsoft.com/fwlink/?LinkId=746572 \"\${CMAKE_INSTALL_PREFIX}/vcredist_x64.exe\")")
   elseif (APPLE)
     # produce a drag and drop DMG on OS X
     set(CPACK_GENERATOR "DragNDrop")
@@ -84,4 +84,3 @@ macro(GENERATE_INSTALLERS)
 
   include(CPack)
 endmacro()
-

cmake/templates/FixupBundlePostBuild.cmake.in

@@ -45,5 +45,4 @@ else()
 endif()
 
 file(GLOB EXTRA_PLUGINS "${BUNDLE_PLUGIN_DIR}/*.${PLUGIN_EXTENSION}")
-fixup_bundle("${BUNDLE_EXECUTABLE}" "${EXTRA_PLUGINS}" "@FIXUP_LIBS@")
-
+fixup_bundle("${BUNDLE_EXECUTABLE}" "${EXTRA_PLUGINS}" "@FIXUP_LIBS@" IGNORE_ITEM "vcredist_x86.exe;vcredist_x64.exe")

domain-server/resources/describe-settings.json

@@ -1,5 +1,5 @@
 {
-  "version": 2.0,
+  "version": 2.1,
   "settings": [
     {
       "name": "label",
@@ -1015,20 +1015,20 @@
       "assignment-types": [ 1, 2 ],
       "settings": [
         {
-          "name": "min_avatar_scale",
+          "name": "min_avatar_height",
           "type": "double",
-          "label": "Minimum Avatar Scale",
-          "help": "Limits the scale of avatars in your domain. Must be at least 0.005.",
-          "placeholder": 0.25,
-          "default": 0.25
+          "label": "Minimum Avatar Height (meters)",
+          "help": "Limits the height of avatars in your domain. Must be at least 0.009.",
+          "placeholder": 0.4,
+          "default": 0.4
         },
         {
-          "name": "max_avatar_scale",
+          "name": "max_avatar_height",
           "type": "double",
-          "label": "Maximum Avatar Scale",
-          "help": "Limits the scale of avatars in your domain. Cannot be greater than 1000.",
-          "placeholder": 3.0,
-          "default": 3.0
+          "label": "Maximum Avatar Height (meters)",
+          "help": "Limits the scale of avatars in your domain. Cannot be greater than 1755.",
+          "placeholder": 5.2,
+          "default": 5.2
         },
         {
           "name": "avatar_whitelist",

domain-server/src/DomainServerSettingsManager.cpp

@@ -304,6 +304,26 @@ void DomainServerSettingsManager::setupConfigMap(const QStringList& argumentList
 
             *wizardCompletedOnce = QVariant(true);
         }
+        if (oldVersion < 2.1) {
+            // convert old avatar scale settings into avatar height.
+
+            const QString AVATAR_MIN_SCALE_KEYPATH = "avatars.min_avatar_scale";
+            const QString AVATAR_MAX_SCALE_KEYPATH = "avatars.max_avatar_scale";
+            const QString AVATAR_MIN_HEIGHT_KEYPATH = "avatars.min_avatar_height";
+            const QString AVATAR_MAX_HEIGHT_KEYPATH = "avatars.max_avatar_height";
+
+            QVariant* avatarMinScale = _configMap.valueForKeyPath(AVATAR_MIN_SCALE_KEYPATH);
+            if (avatarMinScale) {
+                float scale = avatarMinScale->toFloat();
+                _configMap.valueForKeyPath(AVATAR_MIN_HEIGHT_KEYPATH, scale * DEFAULT_AVATAR_HEIGHT);
+            }
+
+            QVariant* avatarMaxScale = _configMap.valueForKeyPath(AVATAR_MAX_SCALE_KEYPATH);
+            if (avatarMaxScale) {
+                float scale = avatarMaxScale->toFloat();
+                _configMap.valueForKeyPath(AVATAR_MAX_HEIGHT_KEYPATH, scale * DEFAULT_AVATAR_HEIGHT);
+            }
+        }
 
         // write the current description version to our settings
         *versionVariant = _descriptionVersion;

interface/resources/controllers/oculus_touch.json

@@ -13,11 +13,11 @@
 
         { "from": "OculusTouch.LY", "to": "Standard.LY",
             "filters": [
-                { "type": "deadZone", "min": 0.3 },
+                { "type": "deadZone", "min": 0.7 },
                 "invert"
             ]
         },
-        { "from": "OculusTouch.LX", "filters": { "type": "deadZone", "min": 0.3 }, "to": "Standard.LX" },
+        { "from": "OculusTouch.LX", "filters": { "type": "deadZone", "min": 0.7 }, "to": "Standard.LX" },
         { "from": "OculusTouch.LT", "to": "Standard.LTClick",
             "peek": true,
             "filters": [ { "type": "hysteresis", "min": 0.85, "max": 0.9 } ]
@@ -29,11 +29,11 @@
 
         { "from": "OculusTouch.RY", "to": "Standard.RY",
             "filters": [
-                { "type": "deadZone", "min": 0.3 },
+                { "type": "deadZone", "min": 0.7 },
                 "invert"
             ]
         },
-        { "from": "OculusTouch.RX", "filters": { "type": "deadZone", "min": 0.3 }, "to": "Standard.RX" },
+        { "from": "OculusTouch.RX", "filters": { "type": "deadZone", "min": 0.7 }, "to": "Standard.RX" },
         { "from": "OculusTouch.RT", "to": "Standard.RTClick",
             "peek": true,
             "filters": [ { "type": "hysteresis", "min": 0.85, "max": 0.9 } ]

interface/resources/html/createGlobalEventBridge.js

@@ -65,21 +65,23 @@ var EventBridge;
         // we need to listen to events that might precede the addition of this elements.
         // A more robust hack will be to add a setInterval that look for DOM changes every 100-300 ms (low performance?)
         
-        window.onload = function(){
+        window.addEventListener("load",function(event) {
             setTimeout(function() { 
                 EventBridge.forceHtmlAudioOutputDeviceUpdate();
             }, 1200);
-        };
-        document.onclick = function(){
+        }, false);
+        
+        document.addEventListener("click",function(){
             setTimeout(function() { 
                 EventBridge.forceHtmlAudioOutputDeviceUpdate();
             }, 1200);
-        };
-        document.onchange = function(){
+        }, false);
+        
+        document.addEventListener("change",function(){
             setTimeout(function() { 
                 EventBridge.forceHtmlAudioOutputDeviceUpdate();
             }, 1200);
-        };
+        }, false);
         
         tempEventBridge._callbacks.forEach(function (callback) {
             EventBridge.scriptEventReceived.connect(callback);

interface/resources/qml/AudioScope.qml

@@ -0,0 +1,634 @@
+//
+//  AudioScope.qml
+//
+//  Created by Luis Cuenca on 11/22/2017
+//  Copyright 2017 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or https://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import "styles-uit"
+import "controls-uit" as HifiControlsUit
+
+Item {
+    id: root
+    width: parent.width
+    height: parent.height   
+    
+    property var _scopeInputData 
+    property var _scopeOutputLeftData
+    property var _scopeOutputRightData
+    
+    property var _triggerInputData 
+    property var _triggerOutputLeftData
+    property var _triggerOutputRightData
+    
+    property var _triggerValues: QtObject{ 
+        property int x: parent.width/2 
+        property int y: parent.height/3
+    }
+    
+    property var _triggered: false
+    property var _steps
+    property var _refreshMs: 32
+    property var _framesPerSecond: AudioScope.getFramesPerSecond()
+    property var _isFrameUnits: true
+    
+    property var _holdStart: QtObject{ 
+        property int x: 0
+        property int y: 0
+    }
+    
+    property var _holdEnd: QtObject{ 
+        property int x: 0 
+        property int y: 0
+    }
+    
+    property var _timeBeforeHold: 300
+    property var _pressedTime: 0
+    property var _isPressed: false
+
+    property var _recOpacity : 0.0
+    property var _recSign : 0.05
+
+    property var _outputLeftState: false
+    property var _outputRightState: false
+    
+    property var _wavFilePath: ""
+    
+    function isHolding() {
+        return (_pressedTime > _timeBeforeHold); 
+    }
+    
+    function updateMeasureUnits() {
+        timeButton.text = _isFrameUnits ? "Display Frames" : "Milliseconds";
+        fiveLabel.text = _isFrameUnits ? "5" : "" + (Math.round(1000 * 5.0/_framesPerSecond));
+        twentyLabel.text = _isFrameUnits ? "20" : "" + (Math.round(1000 * 20.0/_framesPerSecond));
+        fiftyLabel.text = _isFrameUnits ? "50" : "" + (Math.round(1000 * 50.0/_framesPerSecond));
+    }
+    
+    function collectScopeData() {
+        if (inputCh.checked) { 
+            _scopeInputData  = AudioScope.scopeInput;
+        }
+        if (outputLeftCh.checked) {
+            _scopeOutputLeftData  = AudioScope.scopeOutputLeft;
+        }
+        if (outputRightCh.checked) {
+            _scopeOutputRightData  = AudioScope.scopeOutputRight;
+        }
+    }
+    
+    function collectTriggerData() {
+        if (inputCh.checked) { 
+            _triggerInputData  = AudioScope.triggerInput;
+        }
+        if (outputLeftCh.checked) {
+            _triggerOutputLeftData  = AudioScope.triggerOutputLeft;
+        }
+        if (outputRightCh.checked) {
+            _triggerOutputRightData  = AudioScope.triggerOutputRight;
+        }
+    }
+
+    function setRecordingLabelOpacity(opacity) {
+        _recOpacity = opacity;
+        recCircle.opacity = _recOpacity;
+        recText.opacity = _recOpacity;
+    }
+
+    function updateRecordingLabel() {
+        _recOpacity += _recSign;
+        if (_recOpacity > 1.0 || _recOpacity < 0.0) {
+            _recOpacity = _recOpacity > 1.0 ? 1.0 : 0.0;
+            _recSign *= -1;
+        }
+        setRecordingLabelOpacity(_recOpacity);
+    }
+        
+    function pullFreshValues() {
+        if (Audio.getRecording()) {
+            updateRecordingLabel();
+        }
+
+        if (!AudioScope.getPause()) {        
+            if (!_triggered) {
+                collectScopeData();
+            }               
+        } 
+        if (inputCh.checked || outputLeftCh.checked || outputRightCh.checked) {
+            mycanvas.requestPaint();
+        }
+    }
+    
+    function startRecording() {
+        _wavFilePath = (new Date()).toISOString();  // yyyy-mm-ddThh:mm:ss.sssZ
+        _wavFilePath = _wavFilePath.replace(/[\-:]|\.\d*Z$/g, "").replace("T", "-") + ".wav";
+        // Using controller recording default directory
+        _wavFilePath = Recording.getDefaultRecordingSaveDirectory() + _wavFilePath;
+        if (!Audio.startRecording(_wavFilePath)) {
+            Messages.sendMessage("Hifi-Notifications", JSON.stringify({message:"Error creating: "+_wavFilePath}));
+            updateRecordingUI(false);
+        }
+    }
+
+    function stopRecording() {
+        Audio.stopRecording();
+        setRecordingLabelOpacity(0.0);
+        Messages.sendMessage("Hifi-Notifications", JSON.stringify({message:"Saved: "+_wavFilePath}));
+    }
+
+    function updateRecordingUI(isRecording) {
+        if (!isRecording) {
+            recordButton.text = "Record";
+            recordButton.color = hifi.buttons.black;
+            outputLeftCh.checked = _outputLeftState;
+            outputRightCh.checked = _outputRightState;
+        } else {
+            recordButton.text = "Stop";
+            recordButton.color = hifi.buttons.red;
+            _outputLeftState = outputLeftCh.checked;
+            _outputRightState = outputRightCh.checked;
+            outputLeftCh.checked = true;
+            outputRightCh.checked = true;
+        }
+    }
+    
+    function toggleRecording() {
+        if (Audio.getRecording()) {
+            updateRecordingUI(false);
+            stopRecording();
+        } else {
+            updateRecordingUI(true);
+            startRecording();
+        }
+    }
+    
+    Timer {
+        interval: _refreshMs; running: true; repeat: true
+        onTriggered: pullFreshValues()
+    }
+
+    Canvas {
+        id: mycanvas
+        anchors.fill:parent
+        
+        onPaint: {
+        
+            function displayMeasureArea(ctx) {
+                
+                ctx.fillStyle = Qt.rgba(0.1, 0.1, 0.1, 1);
+                ctx.fillRect(_holdStart.x, 0, _holdEnd.x - _holdStart.x, height);
+                
+                ctx.lineWidth = "2";
+                ctx.strokeStyle = "#555555";
+                
+                ctx.beginPath();
+                ctx.moveTo(_holdStart.x, 0); 
+                ctx.lineTo(_holdStart.x, height);
+                ctx.moveTo(_holdEnd.x, 0); 
+                ctx.lineTo(_holdEnd.x, height); 
+                                
+                ctx.moveTo(_holdStart.x, _holdStart.y); 
+                ctx.lineTo(_holdEnd.x, _holdStart.y); 
+                ctx.moveTo(_holdEnd.x, _holdEnd.y); 
+                ctx.lineTo(_holdStart.x, _holdEnd.y);
+                
+                ctx.stroke();
+            }
+            
+            function displayTrigger(ctx, lineWidth, color) {
+                var crossSize = 3;
+                var holeSize = 2;
+                
+                ctx.lineWidth = lineWidth;
+                ctx.strokeStyle = color;
+                
+                ctx.beginPath();
+                ctx.moveTo(_triggerValues.x - (crossSize + holeSize), _triggerValues.y); 
+                ctx.lineTo(_triggerValues.x - holeSize, _triggerValues.y); 
+                ctx.moveTo(_triggerValues.x + holeSize, _triggerValues.y); 
+                ctx.lineTo(_triggerValues.x + (crossSize + holeSize), _triggerValues.y); 
+                
+                ctx.moveTo(_triggerValues.x, _triggerValues.y - (crossSize + holeSize)); 
+                ctx.lineTo(_triggerValues.x, _triggerValues.y - holeSize); 
+                ctx.moveTo(_triggerValues.x, _triggerValues.y + holeSize); 
+                ctx.lineTo(_triggerValues.x, _triggerValues.y + (crossSize + holeSize));
+
+                ctx.stroke();
+            }
+            
+            function displayBackground(ctx, datawidth, steps, lineWidth, color) {
+                var verticalPadding = 100;
+                
+                ctx.strokeStyle = color;
+                ctx.lineWidth = lineWidth;
+ 
+                ctx.moveTo(0, height/2); 
+                ctx.lineTo(datawidth, height/2);
+                
+                var gap = datawidth/steps;
+                for (var i = 0; i < steps; i++) {
+                    ctx.moveTo(i*gap + 1, verticalPadding); 
+                    ctx.lineTo(i*gap + 1, height-verticalPadding); 
+                }
+                ctx.moveTo(datawidth-1, verticalPadding); 
+                ctx.lineTo(datawidth-1, height-verticalPadding); 
+                
+                ctx.stroke();
+            }
+            
+            function drawScope(ctx, data, width, color) {
+                ctx.beginPath();
+                ctx.strokeStyle = color;
+                ctx.lineWidth = width;
+                var x = 0;
+                for (var i = 0; i < data.length-1; i++) {
+                    ctx.moveTo(x, data[i] + height/2); 
+                    ctx.lineTo(++x, data[i+1] + height/2);              
+                }
+                ctx.stroke();
+            }
+            
+            function getMeasurementText(dist) {
+                var datasize = _scopeInputData.length;
+                var value = 0;
+                if (fiveFrames.checked) {
+                    value = (_isFrameUnits) ? 5.0*dist/datasize : (Math.round(1000 * 5.0/_framesPerSecond))*dist/datasize;
+                } else if (twentyFrames.checked) {
+                    value = (_isFrameUnits) ? 20.0*dist/datasize : (Math.round(1000 * 20.0/_framesPerSecond))*dist/datasize;
+                } else if (fiftyFrames.checked) {
+                    value = (_isFrameUnits) ? 50.0*dist/datasize : (Math.round(1000 * 50.0/_framesPerSecond))*dist/datasize;
+                }
+                value = Math.abs(Math.round(value*100)/100);
+                var measureText = "" + value + (_isFrameUnits ? " frames" : " milliseconds");
+                return measureText;
+            }
+            
+            function drawMeasurements(ctx, color) {
+                ctx.fillStyle = color;
+                ctx.font = "normal 16px sans-serif";
+                var fontwidth = 8;
+                var measureText = getMeasurementText(_holdEnd.x - _holdStart.x);
+                if (_holdStart.x < _holdEnd.x) {
+                    ctx.fillText("" + height/2 - _holdStart.y, _holdStart.x-40, _holdStart.y);
+                    ctx.fillText("" + height/2 - _holdEnd.y, _holdStart.x-40, _holdEnd.y);  
+                    ctx.fillText(measureText, _holdEnd.x+10, _holdEnd.y);                   
+                } else {
+                    ctx.fillText("" + height/2 - _holdStart.y, _holdStart.x+10, _holdStart.y);
+                    ctx.fillText("" + height/2 - _holdEnd.y, _holdStart.x+10, _holdEnd.y); 
+                    ctx.fillText(measureText, _holdEnd.x-fontwidth*measureText.length, _holdEnd.y);  
+                }                               
+            }
+            
+            var ctx = getContext("2d");
+            
+            ctx.fillStyle = Qt.rgba(0, 0, 0, 1);
+            ctx.fillRect(0, 0, width, height);
+                
+            if (isHolding()) {
+                displayMeasureArea(ctx);
+            }
+
+            var guideLinesColor = "#555555"
+            var guideLinesWidth = "1"
+            
+            displayBackground(ctx, _scopeInputData.length, _steps, guideLinesWidth, guideLinesColor);
+                
+            var triggerWidth = "3"
+            var triggerColor = "#EFB400"
+            
+            if (AudioScope.getAutoTrigger()) {
+                displayTrigger(ctx, triggerWidth, triggerColor);
+            }
+            
+            var scopeWidth = "2"
+            var scopeInputColor = "#00B4EF"
+            var scopeOutputLeftColor = "#BB0000"
+            var scopeOutputRightColor = "#00BB00"
+            
+            if (!_triggered) {
+                if (inputCh.checked) {
+                    drawScope(ctx, _scopeInputData, scopeWidth, scopeInputColor);
+                }
+                if (outputLeftCh.checked) {
+                    drawScope(ctx, _scopeOutputLeftData, scopeWidth, scopeOutputLeftColor);
+                }
+                if (outputRightCh.checked) {
+                    drawScope(ctx, _scopeOutputRightData, scopeWidth, scopeOutputRightColor);
+                }   
+            } else {
+                if (inputCh.checked) {
+                    drawScope(ctx, _triggerInputData, scopeWidth, scopeInputColor);
+                }
+                if (outputLeftCh.checked) {
+                    drawScope(ctx, _triggerOutputLeftData, scopeWidth, scopeOutputLeftColor);
+                }
+                if (outputRightCh.checked) {
+                    drawScope(ctx, _triggerOutputRightData, scopeWidth, scopeOutputRightColor);
+                }
+            }
+            
+            if (isHolding()) {
+                drawMeasurements(ctx, "#eeeeee");
+            }
+            
+            if (_isPressed) {
+                _pressedTime += _refreshMs;
+            }
+        }
+    }
+    
+    MouseArea {
+        id: hitbox
+        anchors.fill: mycanvas
+        hoverEnabled: true
+        onPressed: {
+            _isPressed = true;
+            _pressedTime = 0;
+            _holdStart.x = mouseX;
+            _holdStart.y = mouseY;
+        }
+        onPositionChanged: {
+            _holdEnd.x = mouseX;
+            _holdEnd.y = mouseY;
+        }
+        onReleased: {
+            if (!isHolding() && AudioScope.getAutoTrigger()) {
+                _triggerValues.x = mouseX
+                _triggerValues.y = mouseY
+                AudioScope.setTriggerValues(mouseX, mouseY-height/2);
+            }
+            _isPressed = false;
+            _pressedTime = 0;
+        }
+    }
+    
+    HifiControlsUit.CheckBox {
+        id: activated
+        boxSize: 20
+        anchors.top: parent.top;
+        anchors.left: parent.left;
+        anchors.topMargin: 8;
+        anchors.leftMargin: 20;
+        checked: AudioScope.getVisible();
+        onCheckedChanged: {     
+            AudioScope.setVisible(checked);
+            activelabel.text = AudioScope.getVisible() ? "On" : "Off"
+        }
+    }
+          
+    HifiControlsUit.Label {
+        id: activelabel
+        text: AudioScope.getVisible() ? "On" : "Off"
+        anchors.top: activated.top;
+        anchors.left: activated.right;
+    }
+    
+    HifiControlsUit.CheckBox {
+        id: outputLeftCh
+        boxSize: 20
+        text: "Output L"
+        anchors.horizontalCenter: parent.horizontalCenter;
+        anchors.top: parent.top;
+        anchors.topMargin: 8;
+        onCheckedChanged: {
+            AudioScope.setServerEcho(outputLeftCh.checked || outputRightCh.checked);
+        }
+    }
+	
+    HifiControlsUit.Label {
+        text: "Channels";
+        anchors.horizontalCenter: outputLeftCh.horizontalCenter;
+        anchors.bottom: outputLeftCh.top;
+        anchors.bottomMargin: 8;
+    }
+    
+    HifiControlsUit.CheckBox {
+        id: inputCh
+        boxSize: 20
+        text: "Input Mono"
+        anchors.bottom: outputLeftCh.bottom;
+        anchors.right: outputLeftCh.left;
+        anchors.rightMargin: 40;
+        onCheckedChanged: {
+			AudioScope.setLocalEcho(checked);
+        }
+    }
+    
+    HifiControlsUit.CheckBox {
+        id: outputRightCh
+        boxSize: 20
+        text: "Output R"
+        anchors.bottom: outputLeftCh.bottom;
+        anchors.left: outputLeftCh.right;
+        anchors.leftMargin: 40;
+        onCheckedChanged: {
+            AudioScope.setServerEcho(outputLeftCh.checked || outputRightCh.checked);
+        }
+    }
+    
+    HifiControlsUit.Button {
+        id: recordButton;
+        text: "Record";
+        color: hifi.buttons.black;
+        colorScheme: hifi.colorSchemes.dark;
+        anchors.right: parent.right;
+        anchors.bottom: parent.bottom;
+        anchors.rightMargin: 30;
+        anchors.bottomMargin: 8;
+        width: 95;
+        height: 55;
+        onClicked: {
+            toggleRecording();
+        }
+    }
+    
+    HifiControlsUit.Button {
+        id: pauseButton;
+        color: hifi.buttons.black;
+        colorScheme: hifi.colorSchemes.dark;
+        anchors.right: recordButton.left;
+        anchors.bottom: parent.bottom;
+        anchors.rightMargin: 30;
+        anchors.bottomMargin: 8;
+        height: 55;
+        width: 95;
+        text: " Pause ";
+        onClicked: {
+            AudioScope.togglePause();
+        }
+    }
+    
+    HifiControlsUit.CheckBox {
+        id: twentyFrames
+        boxSize: 20
+        anchors.left: parent.horizontalCenter;
+        anchors.bottom: parent.bottom;
+        anchors.bottomMargin: 8;
+        onCheckedChanged: {
+            if (checked){
+                fiftyFrames.checked = false;
+                fiveFrames.checked = false;
+                AudioScope.selectAudioScopeTwentyFrames();
+                _steps = 20;
+                AudioScope.setPause(false);
+            }
+        }
+    }
+    
+    HifiControlsUit.Label {
+        id:twentyLabel
+        anchors.left: twentyFrames.right;
+        anchors.verticalCenter: twentyFrames.verticalCenter;
+    }
+    
+    HifiControlsUit.Button {
+        id: timeButton;
+        color: hifi.buttons.black;
+        colorScheme: hifi.colorSchemes.dark;
+        text: "Display Frames";
+        anchors.horizontalCenter: twentyFrames.horizontalCenter;
+        anchors.bottom: twentyFrames.top;
+        anchors.bottomMargin: 8;
+        height: 26;
+        onClicked: {
+            _isFrameUnits = !_isFrameUnits;
+            updateMeasureUnits();
+        }
+    }
+    
+    HifiControlsUit.CheckBox {
+        id: fiveFrames
+        boxSize: 20
+        anchors.horizontalCenter: parent.horizontalCenter;
+        anchors.bottom: parent.bottom;
+        anchors.bottomMargin: 8;
+        anchors.horizontalCenterOffset: -50;
+        checked: true;
+        onCheckedChanged: {
+            if (checked) {
+                fiftyFrames.checked = false;
+                twentyFrames.checked = false;
+                AudioScope.selectAudioScopeFiveFrames();
+                _steps = 5;
+                AudioScope.setPause(false);
+            }
+        }
+    }
+    
+    HifiControlsUit.Label {
+        id:fiveLabel
+        anchors.left: fiveFrames.right;
+        anchors.verticalCenter: fiveFrames.verticalCenter;
+    }
+    
+    HifiControlsUit.CheckBox {
+        id: fiftyFrames
+        boxSize: 20
+        anchors.horizontalCenter: parent.horizontalCenter;
+        anchors.bottom: parent.bottom;
+        anchors.bottomMargin: 8;
+        anchors.horizontalCenterOffset: 70;
+        onCheckedChanged: {
+            if (checked) {
+                twentyFrames.checked = false;
+                fiveFrames.checked = false;
+                AudioScope.selectAudioScopeFiftyFrames();
+                _steps = 50;
+                AudioScope.setPause(false);            
+            }
+        }
+    }
+    
+    HifiControlsUit.Label {
+        id:fiftyLabel
+        anchors.left: fiftyFrames.right;
+        anchors.verticalCenter: fiftyFrames.verticalCenter;
+    }
+    
+    HifiControlsUit.Switch {
+        id: triggerSwitch;
+        height: 26;
+        anchors.left: parent.left;
+        anchors.bottom: parent.bottom;
+        anchors.leftMargin: 75;
+        anchors.bottomMargin: 8;
+        labelTextOff: "Off";
+        labelTextOn: "On";
+        onCheckedChanged: {
+            if (!checked) AudioScope.setPause(false);
+            AudioScope.setPause(false);
+            AudioScope.setAutoTrigger(checked);
+            AudioScope.setTriggerValues(_triggerValues.x, _triggerValues.y-root.height/2);
+        }
+    }
+    
+    HifiControlsUit.Label {
+        text: "Trigger";
+        anchors.left: triggerSwitch.left;
+        anchors.leftMargin: -15;
+        anchors.bottom: triggerSwitch.top;
+    }
+    
+    Rectangle {
+        id: recordIcon;
+        width:110;
+        height:40;
+        anchors.right: parent.right;
+        anchors.top: parent.top;
+        anchors.topMargin: 8;
+        color: "transparent"
+        
+        Text {
+            id: recText
+            text: "REC"
+            color: "red"
+            font.pixelSize: 30;
+            anchors.left: recCircle.right;
+            anchors.leftMargin: 10;
+            opacity: _recOpacity;
+            y: -8;
+        }       
+        
+        Rectangle {
+            id: recCircle;
+            width: 25;
+            height: 25;
+            radius: width*0.5
+            opacity: _recOpacity;
+            color: "red";
+        }
+    }
+    
+    Component.onCompleted: {  
+        _steps = AudioScope.getFramesPerScope();
+        AudioScope.setTriggerValues(_triggerValues.x, _triggerValues.y-root.height/2);
+        activated.checked = true;
+		inputCh.checked = true;
+        updateMeasureUnits();
+    }
+    
+    Connections {
+        target: AudioScope
+        onPauseChanged: {
+            if (!AudioScope.getPause()) {
+                pauseButton.text = "Pause";
+                pauseButton.color = hifi.buttons.black;
+                AudioScope.setTriggered(false);
+                _triggered = false;
+            } else {
+                pauseButton.text = "Continue";
+                pauseButton.color = hifi.buttons.blue;
+            }           
+        }
+        onTriggered: {
+            _triggered = true;
+            collectTriggerData();
+            AudioScope.setPause(true);
+        }
+    }
+}

interface/resources/qml/controls/FlickableWebViewCore.qml

@@ -21,6 +21,8 @@ Item {
     signal newViewRequestedCallback(var request)
     signal loadingChangedCallback(var loadRequest)
 
+    width: parent.width
+
     property bool interactive: false
 
     StylesUIt.HifiConstants {
@@ -58,7 +60,8 @@ Item {
     WebEngineView {
         id: webViewCore
 
-        anchors.fill: parent
+        width: parent.width
+        height: parent.height
 
         profile: HFWebEngineProfile;
         settings.pluginsEnabled: true
@@ -91,20 +94,19 @@ Item {
 
         userScripts: [ createGlobalEventBridge, raiseAndLowerKeyboard, userScript ]
 
-        property string newUrl: ""
-
         Component.onCompleted: {
             webChannel.registerObject("eventBridge", eventBridge);
             webChannel.registerObject("eventBridgeWrapper", eventBridgeWrapper);
-            // Ensure the JS from the web-engine makes it to our logging
-            webViewCore.javaScriptConsoleMessage.connect(function(level, message, lineNumber, sourceID) {
-                console.log("Web Entity JS message: " + sourceID + " " + lineNumber + " " +  message);
-            });
+
             if (webViewCoreUserAgent !== undefined) {
                 webViewCore.profile.httpUserAgent = webViewCoreUserAgent
             } else {
                 webViewCore.profile.httpUserAgent += " (HighFidelityInterface)";
             }
+            // Ensure the JS from the web-engine makes it to our logging
+            webViewCore.javaScriptConsoleMessage.connect(function(level, message, lineNumber, sourceID) {
+                console.log("Web Entity JS message: " + sourceID + " " + lineNumber + " " +  message);
+            });
         }
 
         onFeaturePermissionRequested: {

interface/resources/qml/hifi/Pal.qml

@@ -26,6 +26,7 @@ Rectangle {
     // Style
     color: "#E3E3E3";
     // Properties
+    property bool debug: false;
     property int myCardWidth: width - upperRightInfoContainer.width;
     property int myCardHeight: 80;
     property int rowHeight: 60;
@@ -1120,7 +1121,9 @@ Rectangle {
             break;
         case 'connections':
             var data = message.params;
-            console.log('Got connection data: ', JSON.stringify(data));
+            if (pal.debug) {
+                console.log('Got connection data: ', JSON.stringify(data));
+            }
             connectionsUserModelData = data;
             sortConnectionsModel();
             connectionsLoading.visible = false;

interface/resources/qml/hifi/commerce/checkout/Checkout.qml

@@ -79,10 +79,12 @@ Rectangle {
             if (result.status !== 'success') {
                 failureErrorText.text = result.message;
                 root.activeView = "checkoutFailure";
+                UserActivityLogger.commercePurchaseFailure(root.itemId, root.itemPrice, !root.alreadyOwned, result.message);
             } else {
                 root.itemHref = result.data.download_url;
                 root.isWearable = result.data.categories.indexOf("Wearables") > -1;
                 root.activeView = "checkoutSuccess";
+                UserActivityLogger.commercePurchaseSuccess(root.itemId, root.itemPrice, !root.alreadyOwned);
             }
         }
 
@@ -599,6 +601,7 @@ Rectangle {
                 sendToScript({method: 'checkout_rezClicked', itemHref: root.itemHref, isWearable: root.isWearable});
                 rezzedNotifContainer.visible = true;
                 rezzedNotifContainerTimer.start();
+                UserActivityLogger.commerceEntityRezzed(root.itemId, "checkout", root.isWearable ? "rez" : "wear");
             }
         }
         RalewaySemiBold {

interface/resources/qml/hifi/commerce/purchases/PurchasedItem.qml

@@ -349,6 +349,7 @@ Item {
                 sendToPurchases({method: 'purchases_rezClicked', itemHref: root.itemHref, isWearable: root.isWearable});
                 rezzedNotifContainer.visible = true;
                 rezzedNotifContainerTimer.start();
+                UserActivityLogger.commerceEntityRezzed(root.itemId, "purchases", root.isWearable ? "rez" : "wear");
             }
 
             style: ButtonStyle {

interface/resources/qml/hifi/commerce/wallet/PassphraseModal.qml

@@ -206,16 +206,6 @@ Item {
                 root.isPasswordField = (focus && passphraseField.echoMode === TextInput.Password);
             }
 
-            MouseArea {
-                anchors.fill: parent;
-
-                onClicked: {
-                    root.keyboardRaised = true;
-                    root.isPasswordField = (passphraseField.echoMode === TextInput.Password);
-                    mouse.accepted = false;
-                }
-            }
-
             onAccepted: {
                 submitPassphraseInputButton.enabled = false;
                 commerce.setPassphrase(passphraseField.text);
@@ -362,25 +352,6 @@ Item {
             right: parent.right;
         }
 
-        Image {
-            id: lowerKeyboardButton;
-            z: 999;
-            source: "images/lowerKeyboard.png";
-            anchors.right: keyboard.right;
-            anchors.top: keyboard.showMirrorText ? keyboard.top : undefined;
-            anchors.bottom: keyboard.showMirrorText ? undefined : keyboard.bottom;
-            height: 50;
-            width: 60;
-
-            MouseArea {
-                anchors.fill: parent;
-
-                onClicked: {
-                    root.keyboardRaised = false;
-                }
-            }
-        }
-
         HifiControlsUit.Keyboard {
             id: keyboard;
             raised: HMD.mounted && root.keyboardRaised;

interface/resources/qml/hifi/commerce/wallet/PassphraseSelection.qml

@@ -82,17 +82,6 @@ Item {
             if (focus) {
                 var hidePassword = (currentPassphraseField.echoMode === TextInput.Password);
                 sendSignalToWallet({method: 'walletSetup_raiseKeyboard', isPasswordField: hidePassword});
-            } else if (!passphraseFieldAgain.focus) {
-                sendSignalToWallet({method: 'walletSetup_lowerKeyboard', isPasswordField: false});
-            }
-        }
-
-        MouseArea {
-            anchors.fill: parent;
-            onPressed: {
-                var hidePassword = (currentPassphraseField.echoMode === TextInput.Password);
-                sendSignalToWallet({method: 'walletSetup_raiseKeyboard', isPasswordField: hidePassword});
-                mouse.accepted = false;
             }
         }
 
@@ -115,21 +104,10 @@ Item {
         activeFocusOnPress: true;
         activeFocusOnTab: true;
 
-        MouseArea {
-            anchors.fill: parent;
-            onPressed: {
-                var hidePassword = (passphraseField.echoMode === TextInput.Password);
-                sendSignalToWallet({method: 'walletSetup_raiseKeyboard', isPasswordField: hidePassword});
-                mouse.accepted = false;
-            }
-        }
-
         onFocusChanged: {
             if (focus) {
                 var hidePassword = (passphraseField.echoMode === TextInput.Password);
                 sendMessageToLightbox({method: 'walletSetup_raiseKeyboard', isPasswordField: hidePassword});
-            } else if (!passphraseFieldAgain.focus) {
-                sendMessageToLightbox({method: 'walletSetup_lowerKeyboard', isPasswordField: false});
             }
         }
 
@@ -151,21 +129,10 @@ Item {
         activeFocusOnPress: true;
         activeFocusOnTab: true;
 
-        MouseArea {
-            anchors.fill: parent;
-            onPressed: {
-                var hidePassword = (passphraseFieldAgain.echoMode === TextInput.Password);
-                sendSignalToWallet({method: 'walletSetup_raiseKeyboard', isPasswordField: hidePassword});
-                mouse.accepted = false;
-            }
-        }
-
         onFocusChanged: {
             if (focus) {
                 var hidePassword = (passphraseFieldAgain.echoMode === TextInput.Password);
                 sendMessageToLightbox({method: 'walletSetup_raiseKeyboard', isPasswordField: hidePassword});
-            } else if (!passphraseField.focus) {
-                sendMessageToLightbox({method: 'walletSetup_lowerKeyboard', isPasswordField: false});
             }
         }
 

interface/resources/qml/hifi/commerce/wallet/Wallet.qml

@@ -48,6 +48,11 @@ Rectangle {
                 if (root.activeView !== "walletSetup") {
                     root.activeView = "walletSetup";
                     commerce.resetLocalWalletOnly();
+                    var timestamp = new Date();
+                    walletSetup.startingTimestamp = timestamp;
+                    walletSetup.setupAttemptID = generateUUID();
+                    UserActivityLogger.commerceWalletSetupStarted(timestamp, setupAttemptID, walletSetup.setupFlowVersion, walletSetup.referrer ? walletSetup.referrer : "wallet app",
+                        (AddressManager.placename || AddressManager.hostname || '') + (AddressManager.pathname ? AddressManager.pathname.match(/\/[^\/]+/)[0] : ''));
                 }
             } else if (walletStatus === 2) {
                 if (root.activeView !== "passphraseModal") {
@@ -173,7 +178,7 @@ Rectangle {
         Connections {
             onSendSignalToWallet: {
                 if (msg.method === 'walletSetup_finished') {
-                    if (msg.referrer === '') {
+                    if (msg.referrer === '' || msg.referrer === 'marketplace cta') {
                         root.activeView = "initialize";
                         commerce.getWalletStatus();
                     } else if (msg.referrer === 'purchases') {
@@ -667,25 +672,6 @@ Rectangle {
             right: parent.right;
         }
 
-        Image {
-            id: lowerKeyboardButton;
-            z: 999;
-            source: "images/lowerKeyboard.png";
-            anchors.right: keyboard.right;
-            anchors.top: keyboard.showMirrorText ? keyboard.top : undefined;
-            anchors.bottom: keyboard.showMirrorText ? undefined : keyboard.bottom;
-            height: 50;
-            width: 60;
-
-            MouseArea {
-                anchors.fill: parent;
-
-                onClicked: {
-                    root.keyboardRaised = false;
-                }
-            }
-        }
-
         HifiControlsUit.Keyboard {
             id: keyboard;
             raised: HMD.mounted && root.keyboardRaised;
@@ -720,12 +706,28 @@ Rectangle {
             case 'updateWalletReferrer':
                 walletSetup.referrer = message.referrer;
             break;
+            case 'inspectionCertificate_resetCert':
+                // NOP
+            break;
             default:
                 console.log('Unrecognized message from wallet.js:', JSON.stringify(message));
         }
     }
     signal sendToScript(var message);
 
+    // generateUUID() taken from:
+    // https://stackoverflow.com/a/8809472
+    function generateUUID() { // Public Domain/MIT
+        var d = new Date().getTime();
+        if (typeof performance !== 'undefined' && typeof performance.now === 'function'){
+            d += performance.now(); //use high-precision timer if available
+        }
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+            var r = (d + Math.random() * 16) % 16 | 0;
+            d = Math.floor(d / 16);
+            return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
+        });
+    }
     //
     // FUNCTION DEFINITIONS END
     //

interface/resources/qml/hifi/commerce/wallet/WalletHome.qml

@@ -68,6 +68,7 @@ Item {
     Connections {
         target: GlobalServices
         onMyUsernameChanged: {
+            transactionHistoryModel.clear();
             usernameText.text = Account.username;
         }
     }

interface/resources/qml/hifi/commerce/wallet/WalletSetup.qml

@@ -31,6 +31,10 @@ Item {
     property bool hasShownSecurityImageTip: false;
     property string referrer;
     property string keyFilePath;
+    property date startingTimestamp;
+    property string setupAttemptID;
+    readonly property int setupFlowVersion: 1;
+    readonly property var setupStepNames: [ "Setup Prompt", "Security Image Selection", "Passphrase Selection", "Private Keys Ready" ];
 
     Image {
         anchors.fill: parent;
@@ -67,6 +71,13 @@ Item {
         anchors.fill: parent;
     }
 
+    onActiveViewChanged: {
+        var timestamp = new Date();
+        var currentStepNumber = root.activeView.substring(5);
+        UserActivityLogger.commerceWalletSetupProgress(timestamp, root.setupAttemptID,
+            Math.round((timestamp - root.startingTimestamp)/1000), currentStepNumber, root.setupStepNames[currentStepNumber - 1]);
+    }
+
     //
     // TITLE BAR START
     //
@@ -730,6 +741,9 @@ Item {
                     root.visible = false;
                     root.hasShownSecurityImageTip = false;
                     sendSignalToWallet({method: 'walletSetup_finished', referrer: root.referrer ? root.referrer : ""});
+                    
+                    var timestamp = new Date();
+                    UserActivityLogger.commerceWalletSetupFinished(timestamp, setupAttemptID, Math.round((timestamp - root.startingTimestamp)/1000));
                 }
             }
         }

interface/resources/qml/hifi/dialogs/content/AttachmentsContent.qml

@@ -26,6 +26,7 @@ Item {
     }
     
     Connections {
+        id: onAttachmentsChangedConnection
         target: MyAvatar
         onAttachmentsChanged: reload()
     }
@@ -34,6 +35,12 @@ Item {
         reload()
     }
 
+    function setAttachmentsVariant(attachments) {
+        onAttachmentsChangedConnection.enabled = false;
+        MyAvatar.setAttachmentsVariant(attachments);
+        onAttachmentsChangedConnection.enabled = true;
+    }
+
     Column {
         width: pane.width
 
@@ -92,11 +99,15 @@ Item {
                                 attachments.splice(index, 1);
                                 listView.model.remove(index, 1);
                             }
-                            onUpdateAttachment: MyAvatar.setAttachmentsVariant(attachments);
+                            onUpdateAttachment: {
+                                setAttachmentsVariant(attachments);
+                            }
                         }
                     }
 
-                    onCountChanged: MyAvatar.setAttachmentsVariant(attachments);
+                    onCountChanged: {
+                        setAttachmentsVariant(attachments);
+                    }
 
                     /*
                     // DEBUG
@@ -220,7 +231,7 @@ Item {
                     };
                     attachments.push(template);
                     listView.model.append({});
-                    MyAvatar.setAttachmentsVariant(attachments);
+                    setAttachmentsVariant(attachments);
                 }
             }
 
@@ -250,7 +261,7 @@ Item {
                 id: cancelAction
                 text: "Cancel"
                 onTriggered: {
-                    MyAvatar.setAttachmentsVariant(originalAttachments);
+                    setAttachmentsVariant(originalAttachments);
                     closeDialog();
                 }
             }
@@ -263,7 +274,7 @@ Item {
                         console.log("Attachment " + i + ": " + attachments[i]);
                     }
 
-                    MyAvatar.setAttachmentsVariant(attachments);
+                    setAttachmentsVariant(attachments);
                     closeDialog();
                 }
             }

interface/resources/qml/hifi/overlays/ImageOverlay.qml

@@ -9,33 +9,30 @@ Overlay {
 
     Image {
         id: image
-        property bool scaleFix: true;
-        property real xOffset: 0
-        property real yOffset: 0
+        property bool scaleFix: true
+        property real xStart: 0
+        property real yStart: 0
+        property real xSize: 0
+        property real ySize: 0
         property real imageScale: 1.0
         property var resizer: Timer {
             interval: 50
             repeat: false
             running: false
             onTriggered: {
-                var targetAspect = root.width / root.height;
-                var sourceAspect = image.sourceSize.width / image.sourceSize.height;
-                if (sourceAspect <= targetAspect) {
-                    if (root.width === image.sourceSize.width) {
-                        return;
-                    }
-                    image.imageScale = root.width / image.sourceSize.width;
-                } else if (sourceAspect > targetAspect){
-                    if (root.height === image.sourceSize.height) {
-                        return;
-                    }
-                    image.imageScale = root.height / image.sourceSize.height;
+                if (image.xSize === 0) {
+                    image.xSize = image.sourceSize.width - image.xStart;
                 }
-                image.sourceSize = Qt.size(image.sourceSize.width * image.imageScale, image.sourceSize.height * image.imageScale);
+                if (image.ySize === 0) {
+                    image.ySize = image.sourceSize.height - image.yStart;
+                }
+
+                image.anchors.leftMargin = -image.xStart * root.width / image.xSize;
+                image.anchors.topMargin = -image.yStart * root.height / image.ySize;
+                image.anchors.rightMargin = (image.xStart + image.xSize - image.sourceSize.width) * root.width / image.xSize;
+                image.anchors.bottomMargin = (image.yStart + image.ySize - image.sourceSize.height) * root.height / image.ySize;
             }
         }
-        x: -1 * xOffset * imageScale
-        y: -1 * yOffset * imageScale
 
         onSourceSizeChanged: {
             if (sourceSize.width !== 0 && sourceSize.height !== 0 && progress === 1.0 && scaleFix) {
@@ -43,6 +40,8 @@ Overlay {
                 resizer.start();
             }
         }
+
+        anchors.fill: parent
     }
 
     ColorOverlay {
@@ -57,8 +56,10 @@ Overlay {
             var key = keys[i];
             var value = subImage[key];
             switch (key) {
-                case "x": image.xOffset = value; break;
-                case "y": image.yOffset = value; break;
+                case "x": image.xStart = value; break;
+                case "y": image.yStart = value; break;
+                case "width": image.xSize = value; break;
+                case "height": image.ySize = value; break;
             }
         }
     }

interface/src/Application.cpp

@@ -2812,10 +2812,10 @@ static int getEventQueueSize(QThread* thread) {
 static void dumpEventQueue(QThread* thread) {
     auto threadData = QThreadData::get2(thread);
     QMutexLocker locker(&threadData->postEventList.mutex);
-    qDebug() << "AJT: event list, size =" << threadData->postEventList.size();
+    qDebug() << "Event list, size =" << threadData->postEventList.size();
     for (auto& postEvent : threadData->postEventList) {
         QEvent::Type type = (postEvent.event ? postEvent.event->type() : QEvent::None);
-        qDebug() << "AJT:    " << type;
+        qDebug() << "    " << type;
     }
 }
 #endif // DEBUG_EVENT_QUEUE
@@ -5974,7 +5974,7 @@ bool Application::acceptURL(const QString& urlString, bool defaultUpload) {
         }
     }
 
-    if (defaultUpload) {
+    if (defaultUpload && !url.fileName().isEmpty() && url.isLocalFile()) {
         showAssetServerWidget(urlString);
     }
     return defaultUpload;
@@ -7075,11 +7075,11 @@ QRect Application::getRecommendedHUDRect() const {
     return result;
 }
 
-QSize Application::getDeviceSize() const {
+glm::vec2 Application::getDeviceSize() const {
     static const int MIN_SIZE = 1;
-    QSize result(MIN_SIZE, MIN_SIZE);
+    glm::vec2 result(MIN_SIZE);
     if (_displayPlugin) {
-        result = fromGlm(getActiveDisplayPlugin()->getRecommendedRenderSize());
+        result = getActiveDisplayPlugin()->getRecommendedRenderSize();
     }
     return result;
 }
@@ -7098,10 +7098,6 @@ bool Application::hasFocus() const {
     return (QApplication::activeWindow() != nullptr);
 }
 
-glm::vec2 Application::getViewportDimensions() const {
-    return toGlm(getDeviceSize());
-}
-
 void Application::setMaxOctreePacketsPerSecond(int maxOctreePPS) {
     if (maxOctreePPS != _maxOctreePPS) {
         _maxOctreePPS = maxOctreePPS;

interface/src/Application.h

@@ -158,7 +158,7 @@ public:
 
     glm::uvec2 getUiSize() const;
     QRect getRecommendedHUDRect() const;
-    QSize getDeviceSize() const;
+    glm::vec2 getDeviceSize() const;
     bool hasFocus() const;
 
     void showCursor(const Cursor::Icon& cursor);
@@ -228,8 +228,6 @@ public:
 
     FileLogger* getLogger() const { return _logger; }
 
-    glm::vec2 getViewportDimensions() const;
-
     NodeToJurisdictionMap& getEntityServerJurisdictions() { return _entityServerJurisdictions; }
 
     float getRenderResolutionScale() const;

interface/src/Application_render.cpp

@@ -104,8 +104,7 @@ void Application::paintGL() {
         PerformanceTimer perfTimer("renderOverlay");
         // NOTE: There is no batch associated with this renderArgs
         // the ApplicationOverlay class assumes it's viewport is setup to be the device size
-        QSize size = getDeviceSize();
-        renderArgs._viewport = glm::ivec4(0, 0, size.width(), size.height());
+        renderArgs._viewport = glm::ivec4(0, 0, getDeviceSize());
         _applicationOverlay.renderOverlay(&renderArgs);
     }
 

interface/src/Menu.cpp

@@ -679,36 +679,16 @@ Menu::Menu() {
     });
 
     auto audioIO = DependencyManager::get<AudioClient>();
-    addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoServerAudio, 0, false,
-        audioIO.data(), SLOT(toggleServerEcho()));
-    addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoLocalAudio, 0, false,
-        audioIO.data(), SLOT(toggleLocalEcho()));
     addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::MuteEnvironment, 0,
         audioIO.data(), SLOT(sendMuteEnvironmentPacket()));
 
-    auto scope = DependencyManager::get<AudioScope>();
-    MenuWrapper* audioScopeMenu = audioDebugMenu->addMenu("Audio Scope");
-    addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScope, Qt::CTRL | Qt::Key_F2, false,
-        scope.data(), SLOT(toggle()));
-    addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopePause, Qt::CTRL | Qt::SHIFT | Qt::Key_F2, false,
-        scope.data(), SLOT(togglePause()));
-
-    addDisabledActionAndSeparator(audioScopeMenu, "Display Frames");
-    {
-        QAction* fiveFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiveFrames,
-            0, true, scope.data(), SLOT(selectAudioScopeFiveFrames()));
-
-        QAction* twentyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeTwentyFrames,
-            0, false, scope.data(), SLOT(selectAudioScopeTwentyFrames()));
-
-        QAction* fiftyFrames = addCheckableActionToQMenuAndActionHash(audioScopeMenu, MenuOption::AudioScopeFiftyFrames,
-            0, false, scope.data(), SLOT(selectAudioScopeFiftyFrames()));
-
-        QActionGroup* audioScopeFramesGroup = new QActionGroup(audioScopeMenu);
-        audioScopeFramesGroup->addAction(fiveFrames);
-        audioScopeFramesGroup->addAction(twentyFrames);
-        audioScopeFramesGroup->addAction(fiftyFrames);
-    }
+    action = addActionToQMenuAndActionHash(audioDebugMenu, MenuOption::AudioScope);
+    connect(action, &QAction::triggered, [] {
+        auto scriptEngines = DependencyManager::get<ScriptEngines>();
+        QUrl defaultScriptsLoc = PathUtils::defaultScriptsLocation();
+        defaultScriptsLoc.setPath(defaultScriptsLoc.path() + "developer/utilities/audio/audioScope.js");
+        scriptEngines->loadScript(defaultScriptsLoc.toString());
+    });
 
     // Developer > Physics >>>
     MenuWrapper* physicsOptionsMenu = developerMenu->addMenu("Physics");

interface/src/audio/AudioScope.cpp

@@ -9,6 +9,7 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+#include <qvector2d.h>
 #include <limits>
 
 #include <AudioClient.h>
@@ -21,13 +22,14 @@
 #include "AudioScope.h"
 
 static const unsigned int DEFAULT_FRAMES_PER_SCOPE = 5;
-static const unsigned int SCOPE_WIDTH = AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL * DEFAULT_FRAMES_PER_SCOPE;
 static const unsigned int MULTIPLIER_SCOPE_HEIGHT = 20;
 static const unsigned int SCOPE_HEIGHT = 2 * 15 * MULTIPLIER_SCOPE_HEIGHT;
 
 AudioScope::AudioScope() :
     _isEnabled(false),
     _isPaused(false),
+    _isTriggered(false),
+    _autoTrigger(false),
     _scopeInputOffset(0),
     _scopeOutputOffset(0),
     _framesPerScope(DEFAULT_FRAMES_PER_SCOPE),
@@ -43,6 +45,7 @@ AudioScope::AudioScope() :
     _outputRightD(DependencyManager::get<GeometryCache>()->allocateID())
 {
     auto audioIO = DependencyManager::get<AudioClient>();
+    
     connect(&audioIO->getReceivedAudioStream(), &MixedProcessedAudioStream::addedSilence,
             this, &AudioScope::addStereoSilenceToScope);
     connect(&audioIO->getReceivedAudioStream(), &MixedProcessedAudioStream::addedLastFrameRepeatedWithFade,
@@ -75,6 +78,18 @@ void AudioScope::selectAudioScopeFiftyFrames() {
     reallocateScope(50);
 }
 
+void AudioScope::setLocalEcho(bool localEcho) {
+    DependencyManager::get<AudioClient>()->setLocalEcho(localEcho);
+}
+
+void AudioScope::setServerEcho(bool serverEcho) {
+    DependencyManager::get<AudioClient>()->setServerEcho(serverEcho);
+}
+
+float AudioScope::getFramesPerSecond(){
+    return AudioConstants::NETWORK_FRAMES_PER_SEC;
+}
+
 void AudioScope::allocateScope() {
     _scopeInputOffset = 0;
     _scopeOutputOffset = 0;
@@ -108,63 +123,14 @@ void AudioScope::freeScope() {
     }
 }
 
-void AudioScope::render(RenderArgs* renderArgs, int width, int height) {
-    
-    if (!_isEnabled) {
-        return;
-    }
-    
-    static const glm::vec4 backgroundColor = { 0.4f, 0.4f, 0.4f, 0.6f };
-    static const glm::vec4 gridColor = { 0.7f, 0.7f, 0.7f, 1.0f };
-    static const glm::vec4 inputColor = { 0.3f, 1.0f, 0.3f, 1.0f };
-    static const glm::vec4 outputLeftColor = { 1.0f, 0.3f, 0.3f, 1.0f };
-    static const glm::vec4 outputRightColor = { 0.3f, 0.3f, 1.0f, 1.0f };
-    static const int gridCols = 2;
-    int gridRows = _framesPerScope;
-    
-    int x = (width - (int)SCOPE_WIDTH) / 2;
-    int y = (height - (int)SCOPE_HEIGHT) / 2;
-    int w = (int)SCOPE_WIDTH;
-    int h = (int)SCOPE_HEIGHT;
-
-    gpu::Batch& batch = *renderArgs->_batch;
-    auto geometryCache = DependencyManager::get<GeometryCache>();
-
-    // Grid uses its own pipeline, so draw it before setting another
-    const float GRID_EDGE = 0.005f;
-    geometryCache->renderGrid(batch, glm::vec2(x, y), glm::vec2(x + w, y + h),
-        gridRows, gridCols, GRID_EDGE, gridColor, true, _audioScopeGrid);
-
-    geometryCache->useSimpleDrawPipeline(batch);
-    auto textureCache = DependencyManager::get<TextureCache>();
-    batch.setResourceTexture(0, textureCache->getWhiteTexture());
-    
-    // FIXME - do we really need to reset this here? we know that we're called inside of ApplicationOverlay::renderOverlays
-    //         which already set up our batch for us to have these settings
-    mat4 legacyProjection = glm::ortho<float>(0, width, height, 0, -1000, 1000);
-    batch.setProjectionTransform(legacyProjection);
-    batch.setModelTransform(Transform());
-    batch.resetViewTransform();
-
-    geometryCache->renderQuad(batch, x, y, w, h, backgroundColor, _audioScopeBackground);
-    renderLineStrip(batch, _inputID, inputColor, x, y, _samplesPerScope, _scopeInputOffset, _scopeInput);
-    renderLineStrip(batch, _outputLeftID, outputLeftColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputLeft);
-    renderLineStrip(batch, _outputRightD, outputRightColor, x, y, _samplesPerScope, _scopeOutputOffset, _scopeOutputRight);
-}
-
-void AudioScope::renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& color, int x, int y, int n, int offset, const QByteArray* byteArray) {
-
+QVector<int> AudioScope::getScopeVector(const QByteArray* byteArray, int offset) {
     int16_t sample;
-    int16_t* samples = ((int16_t*) byteArray->data()) + offset;
+    QVector<int> points;
+    if (!_isEnabled || byteArray == NULL) return points;
+    int16_t* samples = ((int16_t*)byteArray->data()) + offset;
     int numSamplesToAverage = _framesPerScope / DEFAULT_FRAMES_PER_SCOPE;
-    int count = (n - offset) / numSamplesToAverage;
-    int remainder = (n - offset) % numSamplesToAverage;
-    y += SCOPE_HEIGHT / 2;
-    
-    auto geometryCache = DependencyManager::get<GeometryCache>();
-
-    QVector<glm::vec2> points;
-    
+    int count = (_samplesPerScope - offset) / numSamplesToAverage;
+    int remainder = (_samplesPerScope - offset) % numSamplesToAverage;
 
     // Compute and draw the sample averages from the offset position
     for (int i = count; --i >= 0; ) {
@@ -173,7 +139,7 @@ void AudioScope::renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& col
             sample += *samples++;
         }
         sample /= numSamplesToAverage;
-        points << glm::vec2(x++, y - sample);
+        points << -sample;
     }
 
     // Compute and draw the sample average across the wrap boundary
@@ -182,16 +148,17 @@ void AudioScope::renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& col
         for (int j = remainder; --j >= 0; ) {
             sample += *samples++;
         }
-    
-        samples = (int16_t*) byteArray->data();
+
+        samples = (int16_t*)byteArray->data();
 
         for (int j = numSamplesToAverage - remainder; --j >= 0; ) {
             sample += *samples++;
         }
         sample /= numSamplesToAverage;
-        points << glm::vec2(x++, y - sample);
-    } else {
-        samples = (int16_t*) byteArray->data();
+        points << -sample;
+    }
+    else {
+        samples = (int16_t*)byteArray->data();
     }
 
     // Compute and draw the sample average from the beginning to the offset
@@ -202,12 +169,51 @@ void AudioScope::renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& col
             sample += *samples++;
         }
         sample /= numSamplesToAverage;
-        points << glm::vec2(x++, y - sample);
+
+        points << -sample;
+    }
+    return points;
+}
+
+bool AudioScope::shouldTrigger(const QVector<int>& scope) {
+    int threshold = 4;
+    if (_autoTrigger && _triggerValues.x < scope.size()) {
+        for (int i = -4*threshold; i < +4*threshold; i++) {
+            int idx = _triggerValues.x + i;
+            idx = (idx < 0) ? 0 : (idx < scope.size() ? idx : scope.size() - 1);
+            int dif = abs(_triggerValues.y - scope[idx]);
+            if (dif < threshold) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+void AudioScope::storeTriggerValues() {
+    _triggerInputData = _scopeInputData;
+    _triggerOutputLeftData = _scopeOutputLeftData;
+    _triggerOutputRightData = _scopeOutputRightData;
+    _isTriggered = true;
+    emit triggered();
+}
+
+void AudioScope::computeInputData() {
+    _scopeInputData = getScopeVector(_scopeInput, _scopeInputOffset);
+    if (shouldTrigger(_scopeInputData)) {
+        storeTriggerValues();
+    }
+}
+
+void AudioScope::computeOutputData() {
+    _scopeOutputLeftData = getScopeVector(_scopeOutputLeft, _scopeOutputOffset);
+    if (shouldTrigger(_scopeOutputLeftData)) {
+        storeTriggerValues();
+    }
+    _scopeOutputRightData = getScopeVector(_scopeOutputRight, _scopeOutputOffset);
+    if (shouldTrigger(_scopeOutputRightData)) {
+        storeTriggerValues();
     }
-    
-    
-    geometryCache->updateVertices(id, points, color);
-    geometryCache->renderVertices(batch, gpu::LINE_STRIP, id);
 }
 
 int AudioScope::addBufferToScope(QByteArray* byteArray, int frameOffset, const int16_t* source, int sourceSamplesPerChannel,
@@ -231,7 +237,7 @@ int AudioScope::addBufferToScope(QByteArray* byteArray, int frameOffset, const i
 }
 
 int AudioScope::addSilenceToScope(QByteArray* byteArray, int frameOffset, int silentSamples) {
-                                                                                                                                                                                                                                    
+                                                                                                                                                                                                                                 
     // Short int pointer to mapped samples in byte array
     int16_t* destination = (int16_t*)byteArray->data();
     
@@ -271,6 +277,7 @@ void AudioScope::addStereoSamplesToScope(const QByteArray& samples) {
     _scopeOutputOffset = addBufferToScope(_scopeOutputRight, _scopeOutputOffset, samplesData, samplesPerChannel, 1, AudioConstants::STEREO);
     
     _scopeLastFrame = samples.right(AudioConstants::NETWORK_FRAME_BYTES_STEREO);
+    computeOutputData();
 }
 
 void AudioScope::addLastFrameRepeatedWithFadeToScope(int samplesPerChannel) {
@@ -302,4 +309,5 @@ void AudioScope::addInputToScope(const QByteArray& inputSamples) {
     _scopeInputOffset = addBufferToScope(_scopeInput, _scopeInputOffset,
                                          reinterpret_cast<const int16_t*>(inputSamples.data()),
                                          inputSamples.size() / sizeof(int16_t), INPUT_AUDIO_CHANNEL, NUM_INPUT_CHANNELS);
+    computeInputData();
 }

interface/src/audio/AudioScope.h

@@ -24,27 +24,60 @@
 class AudioScope : public QObject, public Dependency {
     Q_OBJECT
     SINGLETON_DEPENDENCY
+    
+    Q_PROPERTY(QVector<int> scopeInput READ getScopeInput)
+    Q_PROPERTY(QVector<int> scopeOutputLeft READ getScopeOutputLeft)
+    Q_PROPERTY(QVector<int> scopeOutputRight READ getScopeOutputRight)
+
+    Q_PROPERTY(QVector<int> triggerInput READ getTriggerInput)
+    Q_PROPERTY(QVector<int> triggerOutputLeft READ getTriggerOutputLeft)
+    Q_PROPERTY(QVector<int> triggerOutputRight READ getTriggerOutputRight)
+
 public:
     // Audio scope methods for allocation/deallocation
     void allocateScope();
     void freeScope();
     void reallocateScope(int frames);
     
-    void render(RenderArgs* renderArgs, int width, int height);
-    
 public slots:
     void toggle() { setVisible(!_isEnabled); }
     void setVisible(bool visible);
     bool getVisible() const { return _isEnabled; }
 
-    void togglePause() { _isPaused = !_isPaused; }
-    void setPause(bool paused) { _isPaused = paused; }
+    void togglePause() { setPause(!_isPaused); }
+    void setPause(bool paused) { _isPaused = paused; emit pauseChanged(); }
     bool getPause() { return _isPaused; }
 
+    void toggleTrigger() { _autoTrigger = !_autoTrigger; }
+    bool getAutoTrigger() { return _autoTrigger; }
+    void setAutoTrigger(bool autoTrigger) { _isTriggered = false; _autoTrigger = autoTrigger; }
+
+    void setTriggerValues(int x, int y) { _triggerValues.x = x; _triggerValues.y = y; }
+    void setTriggered(bool triggered) { _isTriggered = triggered; }
+    bool getTriggered() { return _isTriggered; }
+
+    float getFramesPerSecond();
+    int getFramesPerScope() { return _framesPerScope; }
+
     void selectAudioScopeFiveFrames();
     void selectAudioScopeTwentyFrames();
     void selectAudioScopeFiftyFrames();
-    
+
+    QVector<int> getScopeInput() { return _scopeInputData; };
+    QVector<int> getScopeOutputLeft() { return _scopeOutputLeftData; };
+    QVector<int> getScopeOutputRight() { return _scopeOutputRightData; };
+
+    QVector<int> getTriggerInput() { return _triggerInputData; };
+    QVector<int> getTriggerOutputLeft() { return _triggerOutputLeftData; };
+    QVector<int> getTriggerOutputRight() { return _triggerOutputRightData; };
+
+    void setLocalEcho(bool serverEcho);
+    void setServerEcho(bool serverEcho);
+
+signals:
+    void pauseChanged();
+    void triggered();
+
 protected:
     AudioScope();
     
@@ -55,24 +88,44 @@ private slots:
     void addInputToScope(const QByteArray& inputSamples);
     
 private:
-    // Audio scope methods for rendering
-    void renderLineStrip(gpu::Batch& batch, int id, const glm::vec4& color, int x, int  y, int n, int offset, const QByteArray* byteArray);
     
     // Audio scope methods for data acquisition
     int addBufferToScope(QByteArray* byteArray, int frameOffset, const int16_t* source, int sourceSamples,
                          unsigned int sourceChannel, unsigned int sourceNumberOfChannels, float fade = 1.0f);
     int addSilenceToScope(QByteArray* byteArray, int frameOffset, int silentSamples);
     
+    QVector<int> getScopeVector(const QByteArray* scope, int offset);
+
+    bool shouldTrigger(const QVector<int>& scope);
+    void computeInputData();
+    void computeOutputData();
+
+    void storeTriggerValues();
+
     bool _isEnabled;
     bool _isPaused;
+    bool _isTriggered;
+    bool _autoTrigger;
     int _scopeInputOffset;
     int _scopeOutputOffset;
     int _framesPerScope;
     int _samplesPerScope;
+
     QByteArray* _scopeInput;
     QByteArray* _scopeOutputLeft;
     QByteArray* _scopeOutputRight;
     QByteArray _scopeLastFrame;
+    
+    QVector<int> _scopeInputData;
+    QVector<int> _scopeOutputLeftData;
+    QVector<int> _scopeOutputRightData;
+
+    QVector<int> _triggerInputData;
+    QVector<int> _triggerOutputLeftData;
+    QVector<int> _triggerOutputRightData;
+
+    
+    glm::ivec2 _triggerValues;
 
     int _audioScopeBackground;
     int _audioScopeGrid;

interface/src/avatar/AvatarManager.cpp

@@ -28,6 +28,7 @@
 #include <shared/QtHelpers.h>
 #include <AvatarData.h>
 #include <PerfStat.h>
+#include <PrioritySortUtil.h>
 #include <RegisteredMetaTypes.h>
 #include <Rig.h>
 #include <SettingHandle.h>
@@ -142,32 +143,39 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
 
     PerformanceTimer perfTimer("otherAvatars");
 
-    auto avatarMap = getHashCopy();
-    QList<AvatarSharedPointer> avatarList = avatarMap.values();
+    class SortableAvatar: public PrioritySortUtil::Sortable {
+    public:
+        SortableAvatar() = delete;
+        SortableAvatar(const AvatarSharedPointer& avatar) : _avatar(avatar) {}
+        glm::vec3 getPosition() const override { return _avatar->getWorldPosition(); }
+        float getRadius() const override { return std::static_pointer_cast<Avatar>(_avatar)->getBoundingRadius(); }
+        uint64_t getTimestamp() const override { return std::static_pointer_cast<Avatar>(_avatar)->getLastRenderUpdateTime(); }
+        const AvatarSharedPointer& getAvatar() const { return _avatar; }
+    private:
+        AvatarSharedPointer _avatar;
+    };
+
     ViewFrustum cameraView;
     qApp->copyDisplayViewFrustum(cameraView);
+    PrioritySortUtil::PriorityQueue<SortableAvatar> sortedAvatars(cameraView,
+            AvatarData::_avatarSortCoefficientSize,
+            AvatarData::_avatarSortCoefficientCenter,
+            AvatarData::_avatarSortCoefficientAge);
 
-    std::priority_queue<AvatarPriority> sortedAvatars;
-    AvatarData::sortAvatars(avatarList, cameraView, sortedAvatars,
-
-        [](AvatarSharedPointer avatar)->uint64_t{
-            return std::static_pointer_cast<Avatar>(avatar)->getLastRenderUpdateTime();
-        },
-
-        [](AvatarSharedPointer avatar)->float{
-            return std::static_pointer_cast<Avatar>(avatar)->getBoundingRadius();
-        },
-
-        [this](AvatarSharedPointer avatar)->bool{
-            const auto& castedAvatar = std::static_pointer_cast<Avatar>(avatar);
-            if (castedAvatar == _myAvatar || !castedAvatar->isInitialized()) {
-                // DO NOT update _myAvatar!  Its update has already been done earlier in the main loop.
-                // DO NOT update or fade out uninitialized Avatars
-                return true; // ignore it
-            }
-            return false;
-        });
+    // sort
+    auto avatarMap = getHashCopy();
+    AvatarHash::iterator itr = avatarMap.begin();
+    while (itr != avatarMap.end()) {
+        const auto& avatar = std::static_pointer_cast<Avatar>(*itr);
+        // DO NOT update _myAvatar!  Its update has already been done earlier in the main loop.
+        // DO NOT update or fade out uninitialized Avatars
+        if (avatar != _myAvatar && avatar->isInitialized()) {
+            sortedAvatars.push(SortableAvatar(avatar));
+        }
+        ++itr;
+    }
 
+    // process in sorted order
     uint64_t startTime = usecTimestampNow();
     const uint64_t UPDATE_BUDGET = 2000; // usec
     uint64_t updateExpiry = startTime + UPDATE_BUDGET;
@@ -176,8 +184,8 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
 
     render::Transaction transaction;
     while (!sortedAvatars.empty()) {
-        const AvatarPriority& sortData = sortedAvatars.top();
-        const auto& avatar = std::static_pointer_cast<Avatar>(sortData.avatar);
+        const SortableAvatar& sortData = sortedAvatars.top();
+        const auto& avatar = std::static_pointer_cast<Avatar>(sortData.getAvatar());
 
         bool ignoring = DependencyManager::get<NodeList>()->isPersonalMutingNode(avatar->getID());
         if (ignoring) {
@@ -207,7 +215,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
         uint64_t now = usecTimestampNow();
         if (now < updateExpiry) {
             // we're within budget
-            bool inView = sortData.priority > OUT_OF_VIEW_THRESHOLD;
+            bool inView = sortData.getPriority() > OUT_OF_VIEW_THRESHOLD;
             if (inView && avatar->hasNewJointData()) {
                 numAvatarsUpdated++;
             }
@@ -221,7 +229,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
             // --> some avatar velocity measurements may be a little off
 
             // no time simulate, but we take the time to count how many were tragically missed
-            bool inView = sortData.priority > OUT_OF_VIEW_THRESHOLD;
+            bool inView = sortData.getPriority() > OUT_OF_VIEW_THRESHOLD;
             if (!inView) {
                 break;
             }
@@ -230,9 +238,9 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
             }
             sortedAvatars.pop();
             while (inView && !sortedAvatars.empty()) {
-                const AvatarPriority& newSortData = sortedAvatars.top();
-                const auto& newAvatar = std::static_pointer_cast<Avatar>(newSortData.avatar);
-                inView = newSortData.priority > OUT_OF_VIEW_THRESHOLD;
+                const SortableAvatar& newSortData = sortedAvatars.top();
+                const auto& newAvatar = std::static_pointer_cast<Avatar>(newSortData.getAvatar());
+                inView = newSortData.getPriority() > OUT_OF_VIEW_THRESHOLD;
                 if (inView && newAvatar->hasNewJointData()) {
                     numAVatarsNotUpdated++;
                 }

interface/src/avatar/MyAvatar.cpp

@@ -114,7 +114,8 @@ MyAvatar::MyAvatar(QThread* thread) :
 
     _skeletonModel = std::make_shared<MySkeletonModel>(this, nullptr);
     connect(_skeletonModel.get(), &Model::setURLFinished, this, &Avatar::setModelURLFinished);
-
+    connect(_skeletonModel.get(), &Model::rigReady, this, &Avatar::rigReady);
+    connect(_skeletonModel.get(), &Model::rigReset, this, &Avatar::rigReset);
 
     using namespace recording;
     _skeletonModel->flagAsCauterized();
@@ -1516,9 +1517,19 @@ void MyAvatar::updateMotors() {
     _characterController.clearMotors();
     glm::quat motorRotation;
     if (_motionBehaviors & AVATAR_MOTION_ACTION_MOTOR_ENABLED) {
+
+        const float FLYING_MOTOR_TIMESCALE = 0.05f;
+        const float WALKING_MOTOR_TIMESCALE = 0.2f;
+        const float INVALID_MOTOR_TIMESCALE = 1.0e6f;
+
+        float horizontalMotorTimescale;
+        float verticalMotorTimescale;
+
         if (_characterController.getState() == CharacterController::State::Hover ||
                 _characterController.computeCollisionGroup() == BULLET_COLLISION_GROUP_COLLISIONLESS) {
             motorRotation = getMyHead()->getHeadOrientation();
+            horizontalMotorTimescale = FLYING_MOTOR_TIMESCALE;
+            verticalMotorTimescale = FLYING_MOTOR_TIMESCALE;
         } else {
             // non-hovering = walking: follow camera twist about vertical but not lift
             // we decompose camera's rotation and store the twist part in motorRotation
@@ -1529,11 +1540,12 @@ void MyAvatar::updateMotors() {
             glm::quat liftRotation;
             swingTwistDecomposition(headOrientation, Vectors::UNIT_Y, liftRotation, motorRotation);
             motorRotation = orientation * motorRotation;
+            horizontalMotorTimescale = WALKING_MOTOR_TIMESCALE;
+            verticalMotorTimescale = INVALID_MOTOR_TIMESCALE;
         }
-        const float DEFAULT_MOTOR_TIMESCALE = 0.2f;
-        const float INVALID_MOTOR_TIMESCALE = 1.0e6f;
+
         if (_isPushing || _isBraking || !_isBeingPushed) {
-            _characterController.addMotor(_actionMotorVelocity, motorRotation, DEFAULT_MOTOR_TIMESCALE, INVALID_MOTOR_TIMESCALE);
+            _characterController.addMotor(_actionMotorVelocity, motorRotation, horizontalMotorTimescale, verticalMotorTimescale);
         } else {
             // _isBeingPushed must be true --> disable action motor by giving it a long timescale,
             // otherwise it's attempt to "stand in in place" could defeat scripted motor/thrusts
@@ -1799,6 +1811,7 @@ void MyAvatar::postUpdate(float deltaTime, const render::ScenePointer& scene) {
         _skeletonModel->setCauterizeBoneSet(_headBoneSet);
         _fstAnimGraphOverrideUrl = _skeletonModel->getGeometry()->getAnimGraphOverrideUrl();
         initAnimGraph();
+        _isAnimatingScale = true;
     }
 
     if (_enableDebugDrawDefaultPose || _enableDebugDrawAnimPose) {
@@ -1956,27 +1969,33 @@ void MyAvatar::updateOrientation(float deltaTime) {
 
     // Use head/HMD roll to turn while flying, but not when standing still.
     if (qApp->isHMDMode() && getCharacterController()->getState() == CharacterController::State::Hover && _hmdRollControlEnabled && hasDriveInput()) {
+
         // Turn with head roll.
-        const float MIN_CONTROL_SPEED = 0.01f;
-        float speed = glm::length(getWorldVelocity());
-        if (speed >= MIN_CONTROL_SPEED) {
-            // Feather turn when stopping moving.
-            float speedFactor;
-            if (getDriveKey(TRANSLATE_Z) != 0.0f || _lastDrivenSpeed == 0.0f) {
-                _lastDrivenSpeed = speed;
-                speedFactor = 1.0f;
-            } else {
-                speedFactor = glm::min(speed / _lastDrivenSpeed, 1.0f);
-            }
+        const float MIN_CONTROL_SPEED = 2.0f * getSensorToWorldScale();  // meters / sec
+        const glm::vec3 characterForward = getWorldOrientation() * Vectors::UNIT_NEG_Z;
+        float forwardSpeed = glm::dot(characterForward, getWorldVelocity());
 
-            float direction = glm::dot(getWorldVelocity(), getWorldOrientation() * Vectors::UNIT_NEG_Z) > 0.0f ? 1.0f : -1.0f;
+        // only enable roll-turns if we are moving forward or backward at greater then MIN_CONTROL_SPEED
+        if (fabsf(forwardSpeed) >= MIN_CONTROL_SPEED) {
 
+            float direction = forwardSpeed > 0.0f ? 1.0f : -1.0f;
             float rollAngle = glm::degrees(asinf(glm::dot(IDENTITY_UP, _hmdSensorOrientation * IDENTITY_RIGHT)));
             float rollSign = rollAngle < 0.0f ? -1.0f : 1.0f;
             rollAngle = fabsf(rollAngle);
-            rollAngle = rollAngle > _hmdRollControlDeadZone ? rollSign * (rollAngle - _hmdRollControlDeadZone) : 0.0f;
 
-            totalBodyYaw += speedFactor * direction * rollAngle * deltaTime * _hmdRollControlRate;
+            const float MIN_ROLL_ANGLE = _hmdRollControlDeadZone;
+            const float MAX_ROLL_ANGLE = 90.0f;  // degrees
+
+            if (rollAngle > MIN_ROLL_ANGLE) {
+                // rate of turning is linearly proportional to rollAngle
+                rollAngle = glm::clamp(rollAngle, MIN_ROLL_ANGLE, MAX_ROLL_ANGLE);
+
+                // scale rollAngle into a value from zero to one.
+                float rollFactor = (rollAngle - MIN_ROLL_ANGLE) / (MAX_ROLL_ANGLE - MIN_ROLL_ANGLE);
+
+                float angularSpeed = rollSign * rollFactor * _hmdRollControlRate;
+                totalBodyYaw += direction * angularSpeed * deltaTime;
+            }
         }
     }
 
@@ -2022,12 +2041,13 @@ void MyAvatar::updateActionMotor(float deltaTime) {
         _isBraking = _wasPushing || (_isBraking && speed > MIN_ACTION_BRAKE_SPEED);
     }
 
+    CharacterController::State state = _characterController.getState();
+
     // compute action input
     glm::vec3 forward = (getDriveKey(TRANSLATE_Z)) * IDENTITY_FORWARD;
     glm::vec3 right = (getDriveKey(TRANSLATE_X)) * IDENTITY_RIGHT;
 
     glm::vec3 direction = forward + right;
-    CharacterController::State state = _characterController.getState();
     if (state == CharacterController::State::Hover ||
             _characterController.computeCollisionGroup() == BULLET_COLLISION_GROUP_COLLISIONLESS) {
         // we can fly --> support vertical motion
@@ -2161,41 +2181,6 @@ bool findAvatarAvatarPenetration(const glm::vec3 positionA, float radiusA, float
 // target scale to match the new scale they have chosen. When they leave the domain they will not return to the scale they were
 // before they entered the limiting domain.
 
-void MyAvatar::clampTargetScaleToDomainLimits() {
-    // when we're about to change the target scale because the user has asked to increase or decrease their scale,
-    // we first make sure that we're starting from a target scale that is allowed by the current domain
-
-    auto clampedTargetScale = glm::clamp(_targetScale, _domainMinimumScale, _domainMaximumScale);
-
-    if (clampedTargetScale != _targetScale) {
-        qCDebug(interfaceapp, "Clamped scale to %f since original target scale %f was not allowed by domain",
-                (double)clampedTargetScale, (double)_targetScale);
-
-        setTargetScale(clampedTargetScale);
-    }
-}
-
-void MyAvatar::clampScaleChangeToDomainLimits(float desiredScale) {
-    auto clampedTargetScale = glm::clamp(desiredScale, _domainMinimumScale, _domainMaximumScale);
-
-    if (clampedTargetScale != desiredScale) {
-        qCDebug(interfaceapp, "Forcing scale to %f since %f is not allowed by domain",
-                clampedTargetScale, desiredScale);
-    }
-
-    setTargetScale(clampedTargetScale);
-    qCDebug(interfaceapp, "Changed scale to %f", (double)_targetScale);
-    emit(scaleChanged());
-}
-
-float MyAvatar::getDomainMinScale() {
-    return _domainMinimumScale;
-}
-
-float MyAvatar::getDomainMaxScale() {
-    return _domainMaximumScale;
-}
-
 void MyAvatar::setGravity(float gravity) {
     _characterController.setGravity(gravity);
 }
@@ -2205,70 +2190,58 @@ float MyAvatar::getGravity() {
 }
 
 void MyAvatar::increaseSize() {
-    // make sure we're starting from an allowable scale
-    clampTargetScaleToDomainLimits();
+    float minScale = getDomainMinScale();
+    float maxScale = getDomainMaxScale();
 
-    // calculate what our new scale should be
-    float updatedTargetScale = _targetScale * (1.0f + SCALING_RATIO);
+    float clampedTargetScale = glm::clamp(_targetScale, minScale, maxScale);
+    float newTargetScale = glm::clamp(clampedTargetScale * (1.0f + SCALING_RATIO), minScale, maxScale);
 
-    // attempt to change to desired scale (clamped to the domain limits)
-    clampScaleChangeToDomainLimits(updatedTargetScale);
+    setTargetScale(newTargetScale);
 }
 
 void MyAvatar::decreaseSize() {
-    // make sure we're starting from an allowable scale
-    clampTargetScaleToDomainLimits();
+    float minScale = getDomainMinScale();
+    float maxScale = getDomainMaxScale();
 
-    // calculate what our new scale should be
-    float updatedTargetScale = _targetScale * (1.0f - SCALING_RATIO);
+    float clampedTargetScale = glm::clamp(_targetScale, minScale, maxScale);
+    float newTargetScale = glm::clamp(clampedTargetScale * (1.0f - SCALING_RATIO), minScale, maxScale);
 
-    // attempt to change to desired scale (clamped to the domain limits)
-    clampScaleChangeToDomainLimits(updatedTargetScale);
+    setTargetScale(newTargetScale);
 }
 
 void MyAvatar::resetSize() {
     // attempt to reset avatar size to the default (clamped to domain limits)
     const float DEFAULT_AVATAR_SCALE = 1.0f;
-
-    clampScaleChangeToDomainLimits(DEFAULT_AVATAR_SCALE);
+    setTargetScale(DEFAULT_AVATAR_SCALE);
 }
 
 void MyAvatar::restrictScaleFromDomainSettings(const QJsonObject& domainSettingsObject) {
-    // pull out the minimum and maximum scale and set them to restrict our scale
+    // pull out the minimum and maximum height and set them to restrict our scale
 
     static const QString AVATAR_SETTINGS_KEY = "avatars";
     auto avatarsObject = domainSettingsObject[AVATAR_SETTINGS_KEY].toObject();
 
-    static const QString MIN_SCALE_OPTION = "min_avatar_scale";
-    float settingMinScale = avatarsObject[MIN_SCALE_OPTION].toDouble(MIN_AVATAR_SCALE);
-    setDomainMinimumScale(settingMinScale);
+    static const QString MIN_HEIGHT_OPTION = "min_avatar_height";
+    float settingMinHeight = avatarsObject[MIN_HEIGHT_OPTION].toDouble(MIN_AVATAR_HEIGHT);
+    setDomainMinimumHeight(settingMinHeight);
 
-    static const QString MAX_SCALE_OPTION = "max_avatar_scale";
-    float settingMaxScale = avatarsObject[MAX_SCALE_OPTION].toDouble(MAX_AVATAR_SCALE);
-    setDomainMaximumScale(settingMaxScale);
+    static const QString MAX_HEIGHT_OPTION = "max_avatar_height";
+    float settingMaxHeight = avatarsObject[MAX_HEIGHT_OPTION].toDouble(MAX_AVATAR_HEIGHT);
+    setDomainMaximumHeight(settingMaxHeight);
 
     // make sure that the domain owner didn't flip min and max
-    if (_domainMinimumScale > _domainMaximumScale) {
-        std::swap(_domainMinimumScale, _domainMaximumScale);
+    if (_domainMinimumHeight > _domainMaximumHeight) {
+        std::swap(_domainMinimumHeight, _domainMaximumHeight);
     }
     // Set avatar current scale
     Settings settings;
     settings.beginGroup("Avatar");
     _targetScale = loadSetting(settings, "scale", 1.0f);
 
-    qCDebug(interfaceapp) << "This domain requires a minimum avatar scale of " << _domainMinimumScale
-        << " and a maximum avatar scale of " << _domainMaximumScale
-        << ". Current avatar scale is " << _targetScale;
+    qCDebug(interfaceapp) << "This domain requires a minimum avatar scale of " << _domainMinimumHeight
+                          << " and a maximum avatar scale of " << _domainMaximumHeight;
 
-    // debug to log if this avatar's scale in this domain will be clamped
-    float clampedScale = glm::clamp(_targetScale, _domainMinimumScale, _domainMaximumScale);
-
-    if (_targetScale != clampedScale) {
-        qCDebug(interfaceapp) << "Current avatar scale is clamped to " << clampedScale
-            << " because " << _targetScale << " is not allowed by current domain";
-        // The current scale of avatar should not be more than domain's max_avatar_scale and not less than domain's min_avatar_scale .
-        _targetScale = clampedScale;
-    }
+    _isAnimatingScale = true;
 
     setModelScale(_targetScale);
     rebuildCollisionShape();
@@ -2288,8 +2261,8 @@ void MyAvatar::saveAvatarScale() {
 }
 
 void MyAvatar::clearScaleRestriction() {
-    _domainMinimumScale = MIN_AVATAR_SCALE;
-    _domainMaximumScale = MAX_AVATAR_SCALE;
+    _domainMinimumHeight = MIN_AVATAR_HEIGHT;
+    _domainMaximumHeight = MAX_AVATAR_HEIGHT;
 }
 
 void MyAvatar::goToLocation(const QVariant& propertiesVar) {
@@ -3248,6 +3221,7 @@ void MyAvatar::setModelScale(float scale) {
     if (changed) {
         float sensorToWorldScale = getEyeHeight() / getUserEyeHeight();
         emit sensorToWorldScaleChanged(sensorToWorldScale);
+        emit scaleChanged();
     }
 }
 

interface/src/avatar/MyAvatar.h

@@ -110,6 +110,10 @@ class MyAvatar : public Avatar {
      * @property userEyeHeight {number} Estimated height of the users eyes in sensor space. (meters)
      * @property SELF_ID {string} READ-ONLY. UUID representing "my avatar". Only use for local-only entities and overlays in situations where MyAvatar.sessionUUID is not available (e.g., if not connected to a domain).
      *   Note: Likely to be deprecated.
+     * @property hmdRollControlEnabled {bool} When enabled the roll angle of your HMD will turn your avatar while flying.
+     * @property hmdRollControlDeadZone {number} If hmdRollControlEnabled is true, this value can be used to tune what roll angle is required to begin turning.
+     *   This angle is specified in degrees.
+     * @property hmdRollControlRate {number} If hmdRollControlEnabled is true, this value determines the maximum turn rate of your avatar when rolling your HMD in degrees per second.
      */
 
     // FIXME: `glm::vec3 position` is not accessible from QML, so this exposes position in a QML-native type
@@ -158,7 +162,7 @@ class MyAvatar : public Avatar {
     Q_PROPERTY(float userEyeHeight READ getUserEyeHeight)
 
     Q_PROPERTY(QUuid SELF_ID READ getSelfID CONSTANT)
- 
+
     const QString DOMINANT_LEFT_HAND = "left";
     const QString DOMINANT_RIGHT_HAND = "right";
 
@@ -558,8 +562,6 @@ public slots:
     void increaseSize();
     void decreaseSize();
     void resetSize();
-    float getDomainMinScale();
-    float getDomainMaxScale();
 
     void setGravity(float gravity);
     float getGravity();
@@ -737,12 +739,12 @@ private:
     bool _clearOverlayWhenMoving { true };
     QString _dominantHand { DOMINANT_RIGHT_HAND };
 
-    const float ROLL_CONTROL_DEAD_ZONE_DEFAULT = 8.0f; // deg
-    const float ROLL_CONTROL_RATE_DEFAULT = 2.5f; // deg/sec/deg
+    const float ROLL_CONTROL_DEAD_ZONE_DEFAULT = 8.0f; // degrees
+    const float ROLL_CONTROL_RATE_DEFAULT = 114.0f; // degrees / sec
+
     bool _hmdRollControlEnabled { true };
     float _hmdRollControlDeadZone { ROLL_CONTROL_DEAD_ZONE_DEFAULT };
     float _hmdRollControlRate { ROLL_CONTROL_RATE_DEFAULT };
-    float _lastDrivenSpeed { 0.0f };
 
     // working copy -- see AvatarData for thread-safe _sensorToWorldMatrixCache, used for outward facing access
     glm::mat4 _sensorToWorldMatrix { glm::mat4() };

interface/src/commerce/QmlCommerce.cpp

@@ -83,19 +83,28 @@ void QmlCommerce::buy(const QString& assetId, int cost, const bool controlledFai
 void QmlCommerce::balance() {
     auto ledger = DependencyManager::get<Ledger>();
     auto wallet = DependencyManager::get<Wallet>();
-    ledger->balance(wallet->listPublicKeys());
+    QStringList cachedPublicKeys = wallet->listPublicKeys();
+    if (!cachedPublicKeys.isEmpty()) {
+        ledger->balance(cachedPublicKeys);
+    }
 }
 
 void QmlCommerce::inventory() {
     auto ledger = DependencyManager::get<Ledger>();
     auto wallet = DependencyManager::get<Wallet>();
-    ledger->inventory(wallet->listPublicKeys());
+    QStringList cachedPublicKeys = wallet->listPublicKeys();
+    if (!cachedPublicKeys.isEmpty()) {
+        ledger->inventory(cachedPublicKeys);
+    }
 }
 
 void QmlCommerce::history() {
     auto ledger = DependencyManager::get<Ledger>();
     auto wallet = DependencyManager::get<Wallet>();
-    ledger->history(wallet->listPublicKeys());
+    QStringList cachedPublicKeys = wallet->listPublicKeys();
+    if (!cachedPublicKeys.isEmpty()) {
+        ledger->history(cachedPublicKeys);
+    }
 }
 
 void QmlCommerce::changePassphrase(const QString& oldPassphrase, const QString& newPassphrase) {

interface/src/commerce/Wallet.cpp

@@ -321,6 +321,16 @@ Wallet::Wallet() {
     auto accountManager = DependencyManager::get<AccountManager>();
     connect(accountManager.data(), &AccountManager::usernameChanged, this, [&]() {
         getWalletStatus();
+        _publicKeys.clear();
+
+        if (_securityImage) {
+            delete _securityImage;
+        }
+        _securityImage = nullptr;
+
+        // tell the provider we got nothing
+        updateImageProvider();
+        _passphrase->clear();
     });
 }
 

interface/src/raypick/RayPick.cpp

@@ -84,18 +84,7 @@ glm::vec2 RayPick::projectOntoXYPlane(const glm::vec3& worldPos, const glm::vec3
 glm::vec2 RayPick::projectOntoOverlayXYPlane(const QUuid& overlayID, const glm::vec3& worldPos, bool unNormalized) {
     glm::vec3 position = vec3FromVariant(qApp->getOverlays().getProperty(overlayID, "position").value);
     glm::quat rotation = quatFromVariant(qApp->getOverlays().getProperty(overlayID, "rotation").value);
-    glm::vec3 dimensions;
-
-    float dpi = qApp->getOverlays().getProperty(overlayID, "dpi").value.toFloat();
-    if (dpi > 0) {
-        // Calculate physical dimensions for web3d overlay from resolution and dpi; "dimensions" property is used as a scale.
-        glm::vec3 resolution = glm::vec3(vec2FromVariant(qApp->getOverlays().getProperty(overlayID, "resolution").value), 1);
-        glm::vec3 scale = glm::vec3(vec2FromVariant(qApp->getOverlays().getProperty(overlayID, "dimensions").value), 0.01f);
-        const float INCHES_TO_METERS = 1.0f / 39.3701f;
-        dimensions = (resolution * INCHES_TO_METERS / dpi) * scale;
-    } else {
-        dimensions = glm::vec3(vec2FromVariant(qApp->getOverlays().getProperty(overlayID, "dimensions").value), 0.01);
-    }
+    glm::vec3 dimensions = glm::vec3(vec2FromVariant(qApp->getOverlays().getProperty(overlayID, "dimensions").value), 0.01f);
 
     return projectOntoXYPlane(worldPos, position, rotation, dimensions, ENTITY_ITEM_DEFAULT_REGISTRATION_POINT, unNormalized);
 }

interface/src/scripting/Audio.cpp

@@ -58,6 +58,21 @@ Audio::Audio() : _devices(_contextIsHMD) {
     enableNoiseReduction(enableNoiseReductionSetting.get());
 }
 
+bool Audio::startRecording(const QString& filepath) {
+    auto client = DependencyManager::get<AudioClient>().data();
+    return client->startRecording(filepath);
+}
+
+bool Audio::getRecording() {
+    auto client = DependencyManager::get<AudioClient>().data();
+    return client->getRecording();
+}
+
+void Audio::stopRecording() {
+    auto client = DependencyManager::get<AudioClient>().data();
+    client->stopRecording();
+}
+
 void Audio::setMuted(bool isMuted) {
     if (_isMuted != isMuted) {
         auto client = DependencyManager::get<AudioClient>().data();

interface/src/scripting/Audio.h

@@ -16,6 +16,7 @@
 #include "AudioDevices.h"
 #include "AudioEffectOptions.h"
 #include "SettingHandle.h"
+#include "AudioFileWav.h"
 
 namespace scripting {
 
@@ -55,6 +56,10 @@ public:
     Q_INVOKABLE void setReverb(bool enable);
     Q_INVOKABLE void setReverbOptions(const AudioEffectOptions* options);
 
+    Q_INVOKABLE bool startRecording(const QString& filename);
+    Q_INVOKABLE void stopRecording();
+    Q_INVOKABLE bool getRecording();
+
 signals:
     void nop();
     void mutedChanged(bool isMuted);
@@ -83,7 +88,6 @@ private:
     bool _isMuted { false };
     bool _enableNoiseReduction { true };  // Match default value of AudioClient::_isNoiseGateEnabled.
     bool _contextIsHMD { false };
-
     AudioDevices* getDevices() { return &_devices; }
     AudioDevices _devices;
 };

interface/src/scripting/WindowScriptingInterface.cpp

@@ -176,6 +176,10 @@ bool  WindowScriptingInterface::isPointOnDesktopWindow(QVariant point) {
     return offscreenUi->isPointOnDesktopWindow(point);
 }
 
+glm::vec2 WindowScriptingInterface::getDeviceSize() const {
+    return qApp->getDeviceSize();
+}
+
 /// Makes sure that the reticle is visible, use this in blocking forms that require a reticle and
 /// might be in same thread as a script that sets the reticle to invisible
 void WindowScriptingInterface::ensureReticleVisible() const {

interface/src/scripting/WindowScriptingInterface.h

@@ -12,6 +12,8 @@
 #ifndef hifi_WindowScriptingInterface_h
 #define hifi_WindowScriptingInterface_h
 
+#include <glm/glm.hpp>
+
 #include <QtCore/QObject>
 #include <QtCore/QString>
 #include <QtQuick/QQuickItem>
@@ -73,6 +75,7 @@ public slots:
     bool isPhysicsEnabled();
     bool setDisplayTexture(const QString& name);
     bool isPointOnDesktopWindow(QVariant point);
+    glm::vec2 getDeviceSize() const;
 
     int openMessageBox(QString title, QString text, int buttons, int defaultButton);
     void updateMessageBox(int id, QString title, QString text, int buttons, int defaultButton);

interface/src/ui/ApplicationOverlay.cpp

@@ -82,7 +82,6 @@ void ApplicationOverlay::renderOverlay(RenderArgs* renderArgs) {
 
         // Now render the overlay components together into a single texture
         renderDomainConnectionStatusBorder(renderArgs); // renders the connected domain line
-        renderAudioScope(renderArgs); // audio scope in the very back - NOTE: this is the debug audio scope, not the VU meter
         renderOverlays(renderArgs); // renders Scripts Overlay and AudioScope
         renderQmlUi(renderArgs); // renders a unit quad with the QML UI texture, and the text overlays from scripts
     });
@@ -118,25 +117,6 @@ void ApplicationOverlay::renderQmlUi(RenderArgs* renderArgs) {
     geometryCache->renderUnitQuad(batch, glm::vec4(1), _qmlGeometryId);
 }
 
-void ApplicationOverlay::renderAudioScope(RenderArgs* renderArgs) {
-    PROFILE_RANGE(app, __FUNCTION__);
-
-    gpu::Batch& batch = *renderArgs->_batch;
-    auto geometryCache = DependencyManager::get<GeometryCache>();
-    geometryCache->useSimpleDrawPipeline(batch);
-    auto textureCache = DependencyManager::get<TextureCache>();
-    batch.setResourceTexture(0, textureCache->getWhiteTexture());
-    int width = renderArgs->_viewport.z;
-    int height = renderArgs->_viewport.w;
-    mat4 legacyProjection = glm::ortho<float>(0, width, height, 0, ORTHO_NEAR_CLIP, ORTHO_FAR_CLIP);
-    batch.setProjectionTransform(legacyProjection);
-    batch.setModelTransform(Transform());
-    batch.resetViewTransform();
-
-    // Render the audio scope
-    DependencyManager::get<AudioScope>()->render(renderArgs, width, height);
-}
-
 void ApplicationOverlay::renderOverlays(RenderArgs* renderArgs) {
     PROFILE_RANGE(app, __FUNCTION__);
 

interface/src/ui/ApplicationOverlay.h

@@ -32,7 +32,6 @@ private:
     void renderStatsAndLogs(RenderArgs* renderArgs);
     void renderDomainConnectionStatusBorder(RenderArgs* renderArgs);
     void renderQmlUi(RenderArgs* renderArgs);
-    void renderAudioScope(RenderArgs* renderArgs);
     void renderOverlays(RenderArgs* renderArgs);
     void buildFramebufferObject();
 

interface/src/ui/overlays/ModelOverlay.cpp

@@ -35,7 +35,8 @@ ModelOverlay::ModelOverlay(const ModelOverlay* modelOverlay) :
     _modelTextures(QVariantMap()),
     _url(modelOverlay->_url),
     _updateModel(false),
-    _loadPriority(modelOverlay->getLoadPriority())
+    _scaleToFit(modelOverlay->_scaleToFit),
+    _loadPriority(modelOverlay->_loadPriority)
 {
     _model->init();
     _model->setLoadingPriority(_loadPriority);

interface/src/ui/overlays/ModelOverlay.h

@@ -75,8 +75,8 @@ private:
     QVariantMap _modelTextures;
 
     QUrl _url;
-    bool _updateModel = { false };
-    bool _scaleToFit = { false };
+    bool _updateModel { false };
+    bool _scaleToFit { false };
     float _loadPriority { 0.0f };
 
     AnimationPointer _animation;
@@ -87,7 +87,7 @@ private:
     bool _animationRunning { false };
     bool _animationLoop { false };
     float _animationFirstFrame { 0.0f };
-    float _animationLastFrame = { 0.0f };
+    float _animationLastFrame { 0.0f };
     bool _animationHold { false };
     bool _animationAllowTranslation { false };
     uint64_t _lastAnimated { 0 };

interface/src/ui/overlays/Overlays.h

@@ -305,13 +305,6 @@ public slots:
     OverlayID getKeyboardFocusOverlay();
     void setKeyboardFocusOverlay(const OverlayID& id);
 
-    void mousePressPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
-    void mouseMovePointerEvent(const OverlayID& overlayID, const PointerEvent& event);
-    void mouseReleasePointerEvent(const OverlayID& overlayID, const PointerEvent& event);
-    void hoverEnterPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
-    void hoverOverPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
-    void hoverLeavePointerEvent(const OverlayID& overlayID, const PointerEvent& event);
-
 signals:
     /**jsdoc
      * Emitted when an overlay is deleted
@@ -358,6 +351,14 @@ private:
     OverlayID _currentHoverOverOverlayID { UNKNOWN_OVERLAY_ID };
 
     RayToOverlayIntersectionResult findRayIntersectionForMouseEvent(PickRay ray);
+
+private slots:
+    void mousePressPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
+    void mouseMovePointerEvent(const OverlayID& overlayID, const PointerEvent& event);
+    void mouseReleasePointerEvent(const OverlayID& overlayID, const PointerEvent& event);
+    void hoverEnterPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
+    void hoverOverPointerEvent(const OverlayID& overlayID, const PointerEvent& event);
+    void hoverLeavePointerEvent(const OverlayID& overlayID, const PointerEvent& event);
 };
 
 #endif // hifi_Overlays_h

interface/src/ui/overlays/Shape3DOverlay.cpp

@@ -18,8 +18,9 @@
 
 QString const Shape3DOverlay::TYPE = "shape";
 
-Shape3DOverlay::Shape3DOverlay(const Shape3DOverlay* Shape3DOverlay) :
-    Volume3DOverlay(Shape3DOverlay)
+Shape3DOverlay::Shape3DOverlay(const Shape3DOverlay* shape3DOverlay) :
+    Volume3DOverlay(shape3DOverlay),
+    _shape(shape3DOverlay->_shape)
 {
 }
 

interface/src/ui/overlays/Shape3DOverlay.h

@@ -23,7 +23,7 @@ public:
     virtual QString getType() const override { return TYPE; }
 
     Shape3DOverlay() {}
-    Shape3DOverlay(const Shape3DOverlay* Shape3DOverlay);
+    Shape3DOverlay(const Shape3DOverlay* shape3DOverlay);
     
     virtual void render(RenderArgs* args) override;
     virtual const render::ShapeKey getShapeKey() override;

interface/src/ui/overlays/Volume3DOverlay.cpp

@@ -14,7 +14,8 @@
 #include <RegisteredMetaTypes.h>
 
 Volume3DOverlay::Volume3DOverlay(const Volume3DOverlay* volume3DOverlay) :
-    Base3DOverlay(volume3DOverlay)
+    Base3DOverlay(volume3DOverlay),
+    _localBoundingBox(volume3DOverlay->_localBoundingBox)
 {
 }
 

interface/src/ui/overlays/Web3DOverlay.cpp

@@ -55,17 +55,15 @@
 #include <plugins/InputConfiguration.h>
 #include "ui/Snapshot.h"
 #include "SoundCache.h"
-
 #include "raypick/PointerScriptingInterface.h"
 
-static const float DPI = 30.47f;
-static const float INCHES_TO_METERS = 1.0f / 39.3701f;
+static int MAX_WINDOW_SIZE = 4096;
 static const float METERS_TO_INCHES = 39.3701f;
 static const float OPAQUE_ALPHA_THRESHOLD = 0.99f;
 
 const QString Web3DOverlay::TYPE = "web3d";
 const QString Web3DOverlay::QML = "Web3DOverlay.qml";
-Web3DOverlay::Web3DOverlay() : _dpi(DPI) {
+Web3DOverlay::Web3DOverlay() {
     _touchDevice.setCapabilities(QTouchDevice::Position);
     _touchDevice.setType(QTouchDevice::TouchScreen);
     _touchDevice.setName("Web3DOverlayTouchDevice");
@@ -82,7 +80,6 @@ Web3DOverlay::Web3DOverlay(const Web3DOverlay* Web3DOverlay) :
     _url(Web3DOverlay->_url),
     _scriptURL(Web3DOverlay->_scriptURL),
     _dpi(Web3DOverlay->_dpi),
-    _resolution(Web3DOverlay->_resolution),
     _showKeyboardFocusHighlight(Web3DOverlay->_showKeyboardFocusHighlight)
 {
     _geometryId = DependencyManager::get<GeometryCache>()->allocateID();
@@ -154,7 +151,7 @@ void Web3DOverlay::buildWebSurface() {
             setupQmlSurface();
         }
         _webSurface->getSurfaceContext()->setContextProperty("globalPosition", vec3toVariant(getWorldPosition()));
-        _webSurface->resize(QSize(_resolution.x, _resolution.y));
+        onResizeWebSurface();
         _webSurface->resume();
     });
 
@@ -244,8 +241,16 @@ void Web3DOverlay::setMaxFPS(uint8_t maxFPS) {
 }
 
 void Web3DOverlay::onResizeWebSurface() {
-    _mayNeedResize = false;
-    _webSurface->resize(QSize(_resolution.x, _resolution.y));
+    glm::vec2 dims = glm::vec2(getDimensions());
+    dims *= METERS_TO_INCHES * _dpi;
+
+    // ensure no side is never larger then MAX_WINDOW_SIZE
+    float max = (dims.x > dims.y) ? dims.x : dims.y;
+    if (max > MAX_WINDOW_SIZE) {
+        dims *= MAX_WINDOW_SIZE / max;
+    }
+
+    _webSurface->resize(QSize(dims.x, dims.y));
 }
 
 unsigned int Web3DOverlay::deviceIdByTouchPoint(qreal x, qreal y) {
@@ -266,14 +271,14 @@ void Web3DOverlay::render(RenderArgs* args) {
         return;
     }
 
-    if (_currentMaxFPS != _desiredMaxFPS) {
-        setMaxFPS(_desiredMaxFPS);
-    }
-
     if (_mayNeedResize) {
         emit resizeWebSurface();
     }
 
+    if (_currentMaxFPS != _desiredMaxFPS) {
+        setMaxFPS(_desiredMaxFPS);
+    }
+
     vec4 color(toGlm(getColor()), getAlpha());
 
     if (!_texture) {
@@ -310,7 +315,7 @@ void Web3DOverlay::render(RenderArgs* args) {
 Transform Web3DOverlay::evalRenderTransform() {
     Transform transform = Parent::evalRenderTransform();
     transform.setScale(1.0f);
-    transform.postScale(glm::vec3(getSize(), 1.0f));
+    transform.postScale(glm::vec3(getDimensions(), 1.0f));
     return transform;
 }
 
@@ -434,18 +439,10 @@ void Web3DOverlay::setProperties(const QVariantMap& properties) {
         }
     }
 
-    auto resolution = properties["resolution"];
-    if (resolution.isValid()) {
-        bool valid;
-        auto res = vec2FromVariant(resolution, valid);
-        if (valid) {
-            _resolution = res;
-        }
-    }
-
     auto dpi = properties["dpi"];
     if (dpi.isValid()) {
         _dpi = dpi.toFloat();
+        _mayNeedResize = true;
     }
 
     auto maxFPS = properties["maxFPS"];
@@ -467,8 +464,6 @@ void Web3DOverlay::setProperties(const QVariantMap& properties) {
             _inputMode = Touch;
         }
     }
-
-    _mayNeedResize = true;
 }
 
 QVariant Web3DOverlay::getProperty(const QString& property) {
@@ -478,9 +473,6 @@ QVariant Web3DOverlay::getProperty(const QString& property) {
     if (property == "scriptURL") {
         return _scriptURL;
     }
-    if (property == "resolution") {
-        return vec2toVariant(_resolution);
-    }
     if (property == "dpi") {
         return _dpi;
     }
@@ -536,17 +528,18 @@ void Web3DOverlay::setScriptURL(const QString& scriptURL) {
     }
 }
 
-glm::vec2 Web3DOverlay::getSize() const {
-    return _resolution / _dpi * INCHES_TO_METERS * getDimensions();
-};
-
 bool Web3DOverlay::findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance, BoxFace& face, glm::vec3& surfaceNormal) {
-    // FIXME - face and surfaceNormal not being returned
+    glm::vec2 dimensions = getDimensions();
+    glm::quat rotation = getWorldOrientation();
+    glm::vec3 position = getWorldPosition();
 
-    // Don't call applyTransformTo() or setTransform() here because this code runs too frequently.
-
-    // Produce the dimensions of the overlay based on the image's aspect ratio and the overlay's scale.
-    return findRayRectangleIntersection(origin, direction, getWorldOrientation(), getWorldPosition(), getSize(), distance);
+    if (findRayRectangleIntersection(origin, direction, rotation, position, dimensions, distance)) {
+        surfaceNormal = rotation * Vectors::UNIT_Z;
+        face = glm::dot(surfaceNormal, direction) > 0 ? MIN_Z_FACE : MAX_Z_FACE;
+        return true;
+    } else {
+        return false;
+    }
 }
 
 Web3DOverlay* Web3DOverlay::createClone() const {
@@ -555,4 +548,4 @@ Web3DOverlay* Web3DOverlay::createClone() const {
 
 void Web3DOverlay::emitScriptEvent(const QVariant& message) {
     QMetaObject::invokeMethod(this, "scriptEventReceived", Q_ARG(QVariant, message));
-}
+}

interface/src/ui/overlays/Web3DOverlay.h

@@ -52,8 +52,6 @@ public:
     void setProperties(const QVariantMap& properties) override;
     QVariant getProperty(const QString& property) override;
 
-    glm::vec2 getSize() const override;
-
     virtual bool findRayIntersection(const glm::vec3& origin, const glm::vec3& direction, float& distance,
         BoxFace& face, glm::vec3& surfaceNormal) override;
 
@@ -93,10 +91,9 @@ private:
     gpu::TexturePointer _texture;
     QString _url;
     QString _scriptURL;
-    float _dpi;
-    vec2 _resolution{ 640, 480 };
+    float _dpi { 30.0f };
     int _geometryId { 0 };
-    bool _showKeyboardFocusHighlight{ true };
+    bool _showKeyboardFocusHighlight { true };
 
     QTouchDevice _touchDevice;
 

libraries/animation/src/Rig.h

@@ -231,6 +231,9 @@ public:
 
     const glm::mat4& getGeometryToRigTransform() const { return _geometryToRigTransform; }
 
+    const AnimPose& getModelOffsetPose() const { return _modelOffset; }
+    const AnimPose& getGeometryOffsetPose() const { return _geometryOffset; }
+
     void setEnableDebugDrawIKTargets(bool enableDebugDrawIKTargets) { _enableDebugDrawIKTargets = enableDebugDrawIKTargets; }
     void setEnableDebugDrawIKConstraints(bool enableDebugDrawIKConstraints) { _enableDebugDrawIKConstraints = enableDebugDrawIKConstraints; }
     void setEnableDebugDrawIKChains(bool enableDebugDrawIKChains) { _enableDebugDrawIKChains = enableDebugDrawIKChains; }

libraries/audio-client/src/AudioClient.cpp

@@ -79,6 +79,7 @@ Setting::Handle<int> staticJitterBufferFrames("staticJitterBufferFrames",
 using Mutex = std::mutex;
 using Lock = std::unique_lock<Mutex>;
 Mutex _deviceMutex;
+Mutex _recordMutex;
 
 // thread-safe
 QList<QAudioDeviceInfo> getAvailableDevices(QAudio::Mode mode) {
@@ -222,8 +223,7 @@ AudioClient::AudioClient() :
     // initialize wasapi; if getAvailableDevices is called from the CheckDevicesThread before this, it will crash
     getAvailableDevices(QAudio::AudioInput);
     getAvailableDevices(QAudio::AudioOutput);
-
-
+    
     // start a thread to detect any device changes
     _checkDevicesTimer = new QTimer(this);
     connect(_checkDevicesTimer, &QTimer::timeout, [this] {
@@ -1845,11 +1845,9 @@ qint64 AudioClient::AudioOutputIODevice::readData(char * data, qint64 maxSize) {
         qCDebug(audiostream, "Read %d samples from buffer (%d available, %d requested)", networkSamplesPopped, _receivedAudioStream.getSamplesAvailable(), samplesRequested);
         AudioRingBuffer::ConstIterator lastPopOutput = _receivedAudioStream.getLastPopOutput();
         lastPopOutput.readSamples(scratchBuffer, networkSamplesPopped);
-
         for (int i = 0; i < networkSamplesPopped; i++) {
             mixBuffer[i] = convertToFloat(scratchBuffer[i]);
         }
-
         samplesRequested = networkSamplesPopped;
     }
 
@@ -1911,6 +1909,13 @@ qint64 AudioClient::AudioOutputIODevice::readData(char * data, qint64 maxSize) {
         bytesWritten = maxSize;
     }
 
+    // send output buffer for recording
+    if (_audio->_isRecording) {
+        Lock lock(_recordMutex);
+        _audio->_audioFileWav.addRawAudioChunk(reinterpret_cast<char*>(scratchBuffer), bytesWritten);
+    }
+
+
     int bytesAudioOutputUnplayed = _audio->_audioOutput->bufferSize() - _audio->_audioOutput->bytesFree();
     float msecsAudioOutputUnplayed = bytesAudioOutputUnplayed / (float)_audio->_outputFormat.bytesForDuration(USECS_PER_MSEC);
     _audio->_stats.updateOutputMsUnplayed(msecsAudioOutputUnplayed);
@@ -1922,6 +1927,22 @@ qint64 AudioClient::AudioOutputIODevice::readData(char * data, qint64 maxSize) {
     return bytesWritten;
 }
 
+bool AudioClient::startRecording(const QString& filepath) {
+    if (!_audioFileWav.create(_outputFormat, filepath)) {
+        qDebug() << "Error creating audio file: " + filepath;
+        return false;
+    }
+    _isRecording = true;
+    return true;
+}
+
+void AudioClient::stopRecording() {
+    if (_isRecording) {
+        _isRecording = false;
+        _audioFileWav.close();
+    }
+}
+
 void AudioClient::loadSettings() {
     _receivedAudioStream.setDynamicJitterBufferEnabled(dynamicJitterBufferEnabled.get());
     _receivedAudioStream.setStaticJitterBufferFrames(staticJitterBufferFrames.get());

libraries/audio-client/src/AudioClient.h

@@ -47,11 +47,13 @@
 #include <AudioConstants.h>
 #include <AudioGate.h>
 
+
 #include <shared/RateCounter.h>
 
 #include <plugins/CodecPlugin.h>
 
 #include "AudioIOStats.h"
+#include "AudioFileWav.h"
 
 #ifdef _WIN32
 #pragma warning( push )
@@ -67,7 +69,6 @@ class QAudioInput;
 class QAudioOutput;
 class QIODevice;
 
-
 class Transform;
 class NLPacket;
 
@@ -118,6 +119,8 @@ public:
     const MixedProcessedAudioStream& getReceivedAudioStream() const { return _receivedAudioStream; }
     MixedProcessedAudioStream& getReceivedAudioStream() { return _receivedAudioStream; }
 
+    const QAudioFormat& getOutputFormat() const { return _outputFormat; }
+
     float getLastInputLoudness() const { return _lastInputLoudness; }   // TODO: relative to noise floor?
 
     float getTimeSinceLastClip() const { return _timeSinceLastClip; }
@@ -142,7 +145,7 @@ public:
     void setIsPlayingBackRecording(bool isPlayingBackRecording) { _isPlayingBackRecording = isPlayingBackRecording; }
 
     Q_INVOKABLE void setAvatarBoundingBoxParameters(glm::vec3 corner, glm::vec3 scale);
-
+    
     bool outputLocalInjector(const AudioInjectorPointer& injector) override;
 
     QAudioDeviceInfo getActiveAudioDevice(QAudio::Mode mode) const;
@@ -155,6 +158,13 @@ public:
 
     bool getNamedAudioDeviceForModeExists(QAudio::Mode mode, const QString& deviceName);
 
+    void setRecording(bool isRecording) { _isRecording = isRecording; };
+    bool getRecording() { return _isRecording; };
+
+    bool startRecording(const QString& filename);
+    void stopRecording();
+
+
 #ifdef Q_OS_WIN
     static QString getWinDeviceName(wchar_t* guid);
 #endif
@@ -184,13 +194,17 @@ public slots:
     void toggleMute();
     bool isMuted() { return _muted; }
 
-
     virtual void setIsStereoInput(bool stereo) override;
 
     void setNoiseReduction(bool isNoiseGateEnabled);
     bool isNoiseReductionEnabled() const { return _isNoiseGateEnabled; }
 
+    bool getLocalEcho() { return _shouldEchoLocally; }
+    void setLocalEcho(bool localEcho) { _shouldEchoLocally = localEcho; }
     void toggleLocalEcho() { _shouldEchoLocally = !_shouldEchoLocally; }
+
+    bool getServerEcho() { return _shouldEchoToServer; }
+    void setServerEcho(bool serverEcho) { _shouldEchoToServer = serverEcho; }
     void toggleServerEcho() { _shouldEchoToServer = !_shouldEchoToServer; }
 
     void processReceivedSamples(const QByteArray& inputBuffer, QByteArray& outputBuffer);
@@ -239,6 +253,8 @@ signals:
 
     void muteEnvironmentRequested(glm::vec3 position, float radius);
 
+    void outputBufferReceived(const QByteArray _outputBuffer);
+
 protected:
     AudioClient();
     ~AudioClient();
@@ -354,9 +370,8 @@ private:
     int16_t _localScratchBuffer[AudioConstants::NETWORK_FRAME_SAMPLES_AMBISONIC];
     float* _localOutputMixBuffer { NULL };
     Mutex _localAudioMutex;
-
     AudioLimiter _audioLimiter;
-
+    
     // Adds Reverb
     void configureReverb();
     void updateReverbOptions();
@@ -391,6 +406,8 @@ private:
     QList<QAudioDeviceInfo> _inputDevices;
     QList<QAudioDeviceInfo> _outputDevices;
 
+    AudioFileWav _audioFileWav;
+
     bool _hasReceivedFirstPacket { false };
 
     QVector<AudioInjectorPointer> _activeLocalAudioInjectors;
@@ -412,6 +429,8 @@ private:
     
     QTimer* _checkDevicesTimer { nullptr };
     QTimer* _checkPeakValuesTimer { nullptr };
+
+    bool _isRecording { false };
 };
 
 

libraries/audio-client/src/AudioFileWav.cpp

@@ -0,0 +1,69 @@
+//
+//  AudioWavFile.h
+//  libraries/audio-client/src
+//
+//  Created by Luis Cuenca on 12/1/2017.
+//  Copyright 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 "AudioFileWav.h"
+
+bool AudioFileWav::create(const QAudioFormat& audioFormat, const QString& filepath) {
+    if (_file.isOpen()) {
+        _file.close();
+    }
+    _file.setFileName(filepath);
+    if (!_file.open(QIODevice::WriteOnly)) {
+        return false;
+    }
+    addHeader(audioFormat);
+    return true;
+}
+
+bool AudioFileWav::addRawAudioChunk(char* chunk, int size) {
+    if (_file.isOpen()) {
+        QDataStream stream(&_file);
+        stream.writeRawData(chunk, size);
+        return true;
+    }
+    return false;
+}
+
+void AudioFileWav::close() {
+    QDataStream stream(&_file);
+    stream.setByteOrder(QDataStream::LittleEndian);
+
+    // fill RIFF and size data on header
+    _file.seek(4);
+    stream << quint32(_file.size() - 8);
+    _file.seek(40);
+    stream << quint32(_file.size() - 44);
+    _file.close();
+}
+
+void AudioFileWav::addHeader(const QAudioFormat& audioFormat) {
+    QDataStream stream(&_file);
+
+    stream.setByteOrder(QDataStream::LittleEndian);
+
+    // RIFF
+    stream.writeRawData("RIFF", 4);
+    stream << quint32(0);
+    stream.writeRawData("WAVE", 4);
+
+    // Format description PCM = 16
+    stream.writeRawData("fmt ", 4);
+    stream << quint32(16);
+    stream << quint16(1);
+    stream << quint16(audioFormat.channelCount());
+    stream << quint32(audioFormat.sampleRate());
+    stream << quint32(audioFormat.sampleRate() * audioFormat.channelCount() * audioFormat.sampleSize() / 8); // bytes per second
+    stream << quint16(audioFormat.channelCount() * audioFormat.sampleSize() / 8); // block align
+    stream << quint16(audioFormat.sampleSize()); // bits Per Sample
+    // Init data chunck
+    stream.writeRawData("data", 4);
+    stream << quint32(0);
+}

libraries/audio-client/src/AudioFileWav.h

@@ -0,0 +1,34 @@
+//
+//  AudioWavFile.h
+//  libraries/audio-client/src
+//
+//  Created by Luis Cuenca on 12/1/2017.
+//  Copyright 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_AudioFileWav_h
+#define hifi_AudioFileWav_h
+
+#include <QObject>
+#include <QFile>
+#include <QDataStream>
+#include <QVector>
+#include <QAudioFormat>
+
+class AudioFileWav : public QObject {
+    Q_OBJECT
+public:
+    AudioFileWav() {}
+    bool create(const QAudioFormat& audioFormat, const QString& filepath);
+    bool addRawAudioChunk(char* chunk, int size);
+    void close();
+
+private:
+    void addHeader(const QAudioFormat& audioFormat);
+    QFile _file;
+};
+
+#endif // hifi_AudioFileWav_h

libraries/avatars-renderer/src/avatars-renderer/Avatar.cpp

@@ -162,6 +162,7 @@ AABox Avatar::getBounds() const {
 }
 
 void Avatar::animateScaleChanges(float deltaTime) {
+
     if (_isAnimatingScale) {
         float currentScale = getModelScale();
         float desiredScale = getDomainLimitedScale();
@@ -172,7 +173,7 @@ void Avatar::animateScaleChanges(float deltaTime) {
         float animatedScale = (1.0f - blendFactor) * currentScale + blendFactor * desiredScale;
 
         // snap to the end when we get close enough
-        const float MIN_RELATIVE_ERROR = 0.03f;
+        const float MIN_RELATIVE_ERROR = 0.001f;
         float relativeError = fabsf(desiredScale - currentScale) / desiredScale;
         if (relativeError < MIN_RELATIVE_ERROR) {
             animatedScale = desiredScale;
@@ -698,6 +699,7 @@ void Avatar::fixupModelsInScene(const render::ScenePointer& scene) {
         _skeletonModel->removeFromScene(scene, transaction);
         _skeletonModel->addToScene(scene, transaction);
         canTryFade = true;
+        _isAnimatingScale = true;
     }
     for (auto attachmentModel : _attachmentModels) {
         if (attachmentModel->isRenderable() && attachmentModel->needsFixupInScene()) {
@@ -1195,6 +1197,8 @@ void Avatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
 void Avatar::setModelURLFinished(bool success) {
     invalidateJointIndicesCache();
 
+    _isAnimatingScale = true;
+
     if (!success && _skeletonModelURL != AvatarData::defaultFullAvatarModelUrl()) {
         const int MAX_SKELETON_DOWNLOAD_ATTEMPTS = 4; // NOTE: we don't want to be as generous as ResourceCache is, we only want 4 attempts
         if (_skeletonModel->getResourceDownloadAttemptsRemaining() <= 0 ||
@@ -1213,6 +1217,15 @@ void Avatar::setModelURLFinished(bool success) {
     }
 }
 
+// rig is ready
+void Avatar::rigReady() {
+    buildUnscaledEyeHeightCache();
+}
+
+// rig has been reset.
+void Avatar::rigReset() {
+    clearUnscaledEyeHeightCache();
+}
 
 // create new model, can return an instance of a SoftAttachmentModel rather then Model
 static std::shared_ptr<Model> allocateAttachmentModel(bool isSoft, const Rig& rigOverride, bool isCauterized) {
@@ -1580,53 +1593,91 @@ void Avatar::ensureInScene(AvatarSharedPointer self, const render::ScenePointer&
     }
 }
 
+// thread-safe
 float Avatar::getEyeHeight() const {
+    return getModelScale() * getUnscaledEyeHeight();
+}
 
-    if (QThread::currentThread() != thread()) {
-        float result = DEFAULT_AVATAR_EYE_HEIGHT;
-        BLOCKING_INVOKE_METHOD(const_cast<Avatar*>(this), "getEyeHeight", Q_RETURN_ARG(float, result));
-        return result;
+// thread-safe
+float Avatar::getUnscaledEyeHeight() const {
+    return _unscaledEyeHeightCache.get();
+}
+
+void Avatar::buildUnscaledEyeHeightCache() {
+    float skeletonHeight = getUnscaledEyeHeightFromSkeleton();
+
+    // Sanity check by looking at the model extents.
+    Extents meshExtents = _skeletonModel->getUnscaledMeshExtents();
+    float meshHeight = meshExtents.size().y;
+
+    // if we determine the mesh is much larger then the skeleton, then we use the mesh height instead.
+    // This helps prevent absurdly large avatars from exceeding the domain height limit.
+    const float MESH_SLOP_RATIO = 1.5f;
+    if (meshHeight > skeletonHeight * MESH_SLOP_RATIO) {
+        _unscaledEyeHeightCache.set(meshHeight);
+    } else {
+        _unscaledEyeHeightCache.set(skeletonHeight);
     }
+}
+
+void Avatar::clearUnscaledEyeHeightCache() {
+    _unscaledEyeHeightCache.set(DEFAULT_AVATAR_EYE_HEIGHT);
+}
+
+float Avatar::getUnscaledEyeHeightFromSkeleton() const {
 
     // TODO: if performance becomes a concern we can cache this value rather then computing it everytime.
-    // Makes assumption that the y = 0 plane in geometry is the ground plane.
-    // We also make that assumption in Rig::computeAvatarBoundingCapsule()
-    float avatarScale = getModelScale();
+
     if (_skeletonModel) {
         auto& rig = _skeletonModel->getRig();
+
+        // Normally the model offset transform will contain the avatar scale factor, we explicitly remove it here.
+        AnimPose modelOffsetWithoutAvatarScale(glm::vec3(1.0f), rig.getModelOffsetPose().rot(), rig.getModelOffsetPose().trans());
+        AnimPose geomToRigWithoutAvatarScale = modelOffsetWithoutAvatarScale * rig.getGeometryOffsetPose();
+
+        // This factor can be used to scale distances in the geometry frame into the unscaled rig frame.
+        // Typically it will be the unit conversion from cm to m.
+        float scaleFactor = geomToRigWithoutAvatarScale.scale().x;  // in practice this always a uniform scale factor.
+
         int headTopJoint = rig.indexOfJoint("HeadTop_End");
         int headJoint = rig.indexOfJoint("Head");
         int eyeJoint = rig.indexOfJoint("LeftEye") != -1 ? rig.indexOfJoint("LeftEye") : rig.indexOfJoint("RightEye");
         int toeJoint = rig.indexOfJoint("LeftToeBase") != -1 ? rig.indexOfJoint("LeftToeBase") : rig.indexOfJoint("RightToeBase");
+
+        // Makes assumption that the y = 0 plane in geometry is the ground plane.
+        // We also make that assumption in Rig::computeAvatarBoundingCapsule()
+        const float GROUND_Y = 0.0f;
+
+        // Values from the skeleton are in the geometry coordinate frame.
+        auto skeleton = rig.getAnimSkeleton();
         if (eyeJoint >= 0 && toeJoint >= 0) {
-            // measure from eyes to toes.
-            float eyeHeight = rig.getAbsoluteDefaultPose(eyeJoint).trans().y - rig.getAbsoluteDefaultPose(toeJoint).trans().y;
-            return eyeHeight;
+            // Measure from eyes to toes.
+            float eyeHeight = skeleton->getAbsoluteDefaultPose(eyeJoint).trans().y - skeleton->getAbsoluteDefaultPose(toeJoint).trans().y;
+            return scaleFactor * eyeHeight;
         } else if (eyeJoint >= 0) {
-            // measure eyes to y = 0 plane.
-            float groundHeight = transformPoint(rig.getGeometryToRigTransform(), glm::vec3(0.0f)).y;
-            float eyeHeight = rig.getAbsoluteDefaultPose(eyeJoint).trans().y - groundHeight;
-            return eyeHeight;
+            // Measure Eye joint to y = 0 plane.
+            float eyeHeight = skeleton->getAbsoluteDefaultPose(eyeJoint).trans().y - GROUND_Y;
+            return scaleFactor * eyeHeight;
         } else if (headTopJoint >= 0 && toeJoint >= 0) {
-            // measure toe to top of head.  Note: default poses already include avatar scale factor
+            // Measure from ToeBase joint to HeadTop_End joint, then remove forehead distance.
             const float ratio = DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD / DEFAULT_AVATAR_HEIGHT;
-            float height = rig.getAbsoluteDefaultPose(headTopJoint).trans().y - rig.getAbsoluteDefaultPose(toeJoint).trans().y;
-            return height - height * ratio;
+            float height = skeleton->getAbsoluteDefaultPose(headTopJoint).trans().y - skeleton->getAbsoluteDefaultPose(toeJoint).trans().y;
+            return scaleFactor * (height - height * ratio);
         } else if (headTopJoint >= 0) {
+            // Measure from HeadTop_End joint to the ground, then remove forehead distance.
             const float ratio = DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD / DEFAULT_AVATAR_HEIGHT;
-            float groundHeight = transformPoint(rig.getGeometryToRigTransform(), glm::vec3(0.0f)).y;
-            float headHeight = rig.getAbsoluteDefaultPose(headTopJoint).trans().y - groundHeight;
-            return headHeight - headHeight * ratio;
+            float headHeight = skeleton->getAbsoluteDefaultPose(headTopJoint).trans().y - GROUND_Y;
+            return scaleFactor * (headHeight - headHeight * ratio);
         } else if (headJoint >= 0) {
-            float groundHeight = transformPoint(rig.getGeometryToRigTransform(), glm::vec3(0.0f)).y;
+            // Measure Head joint to the ground, then add in distance from neck to eye.
             const float DEFAULT_AVATAR_NECK_TO_EYE = DEFAULT_AVATAR_NECK_TO_TOP_OF_HEAD - DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD;
             const float ratio = DEFAULT_AVATAR_NECK_TO_EYE / DEFAULT_AVATAR_NECK_HEIGHT;
-            float neckHeight = rig.getAbsoluteDefaultPose(headJoint).trans().y - groundHeight;
-            return neckHeight + neckHeight * ratio;
+            float neckHeight = skeleton->getAbsoluteDefaultPose(headJoint).trans().y - GROUND_Y;
+            return scaleFactor * (neckHeight + neckHeight * ratio);
         } else {
-            return avatarScale * DEFAULT_AVATAR_EYE_HEIGHT;
+            return DEFAULT_AVATAR_EYE_HEIGHT;
         }
     } else {
-        return avatarScale * DEFAULT_AVATAR_EYE_HEIGHT;
+        return DEFAULT_AVATAR_EYE_HEIGHT;
     }
 }

libraries/avatars-renderer/src/avatars-renderer/Avatar.h

@@ -255,12 +255,16 @@ public:
     bool isFading() const { return _isFading; }
     void updateFadingStatus(render::ScenePointer scene);
 
-    /**jsdoc
-     * Provides read only access to the current eye height of the avatar.
-     * @function Avatar.getEyeHeight
-     * @returns {number} eye height of avatar in meters
-     */
-    Q_INVOKABLE float getEyeHeight() const;
+    Q_INVOKABLE virtual float getEyeHeight() const override;
+
+    // returns eye height of avatar in meters, ignoring avatar scale.
+    // if _targetScale is 1 then this will be identical to getEyeHeight.
+    virtual float getUnscaledEyeHeight() const override;
+
+    // returns true, if an acurate eye height estimage can be obtained by inspecting the avatar model skeleton and geometry,
+    // not all subclasses of AvatarData have access to this data.
+    virtual bool canMeasureEyeHeight() const override { return true; }
+
 
     virtual float getModelScale() const { return _modelScale; }
     virtual void setModelScale(float scale) { _modelScale = scale; }
@@ -276,9 +280,17 @@ public slots:
     glm::vec3 getRightPalmPosition() const;
     glm::quat getRightPalmRotation() const;
 
+    // hooked up to Model::setURLFinished signal
     void setModelURLFinished(bool success);
 
+    // hooked up to Model::rigReady & rigReset signals
+    void rigReady();
+    void rigReset();
+
 protected:
+    float getUnscaledEyeHeightFromSkeleton() const;
+    void buildUnscaledEyeHeightCache();
+    void clearUnscaledEyeHeightCache();
     virtual const QString& getSessionDisplayNameForTransport() const override { return _empty; } // Save a tiny bit of bandwidth. Mixer won't look at what we send.
     QString _empty{};
     virtual void maybeUpdateSessionDisplayNameFromTransport(const QString& sessionDisplayName) override { _sessionDisplayName = sessionDisplayName; } // don't use no-op setter!
@@ -349,7 +361,7 @@ protected:
     RateCounter<> _skeletonModelSimulationRate;
     RateCounter<> _jointDataSimulationRate;
 
-private:
+protected:
     class AvatarEntityDataHash {
     public:
         AvatarEntityDataHash(uint32_t h) : hash(h) {};
@@ -379,6 +391,8 @@ private:
 
     float _displayNameTargetAlpha { 1.0f };
     float _displayNameAlpha { 1.0f };
+
+    ThreadSafeValueCache<float> _unscaledEyeHeightCache { DEFAULT_AVATAR_EYE_HEIGHT };
 };
 
 #endif // hifi_Avatar_h

libraries/avatars-renderer/src/avatars-renderer/OtherAvatar.cpp

@@ -13,4 +13,6 @@ OtherAvatar::OtherAvatar(QThread* thread) : Avatar(thread) {
     _headData = new Head(this);
     _skeletonModel = std::make_shared<SkeletonModel>(this, nullptr);
     connect(_skeletonModel.get(), &Model::setURLFinished, this, &Avatar::setModelURLFinished);
+    connect(_skeletonModel.get(), &Model::rigReady, this, &Avatar::rigReady);
+    connect(_skeletonModel.get(), &Model::rigReset, this, &Avatar::rigReset);
 }

libraries/avatars/src/AvatarData.cpp

@@ -117,6 +117,55 @@ void AvatarData::setTargetScale(float targetScale) {
     }
 }
 
+float AvatarData::getDomainLimitedScale() const {
+    if (canMeasureEyeHeight()) {
+        const float minScale = getDomainMinScale();
+        const float maxScale = getDomainMaxScale();
+        return glm::clamp(_targetScale, minScale, maxScale);
+    } else {
+        // We can't make a good estimate.
+        return _targetScale;
+    }
+}
+
+void AvatarData::setDomainMinimumHeight(float domainMinimumHeight) {
+    _domainMinimumHeight = glm::clamp(domainMinimumHeight, MIN_AVATAR_HEIGHT, MAX_AVATAR_HEIGHT);
+}
+
+void AvatarData::setDomainMaximumHeight(float domainMaximumHeight) {
+    _domainMaximumHeight = glm::clamp(domainMaximumHeight, MIN_AVATAR_HEIGHT, MAX_AVATAR_HEIGHT);
+}
+
+float AvatarData::getDomainMinScale() const {
+    float unscaledHeight = getUnscaledHeight();
+    const float EPSILON = 1.0e-4f;
+    if (unscaledHeight <= EPSILON) {
+        unscaledHeight = DEFAULT_AVATAR_HEIGHT;
+    }
+    return _domainMinimumHeight / unscaledHeight;
+}
+
+float AvatarData::getDomainMaxScale() const {
+    float unscaledHeight = getUnscaledHeight();
+    const float EPSILON = 1.0e-4f;
+    if (unscaledHeight <= EPSILON) {
+        unscaledHeight = DEFAULT_AVATAR_HEIGHT;
+    }
+    return _domainMaximumHeight / unscaledHeight;
+}
+
+float AvatarData::getUnscaledHeight() const {
+    const float eyeHeight = getUnscaledEyeHeight();
+    const float ratio = eyeHeight / DEFAULT_AVATAR_HEIGHT;
+    return eyeHeight + ratio * DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD;
+}
+
+float AvatarData::getHeight() const {
+    const float eyeHeight = getEyeHeight();
+    const float ratio = eyeHeight / DEFAULT_AVATAR_HEIGHT;
+    return eyeHeight + ratio * DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD;
+}
+
 glm::vec3 AvatarData::getHandPosition() const {
     return getWorldOrientation() * _handPosition + getWorldPosition();
 }
@@ -2387,63 +2436,10 @@ void RayToAvatarIntersectionResultFromScriptValue(const QScriptValue& object, Ra
 
 const float AvatarData::OUT_OF_VIEW_PENALTY = -10.0f;
 
-float AvatarData::_avatarSortCoefficientSize { 0.5f };
+float AvatarData::_avatarSortCoefficientSize { 1.0f };
 float AvatarData::_avatarSortCoefficientCenter { 0.25 };
 float AvatarData::_avatarSortCoefficientAge { 1.0f };
 
-void AvatarData::sortAvatars(
-        QList<AvatarSharedPointer> avatarList,
-        const ViewFrustum& cameraView,
-        std::priority_queue<AvatarPriority>& sortedAvatarsOut,
-        std::function<uint64_t(AvatarSharedPointer)> getLastUpdated,
-        std::function<float(AvatarSharedPointer)> getBoundingRadius,
-        std::function<bool(AvatarSharedPointer)> shouldIgnore) {
-
-    PROFILE_RANGE(simulation, "sort");
-    uint64_t now = usecTimestampNow();
-
-    glm::vec3 frustumCenter = cameraView.getPosition();
-    const glm::vec3& forward = cameraView.getDirection();
-    for (int32_t i = 0; i < avatarList.size(); ++i) {
-        const auto& avatar = avatarList.at(i);
-
-        if (shouldIgnore(avatar)) {
-            continue;
-        }
-
-        // priority = weighted linear combination of:
-        //   (a) apparentSize
-        //   (b) proximity to center of view
-        //   (c) time since last update
-        glm::vec3 avatarPosition = avatar->getWorldPosition();
-        glm::vec3 offset = avatarPosition - frustumCenter;
-        float distance = glm::length(offset) + 0.001f; // add 1mm to avoid divide by zero
-
-        // FIXME - AvatarData has something equivolent to this
-        float radius = getBoundingRadius(avatar);
-
-        float apparentSize = 2.0f * radius / distance;
-        float cosineAngle = glm::dot(offset, forward) / distance;
-        float age = (float)(now - getLastUpdated(avatar)) / (float)(USECS_PER_SECOND);
-
-        // NOTE: we are adding values of different units to get a single measure of "priority".
-        // Thus we multiply each component by a conversion "weight" that scales its units relative to the others.
-        // These weights are pure magic tuning and should be hard coded in the relation below,
-        // but are currently exposed for anyone who would like to explore fine tuning:
-        float priority = _avatarSortCoefficientSize * apparentSize
-            + _avatarSortCoefficientCenter * cosineAngle
-            + _avatarSortCoefficientAge * age;
-
-        // decrement priority of avatars outside keyhole
-        if (distance > cameraView.getCenterRadius()) {
-            if (!cameraView.sphereIntersectsFrustum(avatarPosition, radius)) {
-                priority += OUT_OF_VIEW_PENALTY;
-            }
-        }
-        sortedAvatarsOut.push(AvatarPriority(avatar, priority));
-    }
-}
-
 QScriptValue AvatarEntityMapToScriptValue(QScriptEngine* engine, const AvatarEntityMap& value) {
     QScriptValue obj = engine->newObject();
     for (auto entityID : value.keys()) {

libraries/avatars/src/AvatarData.h

@@ -35,6 +35,7 @@
 #include <QtScript/QScriptValueIterator>
 #include <QReadWriteLock>
 
+#include <AvatarConstants.h>
 #include <JointData.h>
 #include <NLPacket.h>
 #include <Node.h>
@@ -257,9 +258,6 @@ namespace AvatarDataPacket {
     size_t maxJointDataSize(size_t numJoints);
 }
 
-static const float MAX_AVATAR_SCALE = 1000.0f;
-static const float MIN_AVATAR_SCALE = .005f;
-
 const float MAX_AUDIO_LOUDNESS = 1000.0f; // close enough for mouth animation
 
 const int AVATAR_IDENTITY_PACKET_SEND_INTERVAL_MSECS = 1000;
@@ -484,12 +482,52 @@ public:
     //  Scale
     virtual void setTargetScale(float targetScale);
 
-    float getDomainLimitedScale() const { return glm::clamp(_targetScale, _domainMinimumScale, _domainMaximumScale); }
+    float getDomainLimitedScale() const;
 
-    void setDomainMinimumScale(float domainMinimumScale)
-        { _domainMinimumScale = glm::clamp(domainMinimumScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE); _scaleChanged = usecTimestampNow(); }
-    void setDomainMaximumScale(float domainMaximumScale)
-        { _domainMaximumScale = glm::clamp(domainMaximumScale, MIN_AVATAR_SCALE, MAX_AVATAR_SCALE); _scaleChanged = usecTimestampNow(); }
+    /**jsdoc
+     * returns the minimum scale allowed for this avatar in the current domain.
+     * This value can change as the user changes avatars or when changing domains.
+     * @function AvatarData.getDomainMinScale
+     * @returns {number} minimum scale allowed for this avatar in the current domain.
+     */
+    Q_INVOKABLE float getDomainMinScale() const;
+
+    /**jsdoc
+     * returns the maximum scale allowed for this avatar in the current domain.
+     * This value can change as the user changes avatars or when changing domains.
+     * @function AvatarData.getDomainMaxScale
+     * @returns {number} maximum scale allowed for this avatar in the current domain.
+     */
+    Q_INVOKABLE float getDomainMaxScale() const;
+
+    // returns eye height of avatar in meters, ignoreing avatar scale.
+    // if _targetScale is 1 then this will be identical to getEyeHeight;
+    virtual float getUnscaledEyeHeight() const { return DEFAULT_AVATAR_EYE_HEIGHT; }
+
+    // returns true, if an acurate eye height estimage can be obtained by inspecting the avatar model skeleton and geometry,
+    // not all subclasses of AvatarData have access to this data.
+    virtual bool canMeasureEyeHeight() const { return false; }
+
+    /**jsdoc
+     * Provides read only access to the current eye height of the avatar.
+     * This height is only an estimate and might be incorrect for avatars that are missing standard joints.
+     * @function AvatarData.getEyeHeight
+     * @returns {number} eye height of avatar in meters
+     */
+    Q_INVOKABLE virtual float getEyeHeight() const { return _targetScale * getUnscaledEyeHeight(); }
+
+    /**jsdoc
+     * Provides read only access to the current height of the avatar.
+     * This height is only an estimate and might be incorrect for avatars that are missing standard joints.
+     * @function AvatarData.getHeight
+     * @returns {number} height of avatar in meters
+     */
+    Q_INVOKABLE virtual float getHeight() const;
+
+    float getUnscaledHeight() const;
+
+    void setDomainMinimumHeight(float domainMinimumHeight);
+    void setDomainMaximumHeight(float domainMaximumHeight);
 
     //  Hand State
     Q_INVOKABLE void setHandState(char s) { _handState = s; }
@@ -629,14 +667,6 @@ public:
 
     static const float OUT_OF_VIEW_PENALTY;
 
-    static void sortAvatars(
-        QList<AvatarSharedPointer> avatarList,
-        const ViewFrustum& cameraView,
-        std::priority_queue<AvatarPriority>& sortedAvatarsOut,
-        std::function<uint64_t(AvatarSharedPointer)> getLastUpdated,
-        std::function<float(AvatarSharedPointer)> getBoundingRadius,
-        std::function<bool(AvatarSharedPointer)> shouldIgnore);
-
     // TODO: remove this HACK once we settle on optimal sort coefficients
     // These coefficients exposed for fine tuning the sort priority for transfering new _jointData to the render pipeline.
     static float _avatarSortCoefficientSize;
@@ -706,8 +736,8 @@ protected:
 
     // Body scale
     float _targetScale;
-    float _domainMinimumScale { MIN_AVATAR_SCALE };
-    float _domainMaximumScale { MAX_AVATAR_SCALE };
+    float _domainMinimumHeight { MIN_AVATAR_HEIGHT };
+    float _domainMaximumHeight { MAX_AVATAR_HEIGHT };
 
     //  Hand state (are we grabbing something or not)
     char _handState;

libraries/baking/src/FBXBaker.cpp

@@ -607,7 +607,7 @@ void FBXBaker::rewriteAndBakeSceneTextures() {
                                 return;
                             }
 
-                            if (!TextureBaker::getSupportedFormats().contains(textureFileInfo.suffix())) {
+                            if (!image::getSupportedFormats().contains(textureFileInfo.suffix())) {
                                 // this is a texture format we don't bake, skip it
                                 handleWarning(fbxTextureFileName + " is not a bakeable texture format");
                                 continue;

libraries/baking/src/TextureBaker.cpp

@@ -61,14 +61,6 @@ void TextureBaker::abort() {
     _abortProcessing.store(true);
 }
 
-const QStringList TextureBaker::getSupportedFormats() {
-    auto formats = QImageReader::supportedImageFormats();
-    QStringList stringFormats;
-    std::transform(formats.begin(), formats.end(), std::back_inserter(stringFormats),
-                   [](QByteArray& format) -> QString { return format; });
-    return stringFormats;
-}
-
 void TextureBaker::loadTexture() {
     // check if the texture is local or first needs to be downloaded
     if (_textureURL.isLocalFile()) {

libraries/baking/src/TextureBaker.h

@@ -31,8 +31,6 @@ public:
                  const QDir& outputDirectory, const QString& bakedFilename = QString(),
                  const QByteArray& textureContent = QByteArray());
 
-    static const QStringList getSupportedFormats();
-
     const QByteArray& getOriginalTexture() const { return _originalTexture; }
 
     QUrl getTextureURL() const { return _textureURL; }

libraries/display-plugins/src/display-plugins/CompositorHelper.cpp

@@ -437,9 +437,11 @@ glm::mat4 CompositorHelper::getReticleTransform(const glm::mat4& eyePose, const
         } else {
             d = glm::normalize(overlaySurfacePoint);
         }
-        reticlePosition = headPosition + (d * getReticleDepth());
+        // Our sensor to world matrix always has uniform scale
+        float sensorSpaceReticleDepth = getReticleDepth() / extractScale(_sensorToWorldMatrix).x;
+        reticlePosition = headPosition + (d * sensorSpaceReticleDepth);
         quat reticleOrientation = cancelOutRoll(glm::quat_cast(_currentDisplayPlugin->getHeadPose()));
-        vec3 reticleScale = vec3(Cursor::Manager::instance().getScale() * reticleSize * getReticleDepth());
+        vec3 reticleScale = vec3(Cursor::Manager::instance().getScale() * reticleSize * sensorSpaceReticleDepth);
         return glm::inverse(eyePose) * createMatFromScaleQuatAndPos(reticleScale, reticleOrientation, reticlePosition);
     } else {
         static const float CURSOR_PIXEL_SIZE = 32.0f;

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -1149,7 +1149,7 @@ bool ModelEntityRenderer::needsRenderUpdateFromTypedEntity(const TypedEntityPoin
     if (model && model->isLoaded()) {
         if (!entity->_dimensionsInitialized || entity->_needsInitialSimulation) {
             return true;
-        }
+       } 
 
         // Check to see if we need to update the model bounds
         if (entity->needsUpdateModelBounds()) {

libraries/entities/src/EntityItem.cpp

@@ -1605,6 +1605,48 @@ void EntityItem::setParentID(const QUuid& value) {
         if (tree && !oldParentID.isNull()) {
             tree->removeFromChildrenOfAvatars(getThisPointer());
         }
+
+        uint32_t oldParentNoBootstrapping = 0;
+        uint32_t newParentNoBootstrapping = 0;
+        if (!value.isNull() && tree) {
+            EntityItemPointer entity = tree->findEntityByEntityItemID(value);
+            if (entity) {
+                newParentNoBootstrapping = entity->getDirtyFlags() & Simulation::NO_BOOTSTRAPPING;
+            }
+        }
+
+        if (!oldParentID.isNull() && tree) {
+            EntityItemPointer entity = tree->findEntityByEntityItemID(oldParentID);
+            if (entity) {
+                oldParentNoBootstrapping = entity->getDirtyFlags() & Simulation::NO_BOOTSTRAPPING;
+            }
+        }
+
+        if (!value.isNull() && (value == Physics::getSessionUUID() || value == AVATAR_SELF_ID)) {
+            newParentNoBootstrapping |= Simulation::NO_BOOTSTRAPPING;
+        }
+
+        if ((bool)(oldParentNoBootstrapping ^ newParentNoBootstrapping)) {
+            if ((bool)(newParentNoBootstrapping & Simulation::NO_BOOTSTRAPPING)) {
+                markDirtyFlags(Simulation::NO_BOOTSTRAPPING);
+                forEachDescendant([&](SpatiallyNestablePointer object) {
+                        if (object->getNestableType() == NestableType::Entity) {
+                            EntityItemPointer entity = std::static_pointer_cast<EntityItem>(object);
+                            entity->markDirtyFlags(Simulation::DIRTY_COLLISION_GROUP | Simulation::NO_BOOTSTRAPPING);
+                        }
+                });
+            } else {
+                clearDirtyFlags(Simulation::NO_BOOTSTRAPPING);
+                forEachDescendant([&](SpatiallyNestablePointer object) {
+                        if (object->getNestableType() == NestableType::Entity) {
+                            EntityItemPointer entity = std::static_pointer_cast<EntityItem>(object);
+                            entity->markDirtyFlags(Simulation::DIRTY_COLLISION_GROUP);
+                            entity->clearDirtyFlags(Simulation::NO_BOOTSTRAPPING);
+                        }
+                });
+            }
+        }
+
         SpatiallyNestable::setParentID(value);
         // children are forced to be kinematic
         // may need to not collide with own avatar
@@ -1834,39 +1876,8 @@ void EntityItem::computeCollisionGroupAndFinalMask(int16_t& group, int16_t& mask
             }
         }
 
-        if (userMask & USER_COLLISION_GROUP_MY_AVATAR) {
-            bool iAmHoldingThis = false;
-            // if this entity is a descendant of MyAvatar, don't collide with MyAvatar.  This avoids the
-            // "bootstrapping" problem where you can shoot yourself across the room by grabbing something
-            // and holding it against your own avatar.
-            if (isChildOfMyAvatar()) {
-                iAmHoldingThis = true;
-            }
-            // also, don't bootstrap our own avatar with a hold action
-            QList<EntityDynamicPointer> holdActions = getActionsOfType(DYNAMIC_TYPE_HOLD);
-            QList<EntityDynamicPointer>::const_iterator i = holdActions.begin();
-            while (i != holdActions.end()) {
-                EntityDynamicPointer action = *i;
-                if (action->isMine()) {
-                    iAmHoldingThis = true;
-                    break;
-                }
-                i++;
-            }
-            QList<EntityDynamicPointer> farGrabActions = getActionsOfType(DYNAMIC_TYPE_FAR_GRAB);
-            i = farGrabActions.begin();
-            while (i != farGrabActions.end()) {
-                EntityDynamicPointer action = *i;
-                if (action->isMine()) {
-                    iAmHoldingThis = true;
-                    break;
-                }
-                i++;
-            }
-
-            if (iAmHoldingThis) {
-                userMask &= ~USER_COLLISION_GROUP_MY_AVATAR;
-            }
+        if ((bool)(_dirtyFlags & Simulation::NO_BOOTSTRAPPING)) {
+            userMask &= ~USER_COLLISION_GROUP_MY_AVATAR;
         }
         mask = Physics::getDefaultCollisionMask(group) & (int16_t)(userMask);
     }
@@ -1961,7 +1972,20 @@ bool EntityItem::addActionInternal(EntitySimulationPointer simulation, EntityDyn
     if (success) {
         _allActionsDataCache = newDataCache;
         _dirtyFlags |= Simulation::DIRTY_PHYSICS_ACTIVATION;
-        _dirtyFlags |= Simulation::DIRTY_COLLISION_GROUP; // may need to not collide with own avatar
+
+        auto actionType = action->getType();
+        if (actionType == DYNAMIC_TYPE_HOLD || actionType == DYNAMIC_TYPE_FAR_GRAB) {
+            if (!(bool)(_dirtyFlags & Simulation::NO_BOOTSTRAPPING)) {
+                _dirtyFlags |= Simulation::NO_BOOTSTRAPPING;
+                _dirtyFlags |= Simulation::DIRTY_COLLISION_GROUP; // may need to not collide with own avatar
+                forEachDescendant([&](SpatiallyNestablePointer child) {
+                    if (child->getNestableType() == NestableType::Entity) {
+                        EntityItemPointer entity = std::static_pointer_cast<EntityItem>(child);
+                        entity->markDirtyFlags(Simulation::NO_BOOTSTRAPPING | Simulation::DIRTY_COLLISION_GROUP);
+                    }
+                });
+            }
+        }
     } else {
         qCDebug(entities) << "EntityItem::addActionInternal -- serializeActions failed";
     }
@@ -2002,6 +2026,29 @@ bool EntityItem::removeAction(EntitySimulationPointer simulation, const QUuid& a
     return success;
 }
 
+bool EntityItem::stillHasGrabActions() const {
+    QList<EntityDynamicPointer> holdActions = getActionsOfType(DYNAMIC_TYPE_HOLD);
+    QList<EntityDynamicPointer>::const_iterator i = holdActions.begin();
+    while (i != holdActions.end()) {
+        EntityDynamicPointer action = *i;
+        if (action->isMine()) {
+            return true;
+        }
+        i++;
+    }
+    QList<EntityDynamicPointer> farGrabActions = getActionsOfType(DYNAMIC_TYPE_FAR_GRAB);
+    i = farGrabActions.begin();
+    while (i != farGrabActions.end()) {
+        EntityDynamicPointer action = *i;
+        if (action->isMine()) {
+            return true;
+        }
+        i++;
+    }
+
+    return false;
+}
+
 bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulationPointer simulation) {
     _previouslyDeletedActions.insert(actionID, usecTimestampNow());
     if (_objectActions.contains(actionID)) {
@@ -2015,7 +2062,6 @@ bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulationPoi
 
         action->setOwnerEntity(nullptr);
         action->setIsMine(false);
-        _objectActions.remove(actionID);
 
         if (simulation) {
             action->removeFromSimulation(simulation);
@@ -2024,7 +2070,23 @@ bool EntityItem::removeActionInternal(const QUuid& actionID, EntitySimulationPoi
         bool success = true;
         serializeActions(success, _allActionsDataCache);
         _dirtyFlags |= Simulation::DIRTY_PHYSICS_ACTIVATION;
-        _dirtyFlags |= Simulation::DIRTY_COLLISION_GROUP; // may need to not collide with own avatar
+        auto removedActionType = action->getType();
+        if ((removedActionType == DYNAMIC_TYPE_HOLD || removedActionType == DYNAMIC_TYPE_FAR_GRAB) && !stillHasGrabActions()) {
+            _dirtyFlags &= ~Simulation::NO_BOOTSTRAPPING;
+            _dirtyFlags |= Simulation::DIRTY_COLLISION_GROUP; // may need to not collide with own avatar
+            forEachDescendant([&](SpatiallyNestablePointer child) {
+                if (child->getNestableType() == NestableType::Entity) {
+                    EntityItemPointer entity = std::static_pointer_cast<EntityItem>(child);
+                    entity->markDirtyFlags(Simulation::DIRTY_COLLISION_GROUP);
+                    entity->clearDirtyFlags(Simulation::NO_BOOTSTRAPPING);
+                }
+            });
+        } else {
+            // NO-OP: we assume NO_BOOTSTRAPPING bits and collision group are correct
+            // because they should have been set correctly when the action was added
+            // and/or when children were linked
+        }
+        _objectActions.remove(actionID);
         setDynamicDataNeedsTransmit(true);
         return success;
     }

libraries/entities/src/EntityItem.h

@@ -470,6 +470,7 @@ protected:
     void setSimulated(bool simulated) { _simulated = simulated; }
 
     const QByteArray getDynamicDataInternal() const;
+    bool stillHasGrabActions() const;
     void setDynamicDataInternal(QByteArray dynamicData);
 
     virtual void dimensionsChanged() override;

libraries/entities/src/EntityItemProperties.cpp

@@ -2486,7 +2486,7 @@ QByteArray EntityItemProperties::getStaticCertificateJSON() const {
     ADD_STRING_PROPERTY(collisionSoundURL, CollisionSoundURL);
     ADD_STRING_PROPERTY(compoundShapeURL, CompoundShapeURL);
     ADD_INT_PROPERTY(editionNumber, EditionNumber);
-    ADD_INT_PROPERTY(instanceNumber, EntityInstanceNumber);
+    ADD_INT_PROPERTY(entityInstanceNumber, EntityInstanceNumber);
     ADD_STRING_PROPERTY(itemArtist, ItemArtist);
     ADD_STRING_PROPERTY(itemCategories, ItemCategories);
     ADD_STRING_PROPERTY(itemDescription, ItemDescription);

libraries/entities/src/SimulationFlags.h

@@ -27,6 +27,7 @@ namespace Simulation {
     const uint32_t DIRTY_PHYSICS_ACTIVATION = 0x0800; // should activate object in physics engine
     const uint32_t DIRTY_SIMULATOR_ID = 0x1000; // the simulatorID has changed
     const uint32_t DIRTY_SIMULATION_OWNERSHIP_PRIORITY = 0x2000; // our own bid priority has changed
+    const uint32_t NO_BOOTSTRAPPING = 0x4000;
 
     const uint32_t DIRTY_TRANSFORM = DIRTY_POSITION | DIRTY_ROTATION;
     const uint32_t DIRTY_VELOCITIES = DIRTY_LINEAR_VELOCITY | DIRTY_ANGULAR_VELOCITY;

libraries/image/src/image/Image.cpp

@@ -75,6 +75,14 @@ glm::uvec2 rectifyToSparseSize(const glm::uvec2& size) {
 
 namespace image {
 
+const QStringList getSupportedFormats() {
+    auto formats = QImageReader::supportedImageFormats();
+    QStringList stringFormats;
+    std::transform(formats.begin(), formats.end(), std::back_inserter(stringFormats),
+                   [](QByteArray& format) -> QString { return format; });
+    return stringFormats;
+}
+
 QImage::Format QIMAGE_HDR_FORMAT = QImage::Format_RGB30;
 
 TextureUsage::TextureLoader TextureUsage::getTextureLoaderForType(Type type, const QVariantMap& options) {

libraries/image/src/image/Image.h

@@ -80,6 +80,8 @@ gpu::TexturePointer processCubeTextureColorFromImage(const QImage& srcImage, con
 
 } // namespace TextureUsage
 
+const QStringList getSupportedFormats();
+
 bool isColorTexturesCompressionEnabled();
 bool isNormalTexturesCompressionEnabled();
 bool isGrayscaleTexturesCompressionEnabled();

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

@@ -1006,14 +1006,11 @@ NetworkTexturePointer TextureCache::getResourceTexture(QUrl resourceTextureUrl)
         if (!_spectatorCameraNetworkTexture) {
             _spectatorCameraNetworkTexture.reset(new NetworkTexture(resourceTextureUrl));
         }
-        if (_spectatorCameraFramebuffer) {
-            texture = _spectatorCameraFramebuffer->getRenderBuffer(0);
-            if (texture) {
-                texture->setSource(SPECTATOR_CAMERA_FRAME_URL.toString().toStdString());
-                _spectatorCameraNetworkTexture->setImage(texture, texture->getWidth(), texture->getHeight());
-                return _spectatorCameraNetworkTexture;
-            }
+        if (!_spectatorCameraFramebuffer) {
+            getSpectatorCameraFramebuffer(); // initialize frame buffer
         }
+        updateSpectatorCameraNetworkTexture();
+        return _spectatorCameraNetworkTexture;
     }
     // FIXME: Generalize this, DRY up this code
     if (resourceTextureUrl == HMD_PREVIEW_FRAME_URL) {
@@ -1052,7 +1049,18 @@ const gpu::FramebufferPointer& TextureCache::getSpectatorCameraFramebuffer(int w
     // If we aren't taking a screenshot, we might need to resize or create the camera buffer
     if (!_spectatorCameraFramebuffer || _spectatorCameraFramebuffer->getWidth() != width || _spectatorCameraFramebuffer->getHeight() != height) {
         _spectatorCameraFramebuffer.reset(gpu::Framebuffer::create("spectatorCamera", gpu::Element::COLOR_SRGBA_32, width, height));
+        updateSpectatorCameraNetworkTexture();
         emit spectatorCameraFramebufferReset();
     }
     return _spectatorCameraFramebuffer;
 }
+
+void TextureCache::updateSpectatorCameraNetworkTexture() {
+    if (_spectatorCameraFramebuffer && _spectatorCameraNetworkTexture) {
+        gpu::TexturePointer texture = _spectatorCameraFramebuffer->getRenderBuffer(0);
+        if (texture) {
+            texture->setSource(SPECTATOR_CAMERA_FRAME_URL.toString().toStdString());
+            _spectatorCameraNetworkTexture->setImage(texture, texture->getWidth(), texture->getHeight());
+        }
+    }
+}

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

@@ -171,6 +171,7 @@ public:
     const gpu::FramebufferPointer& getHmdPreviewFramebuffer(int width, int height);
     const gpu::FramebufferPointer& getSpectatorCameraFramebuffer();
     const gpu::FramebufferPointer& getSpectatorCameraFramebuffer(int width, int height);
+    void updateSpectatorCameraNetworkTexture();
 
     static const int DEFAULT_SPECTATOR_CAM_WIDTH { 2048 };
     static const int DEFAULT_SPECTATOR_CAM_HEIGHT { 1024 };

libraries/networking/src/UserActivityLoggerScriptingInterface.cpp

@@ -88,3 +88,56 @@ void UserActivityLoggerScriptingInterface::doLogAction(QString action, QJsonObje
                               Q_ARG(QString, action),
                               Q_ARG(QJsonObject, details));
 }
+
+void UserActivityLoggerScriptingInterface::commercePurchaseSuccess(QString marketplaceID, int cost, bool firstPurchaseOfThisItem) {
+    QJsonObject payload;
+    payload["marketplaceID"] = marketplaceID;
+    payload["cost"] = cost;
+    payload["firstPurchaseOfThisItem"] = firstPurchaseOfThisItem;
+    doLogAction("commercePurchaseSuccess", payload);
+}
+
+void UserActivityLoggerScriptingInterface::commercePurchaseFailure(QString marketplaceID, int cost, bool firstPurchaseOfThisItem, QString errorDetails) {
+    QJsonObject payload;
+    payload["marketplaceID"] = marketplaceID;
+    payload["cost"] = cost;
+    payload["firstPurchaseOfThisItem"] = firstPurchaseOfThisItem;
+    payload["errorDetails"] = errorDetails;
+    doLogAction("commercePurchaseFailure", payload);
+}
+
+void UserActivityLoggerScriptingInterface::commerceEntityRezzed(QString marketplaceID, QString source, QString type) {
+    QJsonObject payload;
+    payload["marketplaceID"] = marketplaceID;
+    payload["source"] = source;
+    payload["type"] = type;
+    doLogAction("commerceEntityRezzed", payload);
+}
+
+void UserActivityLoggerScriptingInterface::commerceWalletSetupStarted(int timestamp, QString setupAttemptID, int setupFlowVersion, QString referrer, QString currentDomain) {
+    QJsonObject payload;
+    payload["timestamp"] = timestamp;
+    payload["setupAttemptID"] = setupAttemptID;
+    payload["setupFlowVersion"] = setupFlowVersion;
+    payload["referrer"] = referrer;
+    payload["currentDomain"] = currentDomain;
+    doLogAction("commerceWalletSetupStarted", payload);
+}
+
+void UserActivityLoggerScriptingInterface::commerceWalletSetupProgress(int timestamp, QString setupAttemptID, int secondsElapsed, int currentStepNumber, QString currentStepName) {
+    QJsonObject payload;
+    payload["timestamp"] = timestamp;
+    payload["setupAttemptID"] = setupAttemptID;
+    payload["secondsElapsed"] = secondsElapsed;
+    payload["currentStepNumber"] = currentStepNumber;
+    payload["currentStepName"] = currentStepName;
+    doLogAction("commerceWalletSetupProgress", payload);
+}
+
+void UserActivityLoggerScriptingInterface::commerceWalletSetupFinished(int timestamp, QString setupAttemptID, int secondsToComplete) {
+    QJsonObject payload;
+    payload["timestamp"] = timestamp;
+    payload["setupAttemptID"] = setupAttemptID;
+    payload["secondsToComplete"] = secondsToComplete;
+    doLogAction("commerceWalletSetupFinished", payload);
+}

libraries/networking/src/UserActivityLoggerScriptingInterface.h

@@ -33,6 +33,12 @@ public:
     Q_INVOKABLE void bubbleToggled(bool newValue);
     Q_INVOKABLE void bubbleActivated();
     Q_INVOKABLE void logAction(QString action, QVariantMap details = QVariantMap{});
+    Q_INVOKABLE void commercePurchaseSuccess(QString marketplaceID, int cost, bool firstPurchaseOfThisItem);
+    Q_INVOKABLE void commercePurchaseFailure(QString marketplaceID, int cost, bool firstPurchaseOfThisItem, QString errorDetails);
+    Q_INVOKABLE void commerceEntityRezzed(QString marketplaceID, QString source, QString type);
+    Q_INVOKABLE void commerceWalletSetupStarted(int timestamp, QString setupAttemptID, int setupFlowVersion, QString referrer, QString currentDomain);
+    Q_INVOKABLE void commerceWalletSetupProgress(int timestamp, QString setupAttemptID, int secondsElapsed, int currentStepNumber, QString currentStepName);
+    Q_INVOKABLE void commerceWalletSetupFinished(int timestamp, QString setupAttemptID, int secondsToComplete);
 private:
     void doLogAction(QString action, QJsonObject details = {});
 };

libraries/networking/src/udt/PacketHeaders.cpp

@@ -74,6 +74,8 @@ PacketVersion versionForPacketType(PacketType packetType) {
             return static_cast<PacketVersion>(AudioVersion::HighDynamicRangeVolume);
         case PacketType::ICEPing:
             return static_cast<PacketVersion>(IcePingVersion::SendICEPeerID);
+        case PacketType::DomainSettings:
+            return 18;  // replace min_avatar_scale and max_avatar_scale with min_avatar_height and max_avatar_height
         default:
             return 17;
     }

libraries/physics/src/EntityMotionState.cpp

@@ -700,7 +700,7 @@ uint32_t EntityMotionState::getIncomingDirtyFlags() {
 void EntityMotionState::clearIncomingDirtyFlags() {
     assert(entityTreeIsLocked());
     if (_body && _entity) {
-        _entity->clearDirtyFlags();
+        _entity->clearDirtyFlags(DIRTY_PHYSICS_FLAGS);
     }
 }
 

libraries/render-utils/src/Model.cpp

@@ -163,7 +163,7 @@ void Model::setScale(const glm::vec3& scale) {
     _scaledToFit = false;
 }
 
-const float SCALE_CHANGE_EPSILON = 0.01f;
+const float SCALE_CHANGE_EPSILON = 0.001f;
 
 void Model::setScaleInternal(const glm::vec3& scale) {
     if (glm::distance(_scale, scale) > SCALE_CHANGE_EPSILON) {
@@ -286,6 +286,7 @@ void Model::reset() {
     if (isLoaded()) {
         const FBXGeometry& geometry = getFBXGeometry();
         _rig.reset(geometry);
+        emit rigReset();
     }
 }
 
@@ -322,6 +323,7 @@ bool Model::updateGeometry() {
             _blendedVertexBuffers.push_back(buffer);
         }
         needFullUpdate = true;
+        emit rigReady();
     }
     return needFullUpdate;
 }

libraries/render-utils/src/Model.h

@@ -204,6 +204,9 @@ public:
     /// Returns the extents of the model's mesh
     Extents getMeshExtents() const;
 
+    /// Returns the unscaled extents of the model's mesh
+    Extents getUnscaledMeshExtents() const;
+
     void setTranslation(const glm::vec3& translation);
     void setRotation(const glm::quat& rotation);
     void setTransformNoUpdateRenderItems(const Transform& transform); // temporary HACK
@@ -270,15 +273,14 @@ signals:
     void setURLFinished(bool success);
     void setCollisionModelURLFinished(bool success);
     void requestRenderUpdate();
+    void rigReady();
+    void rigReset();
 
 protected:
 
     void setBlendshapeCoefficients(const QVector<float>& coefficients) { _blendshapeCoefficients = coefficients; }
     const QVector<float>& getBlendshapeCoefficients() const { return _blendshapeCoefficients; }
 
-    /// Returns the unscaled extents of the model's mesh
-    Extents getUnscaledMeshExtents() const;
-
     /// Clear the joint states
     void clearJointState(int index);
 

libraries/render/src/render/Scene.cpp

@@ -32,23 +32,23 @@ void Transaction::removeItem(ItemID id) {
 }
 
 void Transaction::addTransitionToItem(ItemID id, Transition::Type transition, ItemID boundId) {
-    _addedTransitions.emplace_back(TransitionAdd{ id, transition, boundId });
+    _addedTransitions.emplace_back(id, transition, boundId);
 }
 
 void Transaction::removeTransitionFromItem(ItemID id) {
-    _addedTransitions.emplace_back(TransitionAdd{ id, Transition::NONE, render::Item::INVALID_ITEM_ID });
+    _addedTransitions.emplace_back(id, Transition::NONE, render::Item::INVALID_ITEM_ID);
 }
 
 void Transaction::reApplyTransitionToItem(ItemID id) {
-    _reAppliedTransitions.emplace_back(TransitionReApply{ id });
+    _reAppliedTransitions.emplace_back(id);
 }
 
 void Transaction::queryTransitionOnItem(ItemID id, TransitionQueryFunc func) {
-    _queriedTransitions.emplace_back(TransitionQuery{ id, func });
+    _queriedTransitions.emplace_back(id, func);
 }
 
 void Transaction::updateItem(ItemID id, const UpdateFunctorPointer& functor) {
-    _updatedItems.emplace_back(Update{ id, functor });
+    _updatedItems.emplace_back(id, functor);
 }
 
 void Transaction::resetSelection(const Selection& selection) {
@@ -56,28 +56,122 @@ void Transaction::resetSelection(const Selection& selection) {
 }
 
 void Transaction::resetSelectionHighlight(const std::string& selectionName, const HighlightStyle& style) {
-    _highlightResets.emplace_back(HighlightReset{ selectionName, style });
+    _highlightResets.emplace_back(selectionName, style );
 }
 
 void Transaction::removeHighlightFromSelection(const std::string& selectionName) {
     _highlightRemoves.emplace_back(selectionName);
 }
 
-void Transaction::querySelectionHighlight(const std::string& selectionName, SelectionHighlightQueryFunc func) {
-    _highlightQueries.emplace_back(HighlightQuery{ selectionName, func });
+void Transaction::querySelectionHighlight(const std::string& selectionName, const SelectionHighlightQueryFunc& func) {
+    _highlightQueries.emplace_back(selectionName, func);
+}
+
+void Transaction::reserve(const std::vector<Transaction>& transactionContainer) {
+    size_t resetItemsCount = 0;
+    size_t removedItemsCount = 0;
+    size_t updatedItemsCount = 0;
+    size_t resetSelectionsCount = 0;
+    size_t addedTransitionsCount = 0;
+    size_t queriedTransitionsCount = 0;
+    size_t reAppliedTransitionsCount = 0;
+    size_t highlightResetsCount = 0;
+    size_t highlightRemovesCount = 0;
+    size_t highlightQueriesCount = 0;
+
+    for (const auto& transaction : transactionContainer) {
+        resetItemsCount += transaction._resetItems.size();
+        removedItemsCount += transaction._removedItems.size();
+        updatedItemsCount += transaction._updatedItems.size();
+        resetSelectionsCount += transaction._resetSelections.size();
+        addedTransitionsCount += transaction._addedTransitions.size();
+        queriedTransitionsCount += transaction._queriedTransitions.size();
+        reAppliedTransitionsCount += transaction._reAppliedTransitions.size();
+        highlightResetsCount += transaction._highlightResets.size();
+        highlightRemovesCount += transaction._highlightRemoves.size();
+        highlightQueriesCount += transaction._highlightQueries.size();
+    }
+
+    _resetItems.reserve(resetItemsCount);
+    _removedItems.reserve(removedItemsCount);
+    _updatedItems.reserve(updatedItemsCount);
+    _resetSelections.reserve(resetSelectionsCount);
+    _addedTransitions.reserve(addedTransitionsCount);
+    _queriedTransitions.reserve(queriedTransitionsCount);
+    _reAppliedTransitions.reserve(reAppliedTransitionsCount);
+    _highlightResets.reserve(highlightResetsCount);
+    _highlightRemoves.reserve(highlightRemovesCount);
+    _highlightQueries.reserve(highlightQueriesCount);
+}
+
+void Transaction::merge(const std::vector<Transaction>& transactionContainer) {
+    reserve(transactionContainer);
+    for (const auto& transaction : transactionContainer) {
+        merge(transaction);
+    }
+}
+
+
+void Transaction::merge(std::vector<Transaction>&& transactionContainer) {
+    reserve(transactionContainer);
+    auto begin = std::make_move_iterator(transactionContainer.begin());
+    auto end = std::make_move_iterator(transactionContainer.end());
+    for (auto itr = begin; itr != end; ++itr) {
+        merge(*itr);
+    }
+    transactionContainer.clear();
+}
+
+
+template <typename T>
+void moveElements(T& target, T& source) {
+    target.insert(target.end(), std::make_move_iterator(source.begin()), std::make_move_iterator(source.end()));
+    source.clear();
+}
+
+template <typename T>
+void copyElements(T& target, const T& source) {
+    target.insert(target.end(), source.begin(), source.end());
+}
+
+
+void Transaction::merge(Transaction&& transaction) {
+    moveElements(_resetItems, transaction._resetItems);
+    moveElements(_removedItems, transaction._removedItems);
+    moveElements(_updatedItems, transaction._updatedItems);
+    moveElements(_resetSelections, transaction._resetSelections);
+    moveElements(_addedTransitions, transaction._addedTransitions);
+    moveElements(_queriedTransitions, transaction._queriedTransitions);
+    moveElements(_reAppliedTransitions, transaction._reAppliedTransitions);
+    moveElements(_highlightResets, transaction._highlightResets);
+    moveElements(_highlightRemoves, transaction._highlightRemoves);
+    moveElements(_highlightQueries, transaction._highlightQueries);
 }
 
 void Transaction::merge(const Transaction& transaction) {
-    _resetItems.insert(_resetItems.end(), transaction._resetItems.begin(), transaction._resetItems.end());
-    _removedItems.insert(_removedItems.end(), transaction._removedItems.begin(), transaction._removedItems.end());
-    _updatedItems.insert(_updatedItems.end(), transaction._updatedItems.begin(), transaction._updatedItems.end());
-    _resetSelections.insert(_resetSelections.end(), transaction._resetSelections.begin(), transaction._resetSelections.end());
-    _addedTransitions.insert(_addedTransitions.end(), transaction._addedTransitions.begin(), transaction._addedTransitions.end());
-    _queriedTransitions.insert(_queriedTransitions.end(), transaction._queriedTransitions.begin(), transaction._queriedTransitions.end());
-    _reAppliedTransitions.insert(_reAppliedTransitions.end(), transaction._reAppliedTransitions.begin(), transaction._reAppliedTransitions.end());
-    _highlightResets.insert(_highlightResets.end(), transaction._highlightResets.begin(), transaction._highlightResets.end());
-    _highlightRemoves.insert(_highlightRemoves.end(), transaction._highlightRemoves.begin(), transaction._highlightRemoves.end());
-    _highlightQueries.insert(_highlightQueries.end(), transaction._highlightQueries.begin(), transaction._highlightQueries.end());
+    copyElements(_resetItems, transaction._resetItems);
+    copyElements(_removedItems, transaction._removedItems);
+    copyElements(_updatedItems, transaction._updatedItems);
+    copyElements(_resetSelections, transaction._resetSelections);
+    copyElements(_addedTransitions, transaction._addedTransitions);
+    copyElements(_queriedTransitions, transaction._queriedTransitions);
+    copyElements(_reAppliedTransitions, transaction._reAppliedTransitions);
+    copyElements(_highlightResets, transaction._highlightResets);
+    copyElements(_highlightRemoves, transaction._highlightRemoves);
+    copyElements(_highlightQueries, transaction._highlightQueries);
+}
+
+void Transaction::clear() {
+    _resetItems.clear();
+    _removedItems.clear();
+    _updatedItems.clear();
+    _resetSelections.clear();
+    _addedTransitions.clear();
+    _queriedTransitions.clear();
+    _reAppliedTransitions.clear();
+    _highlightResets.clear();
+    _highlightRemoves.clear();
+    _highlightQueries.clear();
 }
 
 
@@ -102,54 +196,50 @@ bool Scene::isAllocatedID(const ItemID& id) const {
 
 /// Enqueue change batch to the scene
 void Scene::enqueueTransaction(const Transaction& transaction) {
-    _transactionQueueMutex.lock();
-    _transactionQueue.push(transaction);
-    _transactionQueueMutex.unlock();
+    std::unique_lock<std::mutex> lock(_transactionQueueMutex);
+    _transactionQueue.emplace_back(transaction);
 }
 
-void consolidateTransaction(TransactionQueue& queue, Transaction& singleBatch) {
-    while (!queue.empty()) {
-        const auto& transaction = queue.front();
-        singleBatch.merge(transaction);
-        queue.pop();
-    };
+void Scene::enqueueTransaction(Transaction&& transaction) {
+    std::unique_lock<std::mutex> lock(_transactionQueueMutex);
+    _transactionQueue.emplace_back(std::move(transaction));
 }
 
 uint32_t Scene::enqueueFrame() {
     PROFILE_RANGE(render, __FUNCTION__);
-    Transaction consolidatedTransaction;
+    TransactionQueue localTransactionQueue;
     {
         std::unique_lock<std::mutex> lock(_transactionQueueMutex);
-        consolidateTransaction(_transactionQueue, consolidatedTransaction);
+        localTransactionQueue.swap(_transactionQueue);
     }
 
-    uint32_t frameNumber = 0;
+    Transaction consolidatedTransaction;
+    consolidatedTransaction.merge(std::move(localTransactionQueue));
     {
         std::unique_lock<std::mutex> lock(_transactionFramesMutex);
         _transactionFrames.push_back(consolidatedTransaction);
-        _transactionFrameNumber++;
-        frameNumber = _transactionFrameNumber;
     }
 
-    return frameNumber;
+    return ++_transactionFrameNumber;
 }
 
  
 void Scene::processTransactionQueue() {
     PROFILE_RANGE(render, __FUNCTION__);
 
-    TransactionFrames queuedFrames;
+    static TransactionFrames queuedFrames;
     {
         // capture the queued frames and clear the queue
         std::unique_lock<std::mutex> lock(_transactionFramesMutex);
-        queuedFrames = _transactionFrames;
-        _transactionFrames.clear();
+        queuedFrames.swap(_transactionFrames);
     }
 
     // go through the queue of frames and process them
     for (auto& frame : queuedFrames) {
         processTransactionFrame(frame);
     }
+
+    queuedFrames.clear();
 }
 
 void Scene::processTransactionFrame(const Transaction& transaction) {

libraries/render/src/render/Scene.h

@@ -65,9 +65,14 @@ public:
 
     void resetSelectionHighlight(const std::string& selectionName, const HighlightStyle& style = HighlightStyle());
     void removeHighlightFromSelection(const std::string& selectionName);
-    void querySelectionHighlight(const std::string& selectionName, SelectionHighlightQueryFunc func);
+    void querySelectionHighlight(const std::string& selectionName, const SelectionHighlightQueryFunc& func);
 
+    void reserve(const std::vector<Transaction>& transactionContainer);
+    void merge(const std::vector<Transaction>& transactionContainer);
+    void merge(std::vector<Transaction>&& transactionContainer);
     void merge(const Transaction& transaction);
+    void merge(Transaction&& transaction);
+    void clear();
 
     // Checkers if there is work to do when processing the transaction
     bool touchTransactions() const { return !_resetSelections.empty(); }
@@ -107,7 +112,7 @@ protected:
     HighlightRemoves _highlightRemoves;
     HighlightQueries _highlightQueries;
 };
-typedef std::queue<Transaction> TransactionQueue;
+typedef std::vector<Transaction> TransactionQueue;
 
 
 // Scene is a container for Items
@@ -133,6 +138,9 @@ public:
     // Enqueue transaction to the scene
     void enqueueTransaction(const Transaction& transaction);
 
+    // Enqueue transaction to the scene
+    void enqueueTransaction(Transaction&& transaction);
+
     // Enqueue end of frame transactions boundary
     uint32_t enqueueFrame();
 
@@ -187,7 +195,7 @@ protected:
 
     
     std::mutex _transactionFramesMutex;
-    using TransactionFrames = std::list<Transaction>;
+    using TransactionFrames = std::vector<Transaction>;
     TransactionFrames _transactionFrames;
     uint32_t _transactionFrameNumber{ 0 };
 

libraries/shared/src/AvatarConstants.h

@@ -12,6 +12,8 @@
 #ifndef hifi_AvatarConstants_h
 #define hifi_AvatarConstants_h
 
+#include "GLMHelpers.h"
+
 // 50th Percentile Man
 const float DEFAULT_AVATAR_HEIGHT = 1.755f; // meters
 const float DEFAULT_AVATAR_EYE_TO_TOP_OF_HEAD = 0.11f; // meters
@@ -52,5 +54,10 @@ const float DEFAULT_AVATAR_JUMP_HEIGHT = (DEFAULT_AVATAR_JUMP_SPEED * DEFAULT_AV
 const float DEFAULT_AVATAR_FALL_HEIGHT = 20.0f; // meters
 const float DEFAULT_AVATAR_MIN_HOVER_HEIGHT = 2.5f; // meters
 
+static const float MAX_AVATAR_SCALE = 1000.0f;
+static const float MIN_AVATAR_SCALE = 0.005f;
+
+static const float MAX_AVATAR_HEIGHT = 1000.0f * DEFAULT_AVATAR_HEIGHT; // meters
+static const float MIN_AVATAR_HEIGHT = 0.005f * DEFAULT_AVATAR_HEIGHT; // meters
 
 #endif // hifi_AvatarConstants_h

libraries/shared/src/PathUtils.cpp

@@ -19,8 +19,14 @@
 #include <QDir>
 #include <QUrl>
 #include <QtCore/QStandardPaths>
+#include <QRegularExpression>
 #include <mutex> // std::once
 #include "shared/GlobalAppProperties.h"
+#include "SharedUtil.h"
+
+// Format: AppName-PID-Timestamp
+// Example: ...
+QString TEMP_DIR_FORMAT { "%1-%2-%3" };
 
 const QString& PathUtils::resourcesPath() {
 #ifdef Q_OS_MAC
@@ -60,7 +66,8 @@ QString PathUtils::generateTemporaryDir() {
     QString appName = qApp->applicationName();
     for (auto i = 0; i < 64; ++i) {
         auto now = std::chrono::system_clock::now().time_since_epoch().count();
-        QDir tempDir = rootTempDir.filePath(appName + "-" + QString::number(now));
+        auto dirName = TEMP_DIR_FORMAT.arg(appName).arg(qApp->applicationPid()).arg(now);
+        QDir tempDir = rootTempDir.filePath(dirName);
         if (tempDir.mkpath(".")) {
             return tempDir.absolutePath();
         }
@@ -68,6 +75,39 @@ QString PathUtils::generateTemporaryDir() {
     return "";
 }
 
+// Delete all temporary directories for an application
+int PathUtils::removeTemporaryApplicationDirs(QString appName) {
+    if (appName.isNull()) {
+        appName = qApp->applicationName();
+    }
+
+    auto dirName = TEMP_DIR_FORMAT.arg(appName).arg("*").arg("*");
+
+    QDir rootTempDir = QDir::tempPath();
+    auto dirs = rootTempDir.entryInfoList({ dirName }, QDir::Dirs);
+    int removed = 0;
+    for (auto& dir : dirs) {
+        auto dirName = dir.fileName();
+        auto absoluteDirPath = QDir(dir.absoluteFilePath());
+        QRegularExpression re { "^" + QRegularExpression::escape(appName) + "\\-(?<pid>\\d+)\\-(?<timestamp>\\d+)$" };
+
+        auto match = re.match(dirName);
+        if (match.hasMatch()) {
+            auto pid = match.capturedRef("pid").toLongLong();
+            auto timestamp = match.capturedRef("timestamp");
+            if (!processIsRunning(pid)) {
+                qDebug() << "  Removing old temporary directory: " << dir.absoluteFilePath();
+                absoluteDirPath.removeRecursively();
+                removed++;
+            } else {
+                qDebug() << "  Not removing (process is running): " << dir.absoluteFilePath();
+            }
+        }
+    }
+
+    return removed;
+}
+
 QString fileNameWithoutExtension(const QString& fileName, const QVector<QString> possibleExtensions) {
     QString fileNameLowered = fileName.toLower();
     foreach (const QString possibleExtension, possibleExtensions) {

libraries/shared/src/PathUtils.h

@@ -39,6 +39,8 @@ public:
 
     static QString generateTemporaryDir();
 
+    static int removeTemporaryApplicationDirs(QString appName = QString::null);
+
     static Qt::CaseSensitivity getFSCaseSensitivity();
     static QString stripFilename(const QUrl& url);
     // note: this is FS-case-sensitive version of parentURL.isParentOf(childURL)

libraries/shared/src/PrioritySortUtil.h

@@ -12,6 +12,9 @@
 #define hifi_PrioritySortUtil_h
 
 #include <glm/glm.hpp>
+#include <queue>
+
+#include "NumericalConstants.h"
 #include "ViewFrustum.h"
 
 /*   PrioritySortUtil is a helper for sorting 3D things relative to a ViewFrustum.  To use:
@@ -32,11 +35,10 @@
 
 (2) Make a PrioritySortUtil::PriorityQueue<Thing> and add them to the queue:
 
-    PrioritySortUtil::Prioritizer prioritizer(viewFrustum);
+    PrioritySortUtil::PriorityQueue<SortableWrapper> sortedThings(viewFrustum);
     std::priority_queue< PrioritySortUtil::Sortable<Thing> > sortedThings;
     for (thing in things) {
-        float priority = prioritizer.computePriority(PrioritySortUtil::PrioritizableThing(thing));
-        sortedThings.push(PrioritySortUtil::Sortable<Thing> entry(thing, priority));
+        sortedThings.push(SortableWrapper(thing));
     }
 
 (3) Loop over your priority queue and do timeboxed work:
@@ -65,6 +67,7 @@ namespace PrioritySortUtil {
         virtual uint64_t getTimestamp() const = 0;
 
         void setPriority(float priority) { _priority = priority; }
+        float getPriority() const { return _priority; }
         bool operator<(const Sortable& other) const { return _priority < other._priority; }
     private:
         float _priority { 0.0f };
@@ -109,11 +112,19 @@ namespace PrioritySortUtil {
             glm::vec3 position = thing.getPosition();
             glm::vec3 offset = position - _view.getPosition();
             float distance = glm::length(offset) + 0.001f; // add 1mm to avoid divide by zero
-            float radius = thing.getRadius();
+            const float MIN_RADIUS = 0.1f; // WORKAROUND for zero size objects (we still want them to sort by distance)
+            float radius = glm::min(thing.getRadius(), MIN_RADIUS);
+            float cosineAngle = (glm::dot(offset, _view.getDirection()) / distance);
+            float age = (float)(usecTimestampNow() - thing.getTimestamp());
 
-            float priority = _angularWeight * (radius / distance)
-                + _centerWeight * (glm::dot(offset, _view.getDirection()) / distance)
-                + _ageWeight * (float)(usecTimestampNow() - thing.getTimestamp());
+            // we modulatate "age" drift rate by the cosineAngle term to make periphrial objects sort forward
+            // at a reduced rate but we don't want the "age" term to go zero or negative so we clamp it
+            const float MIN_COSINE_ANGLE_FACTOR = 0.1f;
+            float cosineAngleFactor = glm::max(cosineAngle, MIN_COSINE_ANGLE_FACTOR);
+
+            float priority = _angularWeight * glm::max(radius, MIN_RADIUS) / distance
+                + _centerWeight * cosineAngle
+                + _ageWeight * cosineAngleFactor * age;
 
             // decrement priority of things outside keyhole
             if (distance - radius > _view.getCenterRadius()) {

libraries/shared/src/SharedUtil.cpp

@@ -44,6 +44,12 @@ extern "C" FILE * __cdecl __iob_func(void) {
 #include <CoreFoundation/CoreFoundation.h>
 #endif
 
+
+#if defined(Q_OS_LINUX) || defined(Q_OS_MAC)
+#include <signal.h>
+#include <cerrno>
+#endif
+
 #include <QtCore/QDebug>
 #include <QDateTime>
 #include <QElapsedTimer>
@@ -1078,6 +1084,24 @@ void setMaxCores(uint8_t maxCores) {
 #endif
 }
 
+bool processIsRunning(int64_t pid) {
+#ifdef Q_OS_WIN
+    HANDLE process = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
+    if (process) {
+        DWORD exitCode;
+        if (GetExitCodeProcess(process, &exitCode) != 0) {
+            return exitCode == STILL_ACTIVE;
+        }
+    }
+    return false;
+#else
+    if (kill(pid, 0) == -1) {
+        return errno != ESRCH;
+    }
+    return true;
+#endif
+}
+
 void quitWithParentProcess() {
     if (qApp) {
         qDebug() << "Parent process died, quitting";

libraries/shared/src/SharedUtil.h

@@ -238,6 +238,8 @@ void setMaxCores(uint8_t maxCores);
 const QString PARENT_PID_OPTION = "parent-pid";
 void watchParentProcess(int parentPID);
 
+bool processIsRunning(int64_t pid);
+
 
 #ifdef Q_OS_WIN
 void* createProcessGroup();

libraries/ui/src/ui/OffscreenQmlSurface.cpp

@@ -121,63 +121,58 @@ uint64_t uvec2ToUint64(const uvec2& v) {
 class AudioHandler : public QObject, QRunnable {
     Q_OBJECT
 public:
-    AudioHandler(QObject* container, const QString& deviceName, int runDelayMs = 0, QObject* parent = nullptr) : QObject(parent) {
-        _container = container;
+    AudioHandler(QSharedPointer<OffscreenQmlSurface> surface, const QString& deviceName, QObject* parent = nullptr) : QObject(parent) {
         _newTargetDevice = deviceName;
-        _runDelayMs = runDelayMs;
+        _surface = surface;
         setAutoDelete(true);
-        QThreadPool::globalInstance()->start(this);
+        if (deviceName.size() > 0) {
+            QThreadPool::globalInstance()->start(this);
+        }
     }
     virtual ~AudioHandler() {
         qDebug() << "Audio Handler Destroyed";
     }
     void run() override {
-        if (_newTargetDevice.isEmpty()) {
-            return;
-        }
-        if (_runDelayMs > 0) {
-            QThread::msleep(_runDelayMs);
-        }
-        auto audioIO = DependencyManager::get<AudioClient>();
-        QString deviceName = audioIO->getActiveAudioDevice(QAudio::AudioOutput).deviceName();
-        for (auto player : _container->findChildren<QMediaPlayer*>()) {
-            auto mediaState = player->state();
-            QMediaService *svc = player->service();
-            if (nullptr == svc) {
-                return;
-            }
-            QAudioOutputSelectorControl *out = qobject_cast<QAudioOutputSelectorControl *>
-                (svc->requestControl(QAudioOutputSelectorControl_iid));
-            if (nullptr == out) {
-                return;
-            }
-            QString deviceOuput;
-            auto outputs = out->availableOutputs();
-            for (int i = 0; i < outputs.size(); i++) {
-                QString output = outputs[i];
-                QString description = out->outputDescription(output);
-                if (description == deviceName) {
-                    deviceOuput = output;
-                    break;
+        if (!_surface.isNull() && _surface->getRootItem() && !_surface->getCleaned()) {
+            for (auto player : _surface->getRootItem()->findChildren<QMediaPlayer*>()) {
+                auto mediaState = player->state();
+                QMediaService *svc = player->service();
+                if (nullptr == svc) {
+                    return;
+                }
+                QAudioOutputSelectorControl *out = qobject_cast<QAudioOutputSelectorControl *>
+                    (svc->requestControl(QAudioOutputSelectorControl_iid));
+                if (nullptr == out) {
+                    return;
+                }
+                QString deviceOuput;
+                auto outputs = out->availableOutputs();
+                for (int i = 0; i < outputs.size(); i++) {
+                    QString output = outputs[i];
+                    QString description = out->outputDescription(output);
+                    if (description == _newTargetDevice) {
+                        deviceOuput = output;
+                        break;
+                    }
+                }
+                out->setActiveOutput(deviceOuput);
+                svc->releaseControl(out);
+                // if multimedia was paused, it will start playing automatically after changing audio device
+                // this will reset it back to a paused state
+                if (mediaState == QMediaPlayer::State::PausedState) {
+                    player->pause();
+                }
+                else if (mediaState == QMediaPlayer::State::StoppedState) {
+                    player->stop();
                 }
             }
-            out->setActiveOutput(deviceOuput);
-            svc->releaseControl(out);
-            // if multimedia was paused, it will start playing automatically after changing audio device
-            // this will reset it back to a paused state
-            if (mediaState == QMediaPlayer::State::PausedState) {
-                player->pause();
-            } else if (mediaState == QMediaPlayer::State::StoppedState) {
-                player->stop();
-            }
         }
-        qDebug() << "QML Audio changed to " << deviceName;
+        qDebug() << "QML Audio changed to " << _newTargetDevice;
     }
 
 private:
     QString _newTargetDevice;
-    QObject* _container;
-    int _runDelayMs;
+    QSharedPointer<OffscreenQmlSurface> _surface;
 };
 
 class OffscreenTextures {
@@ -502,6 +497,7 @@ QOpenGLContext* OffscreenQmlSurface::getSharedContext() {
 }
 
 void OffscreenQmlSurface::cleanup() {
+    _isCleaned = true;
     _canvas->makeCurrent();
 
     _renderControl->invalidate();
@@ -600,6 +596,7 @@ OffscreenQmlSurface::OffscreenQmlSurface() {
 
 OffscreenQmlSurface::~OffscreenQmlSurface() {
     QObject::disconnect(&_updateTimer);
+    disconnectAudioOutputTimer();
     QObject::disconnect(qApp);
 
     cleanup();
@@ -613,6 +610,15 @@ OffscreenQmlSurface::~OffscreenQmlSurface() {
 void OffscreenQmlSurface::onAboutToQuit() {
     _paused = true;
     QObject::disconnect(&_updateTimer);
+    disconnectAudioOutputTimer();
+    
+}
+
+void OffscreenQmlSurface::disconnectAudioOutputTimer() {
+    if (_audioOutputUpdateTimer.isActive()) {
+        _audioOutputUpdateTimer.stop();
+    }
+    QObject::disconnect(&_audioOutputUpdateTimer);
 }
 
 void OffscreenQmlSurface::create() {
@@ -671,6 +677,14 @@ void OffscreenQmlSurface::create() {
         }
     });
 
+    // Setup the update of the QML media components with the current audio output device
+    QObject::connect(&_audioOutputUpdateTimer, &QTimer::timeout, this, [this]() {
+        new AudioHandler(sharedFromThis(), _currentAudioOutputDevice);
+    });
+    int waitForAudioQmlMs = 200;
+    _audioOutputUpdateTimer.setInterval(waitForAudioQmlMs);
+    _audioOutputUpdateTimer.setSingleShot(true);
+
     // When Quick says there is a need to render, we will not render immediately. Instead,
     // a timer with a small interval is used to get better performance.
     QObject::connect(&_updateTimer, &QTimer::timeout, this, &OffscreenQmlSurface::updateQuick);
@@ -699,10 +713,11 @@ void OffscreenQmlSurface::forceQmlAudioOutputDeviceUpdate() {
         QMetaObject::invokeMethod(this, "forceQmlAudioOutputDeviceUpdate", Qt::QueuedConnection);
     } else {
         auto audioIO = DependencyManager::get<AudioClient>();
-        QString deviceName = audioIO->getActiveAudioDevice(QAudio::AudioOutput).deviceName();
-        int waitForAudioQmlMs = 500;
-        // The audio device need to be change using oth
-        new AudioHandler(_rootItem, deviceName, waitForAudioQmlMs);        
+        _currentAudioOutputDevice = audioIO->getActiveAudioDevice(QAudio::AudioOutput).deviceName();
+        if (_audioOutputUpdateTimer.isActive()) {
+            _audioOutputUpdateTimer.stop();
+        }
+        _audioOutputUpdateTimer.start();
     }
 }
 
@@ -1134,6 +1149,7 @@ bool OffscreenQmlSurface::handlePointerEvent(const PointerEvent& event, class QT
         touchEvent.setTarget(_rootItem);
         touchEvent.setTouchPoints(touchPoints);
         touchEvent.setTouchPointStates(touchPointStates);
+        touchEvent.setTimestamp((ulong)QDateTime::currentMSecsSinceEpoch());
         touchEvent.ignore();
     }
 

libraries/ui/src/ui/OffscreenQmlSurface.h

@@ -40,7 +40,7 @@ class QQuickItem;
 
 using QmlContextCallback = std::function<void(QQmlContext*, QObject*)>;
 
-class OffscreenQmlSurface : public QObject {
+class OffscreenQmlSurface : public QObject, public QEnableSharedFromThis<OffscreenQmlSurface> {
     Q_OBJECT
     Q_PROPERTY(bool focusText READ isFocusText NOTIFY focusTextChanged)
 public:
@@ -75,6 +75,7 @@ public:
     void pause();
     void resume();
     bool isPaused() const;
+    bool getCleaned() { return _isCleaned; }
 
     void setBaseUrl(const QUrl& baseUrl);
     QQuickItem* getRootItem();
@@ -116,6 +117,7 @@ public slots:
     void changeAudioOutputDevice(const QString& deviceName, bool isHtmlUpdate = false);
     void forceHtmlAudioOutputDeviceUpdate();
     void forceQmlAudioOutputDeviceUpdate();
+
 signals:
     void audioOutputDeviceChanged(const QString& deviceName);
 
@@ -147,6 +149,7 @@ private:
     void render();
     void cleanup();
     QJsonObject getGLContextData();
+    void disconnectAudioOutputTimer();
 
 private slots:
     void updateQuick();
@@ -170,6 +173,9 @@ private:
     uint64_t _lastRenderTime { 0 };
     uvec2 _size;
 
+    QTimer _audioOutputUpdateTimer;
+    QString _currentAudioOutputDevice;
+
     // Texture management
     TextureAndFence _latestTextureAndFence { 0, 0 };
 
@@ -177,6 +183,7 @@ private:
     bool _polish { true };
     bool _paused { true };
     bool _focusText { false };
+    bool _isCleaned{ false };
     uint8_t _maxFps { 60 };
     MouseTranslator _mouseTranslator { [](const QPointF& p) { return p.toPoint();  } };
     QWindow* _proxyWindow { nullptr };

scripts/developer/utilities/audio/audioScope.js

@@ -0,0 +1,17 @@
+var qml = Script.resourcesPath() + '/qml/AudioScope.qml';
+var window = new OverlayWindow({
+    title: 'Audio Scope',
+    source: qml,
+    width: 1200,
+    height: 500
+});
+window.closed.connect(function () { 
+	if (Audio.getRecording()) {
+		Audio.stopRecording();
+	}
+	AudioScope.setVisible(false);
+	AudioScope.setLocalEcho(false);
+	AudioScope.setServerEcho(false);
+	AudioScope.selectAudioScopeFiveFrames();
+	Script.stop(); 
+});

scripts/system/controllers/controllerDispatcher.js

@@ -376,6 +376,7 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
             if (PROFILE) {
                 Script.endProfileRange("dispatch.run");
             }
+            Script.setTimeout(_this.update, BASIC_TIMER_INTERVAL_MS);
         };
 
         this.setBlacklist = function() {
@@ -470,7 +471,6 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
         };
 
         this.cleanup = function () {
-            Script.update.disconnect(_this.update);
             Controller.disableMapping(MAPPING_NAME);
             _this.pointerManager.removePointers();
             Pointers.removePointer(this.mouseRayPick);
@@ -501,5 +501,5 @@ Script.include("/~/system/libraries/controllerDispatcherUtils.js");
     Messages.subscribe('Hifi-Hand-RayPick-Blacklist');
     Messages.messageReceived.connect(controllerDispatcher.handleHandMessage);
     Script.scriptEnding.connect(controllerDispatcher.cleanup);
-    Script.update.connect(controllerDispatcher.update);
+    Script.setTimeout(controllerDispatcher.update, BASIC_TIMER_INTERVAL_MS);
 }());

scripts/system/controllers/controllerModules/equipEntity.js

@@ -10,7 +10,7 @@
    getControllerJointIndex, enableDispatcherModule, disableDispatcherModule,
    Messages, makeDispatcherModuleParameters, makeRunningValues, Settings, entityHasActions,
    Vec3, Overlays, flatten, Xform, getControllerWorldLocation, ensureDynamic, entityIsCloneable,
-   cloneEntity, DISPATCHER_PROPERTIES
+   cloneEntity, DISPATCHER_PROPERTIES, TEAR_AWAY_DISTANCE
 */
 
 Script.include("/~/system/libraries/Xform.js");
@@ -138,9 +138,9 @@ EquipHotspotBuddy.prototype.update = function(deltaTime, timestamp, controllerDa
 
                 var dimensions;
                 if (overlayInfoSet.type === "sphere") {
-                    dimensions = overlayInfoSet.hotspot.radius * 2 * overlayInfoSet.currentSize * EQUIP_SPHERE_SCALE_FACTOR;
+                    dimensions = (overlayInfoSet.hotspot.radius / 2) *  overlayInfoSet.currentSize * EQUIP_SPHERE_SCALE_FACTOR;
                 } else {
-                    dimensions = overlayInfoSet.hotspot.radius * 2 * overlayInfoSet.currentSize;
+                    dimensions = (overlayInfoSet.hotspot.radius / 2) * overlayInfoSet.currentSize;
                 }
 
                 overlayInfoSet.overlays.forEach(function(overlay) {
@@ -162,7 +162,7 @@ EquipHotspotBuddy.prototype.update = function(deltaTime, timestamp, controllerDa
 
     var ATTACH_POINT_SETTINGS = "io.highfidelity.attachPoints";
 
-    var EQUIP_RADIUS = 0.2; // radius used for palm vs equip-hotspot for equipping.
+    var EQUIP_RADIUS = 1.0; // radius used for palm vs equip-hotspot for equipping.
 
     var HAPTIC_PULSE_STRENGTH = 1.0;
     var HAPTIC_PULSE_DURATION = 13.0;
@@ -322,7 +322,9 @@ EquipHotspotBuddy.prototype.update = function(deltaTime, timestamp, controllerDa
                 }
             } else {
                 var wearableProps = getWearableData(props);
+                var sensorToScaleFactor = MyAvatar.sensorToWorldScale;
                 if (wearableProps && wearableProps.joints) {
+
                     result.push({
                         key: entityID.toString() + "0",
                         entityID: entityID,
@@ -332,7 +334,7 @@ EquipHotspotBuddy.prototype.update = function(deltaTime, timestamp, controllerDa
                             z: 0
                         },
                         worldPosition: entityXform.pos,
-                        radius: EQUIP_RADIUS,
+                        radius: EQUIP_RADIUS * sensorToScaleFactor,
                         joints: wearableProps.joints,
                         modelURL: null,
                         modelScale: null

scripts/system/controllers/controllerModules/hudOverlayPointer.js

@@ -62,7 +62,7 @@
 
         this.pointingAtTablet = function(controllerData) {
             var rayPick = controllerData.rayPicks[this.hand];
-            return (rayPick.objectID === HMD.tabletScreenID || rayPick.objectID === HMD.homeButtonID);
+            return (HMD.tabletScreenID && HMD.homeButtonID && (rayPick.objectID === HMD.tabletScreenID || rayPick.objectID === HMD.homeButtonID));
         };
 
         this.getOtherModule = function() {

scripts/system/controllers/controllerModules/nearParentGrabEntity.js

@@ -81,7 +81,8 @@ Script.include("/~/system/libraries/cloneEntityUtils.js");
         };
 
         this.otherHandIsParent = function(props) {
-            return this.getOtherModule().thisHandIsParent(props);
+            var otherModule = this.getOtherModule();
+            return (otherModule.thisHandIsParent(props) && otherModule.grabbing);
         };
 
         this.startNearParentingGrabEntity = function (controllerData, targetProps) {

scripts/system/controllers/controllerModules/scaleAvatar.js

@@ -12,6 +12,10 @@
 (function () {
     var dispatcherUtils = Script.require("/~/system/libraries/controllerDispatcherUtils.js");
 
+    function clamp(val, min, max) {
+        return Math.max(min, Math.min(max, val));
+    }
+
     function ScaleAvatar(hand) {
         this.hand = hand;
         this.scalingStartAvatarScale = 0;
@@ -61,7 +65,7 @@
                             controllerData.controllerLocations[this.otherHand()].position));
 
                     var newAvatarScale = (scalingCurrentDistance / this.scalingStartDistance) * this.scalingStartAvatarScale;
-                    MyAvatar.scale = newAvatarScale;
+                    MyAvatar.scale = clamp(newAvatarScale, MyAvatar.getDomainMinScale(), MyAvatar.getDomainMaxScale());
                     MyAvatar.scaleChanged();
                 }
                 return dispatcherUtils.makeRunningValues(true, [], []);

scripts/system/directory.js

@@ -63,7 +63,7 @@ var toolBar = (function() {
             y: -TOOLBAR_MARGIN_Y - toolHeight
         });
         browseDirectoryButton = toolBar.addTool({
-            imageURL: toolIconUrl + "directory-01.svg",
+            imageURL: toolIconUrl + "directory.svg",
             subImage: {
                 x: 0,
                 y: Tool.IMAGE_WIDTH,

scripts/system/html/css/edit-style.css

@@ -1415,6 +1415,9 @@ input#reset-to-natural-dimensions {
 }
 
 /* -----   Order of Menu items for Primitive   ----- */
+/* Entity Menu classes are specified by selected entity
+    within entityProperties.js
+*/
 #properties-list.ShapeMenu #general,
 #properties-list.BoxMenu #general,
 #properties-list.SphereMenu #general {
@@ -1469,6 +1472,34 @@ input#reset-to-natural-dimensions {
     display: none;
 }
 
+/* -----   ParticleEffectMenu   ----- */
+#properties-list.ParticleEffectMenu #general {
+    order: 1;
+}
+#properties-list.ParticleEffectMenu #collision-info {
+    order: 2;
+}
+#properties-list.ParticleEffectMenu #physical {
+    order: 3;
+}
+#properties-list.ParticleEffectMenu #spatial {
+    order: 4;
+}
+#properties-list.ParticleEffectMenu #behavior {
+    order: 5;
+}
+
+/* items to hide    */
+#properties-list.ParticleEffectMenu #base-color-section,
+#properties-list.ParticleEffectMenu #hyperlink,
+#properties-list.ParticleEffectMenu #light,
+#properties-list.ParticleEffectMenu #model,
+#properties-list.ParticleEffectMenu #shape-list,
+#properties-list.ParticleEffectMenu #text,
+#properties-list.ParticleEffectMenu #web,
+#properties-list.ParticleEffectMenu #zone {
+    display: none;
+}
 
 /* -----   Order of Menu items for Light   ----- */
 #properties-list.LightMenu #general {
@@ -1500,8 +1531,8 @@ input#reset-to-natural-dimensions {
     display: none;
 }
 /* items to hide */
-#properties-list.LightMenu .shape-group.shape-section.property.dropdown,
-#properties-list.LightMenu color-section.color-control1 {
+#properties-list.LightMenu #shape-list,
+#properties-list.LightMenu #base-color-section {
     display: none
 }
 
@@ -1536,8 +1567,8 @@ input#reset-to-natural-dimensions {
     display: none;
 }
 /* items to hide */
-#properties-list.ModelMenu .shape-group.shape-section.property.dropdown,
-#properties-list.ModelMenu .color-section.color-control1 {
+#properties-list.ModelMenu #shape-list,
+#properties-list.ModelMenu #base-color-section {
     display: none
 }
 
@@ -1572,8 +1603,8 @@ input#reset-to-natural-dimensions {
     display: none;
 }
 /* items to hide */
-#properties-list.ZoneMenu .shape-group.shape-section.property.dropdown,
-#properties-list.ZoneMenu .color-section.color-control1 {
+#properties-list.ZoneMenu #shape-list,
+#properties-list.ZoneMenu #base-color-section {
     display: none
 }
 
@@ -1608,8 +1639,8 @@ input#reset-to-natural-dimensions {
     display: none;
 }
 /* items to hide */
-#properties-list.WebMenu .shape-group.shape-section.property.dropdown,
-#properties-list.WebMenu .color-section.color-control1 {
+#properties-list.WebMenu #shape-list,
+#properties-list.WebMenu #base-color-section {
     display: none;
 }
 
@@ -1645,8 +1676,8 @@ input#reset-to-natural-dimensions {
     display: none;
 }
 /* items to hide */
-#properties-list.TextMenu .shape-group.shape-section.property.dropdown,
-#properties-list.TextMenu .color-section.color-control1 {
+#properties-list.TextMenu #shape-list,
+#properties-list.TextMenu #base-color-section {
     display: none
 }