Merge branch 'master' into 21396

assignment-client/src/Agent.cpp

@@ -23,6 +23,7 @@
 #include <AvatarHashMap.h>
 #include <AudioInjectorManager.h>
 #include <AssetClient.h>
+#include <LocationScriptingInterface.h>
 #include <MessagesClient.h>
 #include <NetworkAccessManager.h>
 #include <NodeList.h>
@@ -453,6 +454,9 @@ void Agent::executeScript() {
 
     _scriptEngine->registerGlobalObject("EntityViewer", &_entityViewer);
 
+    _scriptEngine->registerGetterSetter("location", LocationScriptingInterface::locationGetter,
+        LocationScriptingInterface::locationSetter);
+
     auto recordingInterface = DependencyManager::get<RecordingScriptingInterface>();
     _scriptEngine->registerGlobalObject("Recording", recordingInterface.data());
 

assignment-client/src/Agent.h

@@ -23,7 +23,6 @@
 
 #include <EntityEditPacketSender.h>
 #include <EntityTree.h>
-#include <EntityTreeHeadlessViewer.h>
 #include <ScriptEngine.h>
 #include <ThreadedAssignment.h>
 
@@ -31,6 +30,7 @@
 
 #include "AudioGate.h"
 #include "MixedAudioStream.h"
+#include "entities/EntityTreeHeadlessViewer.h"
 #include "avatars/ScriptableAvatar.h"
 
 class Agent : public ThreadedAssignment {

assignment-client/src/AssignmentClientApp.cpp

@@ -186,6 +186,10 @@ AssignmentClientApp::AssignmentClientApp(int argc, char* argv[]) :
         listenPort = argumentVariantMap.value(ASSIGNMENT_CLIENT_LISTEN_PORT_OPTION).toUInt();
     }
 
+    if (parser.isSet(portOption)) {
+        listenPort = parser.value(portOption).toUInt();
+    }
+
     if (parser.isSet(numChildsOption)) {
         if (minForks && minForks > numForks) {
             qCritical() << "--min can't be more than -n";

assignment-client/src/audio/AudioMixer.cpp

@@ -55,7 +55,8 @@ QVector<AudioMixer::ZoneSettings> AudioMixer::_zoneSettings;
 QVector<AudioMixer::ReverbSettings> AudioMixer::_zoneReverbSettings;
 
 AudioMixer::AudioMixer(ReceivedMessage& message) :
-    ThreadedAssignment(message) {
+    ThreadedAssignment(message)
+{
 
     // Always clear settings first
     // This prevents previous assignment settings from sticking around
@@ -92,7 +93,21 @@ AudioMixer::AudioMixer(ReceivedMessage& message) :
     packetReceiver.registerListener(PacketType::NodeMuteRequest, this, "handleNodeMuteRequestPacket");
     packetReceiver.registerListener(PacketType::KillAvatar, this, "handleKillAvatarPacket");
 
+    packetReceiver.registerListenerForTypes({
+        PacketType::ReplicatedMicrophoneAudioNoEcho,
+        PacketType::ReplicatedMicrophoneAudioWithEcho,
+        PacketType::ReplicatedInjectAudio,
+        PacketType::ReplicatedSilentAudioFrame
+    },
+        this, "queueReplicatedAudioPacket"
+    );
+
     connect(nodeList.data(), &NodeList::nodeKilled, this, &AudioMixer::handleNodeKilled);
+    connect(nodeList.data(), &NodeList::nodeAdded, this, [this](const SharedNodePointer& node) {
+        if (node->getType() == NodeType::DownstreamAudioMixer) {
+            node->activatePublicSocket();
+        }
+    });
 }
 
 void AudioMixer::queueAudioPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer node) {
@@ -103,6 +118,33 @@ void AudioMixer::queueAudioPacket(QSharedPointer<ReceivedMessage> message, Share
     getOrCreateClientData(node.data())->queuePacket(message, node);
 }
 
+void AudioMixer::queueReplicatedAudioPacket(QSharedPointer<ReceivedMessage> message) {
+    // make sure we have a replicated node for the original sender of the packet
+    auto nodeList = DependencyManager::get<NodeList>();
+
+    QUuid nodeID =  QUuid::fromRfc4122(message->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
+
+    auto replicatedNode = nodeList->addOrUpdateNode(nodeID, NodeType::Agent,
+                                                    message->getSenderSockAddr(), message->getSenderSockAddr(),
+                                                    true, true);
+    replicatedNode->setLastHeardMicrostamp(usecTimestampNow());
+
+    // construct a "fake" audio received message from the byte array and packet list information
+    auto audioData = message->getMessage().mid(NUM_BYTES_RFC4122_UUID);
+
+    PacketType rewrittenType = REPLICATED_PACKET_MAPPING.key(message->getType());
+
+    if (rewrittenType == PacketType::Unknown) {
+        qDebug() << "Cannot unwrap replicated packet type not present in REPLICATED_PACKET_WRAPPING";
+    }
+
+    auto replicatedMessage = QSharedPointer<ReceivedMessage>::create(audioData, rewrittenType,
+                                                                     versionForPacketType(rewrittenType),
+                                                                     message->getSenderSockAddr(), nodeID);
+
+    getOrCreateClientData(replicatedNode.data())->queuePacket(replicatedMessage, replicatedNode);
+}
+
 void AudioMixer::handleMuteEnvironmentPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
     auto nodeList = DependencyManager::get<NodeList>();
 
@@ -347,7 +389,7 @@ void AudioMixer::start() {
     auto nodeList = DependencyManager::get<NodeList>();
 
     // prepare the NodeList
-    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::EntityScriptServer });
+    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::DownstreamAudioMixer, NodeType::EntityScriptServer });
     nodeList->linkedDataCreateCallback = [&](Node* node) { getOrCreateClientData(node); };
 
     // parse out any AudioMixer settings
@@ -506,7 +548,7 @@ void AudioMixer::clearDomainSettings() {
     _zoneReverbSettings.clear();
 }
 
-void AudioMixer::parseSettingsObject(const QJsonObject &settingsObject) {
+void AudioMixer::parseSettingsObject(const QJsonObject& settingsObject) {
     qDebug() << "AVX2 Support:" << (cpuSupportsAVX2() ? "enabled" : "disabled");
 
     if (settingsObject.contains(AUDIO_THREADING_GROUP_KEY)) {

assignment-client/src/audio/AudioMixer.h

@@ -63,6 +63,7 @@ private slots:
     void handleKillAvatarPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode);
 
     void queueAudioPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode);
+    void queueReplicatedAudioPacket(QSharedPointer<ReceivedMessage> packet);
     void removeHRTFsForFinishedInjector(const QUuid& streamID);
     void start();
 

assignment-client/src/audio/AudioMixerClientData.cpp

@@ -68,9 +68,21 @@ void AudioMixerClientData::processPackets() {
             case PacketType::MicrophoneAudioWithEcho:
             case PacketType::InjectAudio:
             case PacketType::AudioStreamStats:
-            case PacketType::SilentAudioFrame: {
+            case PacketType::SilentAudioFrame:
+            case PacketType::ReplicatedMicrophoneAudioNoEcho:
+            case PacketType::ReplicatedMicrophoneAudioWithEcho:
+            case PacketType::ReplicatedInjectAudio:
+            case PacketType::ReplicatedSilentAudioFrame: {
+
+                if (node->isUpstream() && !_hasSetupCodecForUpstreamNode) {
+                    setupCodecForReplicatedAgent(packet);
+                }
+
                 QMutexLocker lock(&getMutex());
                 parseData(*packet);
+                
+                optionallyReplicatePacket(*packet, *node);
+
                 break;
             }
             case PacketType::NegotiateAudioFormat:
@@ -97,6 +109,59 @@ void AudioMixerClientData::processPackets() {
     assert(_packetQueue.empty());
 }
 
+bool isReplicatedPacket(PacketType packetType) {
+    return packetType == PacketType::ReplicatedMicrophoneAudioNoEcho
+        || packetType == PacketType::ReplicatedMicrophoneAudioWithEcho
+        || packetType == PacketType::ReplicatedInjectAudio
+        || packetType == PacketType::ReplicatedSilentAudioFrame;
+}
+
+void AudioMixerClientData::optionallyReplicatePacket(ReceivedMessage& message, const Node& node) {
+
+    // first, make sure that this is a packet from a node we are supposed to replicate
+    if (node.isReplicated()) {
+
+        // now make sure it's a packet type that we want to replicate
+
+        // first check if it is an original type that we should replicate
+        PacketType mirroredType = REPLICATED_PACKET_MAPPING.value(message.getType());
+
+        if (mirroredType == PacketType::Unknown) {
+            // if it wasn't check if it is a replicated type that we should re-replicate
+            if (REPLICATED_PACKET_MAPPING.key(message.getType()) != PacketType::Unknown) {
+                mirroredType = message.getType();
+            } else {
+                qDebug() << "Packet passed to optionallyReplicatePacket was not a replicatable type - returning";
+                return;
+            }
+        }
+
+        std::unique_ptr<NLPacket> packet;
+        auto nodeList = DependencyManager::get<NodeList>();
+
+        // enumerate the downstream audio mixers and send them the replicated version of this packet
+        nodeList->unsafeEachNode([&](const SharedNodePointer& downstreamNode) {
+            if (downstreamNode->getType() == NodeType::DownstreamAudioMixer) {
+                // construct the packet only once, if we have any downstream audio mixers to send to
+                if (!packet) {
+                    // construct an NLPacket to send to the replicant that has the contents of the received packet
+                    packet = NLPacket::create(mirroredType);
+
+                    if (!isReplicatedPacket(message.getType())) {
+                        // since this packet will be non-sourced, we add the replicated node's ID here
+                        packet->write(node.getUUID().toRfc4122());
+                    }
+
+                    packet->write(message.getMessage());
+                }
+                
+                nodeList->sendUnreliablePacket(*packet, *downstreamNode);
+            }
+        });
+    }
+
+}
+
 void AudioMixerClientData::negotiateAudioFormat(ReceivedMessage& message, const SharedNodePointer& node) {
     quint8 numberOfCodecs;
     message.readPrimitive(&numberOfCodecs);
@@ -188,8 +253,11 @@ int AudioMixerClientData::parseData(ReceivedMessage& message) {
         bool isMicStream = false;
 
         if (packetType == PacketType::MicrophoneAudioWithEcho
+            || packetType == PacketType::ReplicatedMicrophoneAudioWithEcho
             || packetType == PacketType::MicrophoneAudioNoEcho
-            || packetType == PacketType::SilentAudioFrame) {
+            || packetType == PacketType::ReplicatedMicrophoneAudioNoEcho
+            || packetType == PacketType::SilentAudioFrame
+            || packetType == PacketType::ReplicatedSilentAudioFrame) {
 
             QWriteLocker writeLocker { &_streamsLock };
 
@@ -209,7 +277,8 @@ int AudioMixerClientData::parseData(ReceivedMessage& message) {
                 avatarAudioStream->setupCodec(_codec, _selectedCodecName, AudioConstants::MONO);
                 qDebug() << "creating new AvatarAudioStream... codec:" << _selectedCodecName;
 
-                connect(avatarAudioStream, &InboundAudioStream::mismatchedAudioCodec, this, &AudioMixerClientData::handleMismatchAudioFormat);
+                connect(avatarAudioStream, &InboundAudioStream::mismatchedAudioCodec,
+                        this, &AudioMixerClientData::handleMismatchAudioFormat);
 
                 auto emplaced = _audioStreams.emplace(
                     QUuid(),
@@ -224,10 +293,12 @@ int AudioMixerClientData::parseData(ReceivedMessage& message) {
             writeLocker.unlock();
 
             isMicStream = true;
-        } else if (packetType == PacketType::InjectAudio) {
+        } else if (packetType == PacketType::InjectAudio
+                   || packetType == PacketType::ReplicatedInjectAudio) {
             // this is injected audio
             // grab the stream identifier for this injected audio
             message.seek(sizeof(quint16));
+
             QUuid streamIdentifier = QUuid::fromRfc4122(message.readWithoutCopy(NUM_BYTES_RFC4122_UUID));
 
             bool isStereo;
@@ -608,3 +679,22 @@ bool AudioMixerClientData::shouldIgnore(const SharedNodePointer self, const Shar
 
     return shouldIgnore;
 }
+
+void AudioMixerClientData::setupCodecForReplicatedAgent(QSharedPointer<ReceivedMessage> message) {
+    // hop past the sequence number that leads the packet
+    message->seek(sizeof(quint16));
+
+    // pull the codec string from the packet
+    auto codecString = message->readString();
+
+    qDebug() << "Manually setting codec for replicated agent" << uuidStringWithoutCurlyBraces(getNodeID())
+        << "-" << codecString;
+
+    const std::pair<QString, CodecPluginPointer> codec = AudioMixer::negotiateCodec({ codecString });
+    setupCodec(codec.second, codec.first);
+
+    _hasSetupCodecForUpstreamNode = true;
+
+    // seek back to the beginning of the message so other readers are in the right place
+    message->seek(0);
+}

assignment-client/src/audio/AudioMixerClientData.h

@@ -26,7 +26,6 @@
 #include "PositionalAudioStream.h"
 #include "AvatarAudioStream.h"
 
-
 class AudioMixerClientData : public NodeData {
     Q_OBJECT
 public:
@@ -108,6 +107,8 @@ public:
     bool getRequestsDomainListData() { return _requestsDomainListData; }
     void setRequestsDomainListData(bool requesting) { _requestsDomainListData = requesting; }
 
+    void setupCodecForReplicatedAgent(QSharedPointer<ReceivedMessage> message);
+
 signals:
     void injectorStreamFinished(const QUuid& streamIdentifier);
 
@@ -124,6 +125,8 @@ private:
     QReadWriteLock _streamsLock;
     AudioStreamMap _audioStreams; // microphone stream from avatar is stored under key of null UUID
 
+    void optionallyReplicatePacket(ReceivedMessage& packet, const Node& node);
+
     using IgnoreZone = AABox;
     class IgnoreZoneMemo {
     public:
@@ -181,6 +184,8 @@ private:
 
     bool _shouldMuteClient { false };
     bool _requestsDomainListData { false };
+
+    bool _hasSetupCodecForUpstreamNode { false };
 };
 
 #endif // hifi_AudioMixerClientData_h

assignment-client/src/audio/AudioMixerSlave.cpp

@@ -74,6 +74,10 @@ void AudioMixerSlave::mix(const SharedNodePointer& node) {
         return;
     }
 
+    if (node->isUpstream()) {
+        return;
+    }
+
     // check that the stream is valid
     auto avatarStream = data->getAvatarAudioStream();
     if (avatarStream == nullptr) {

assignment-client/src/avatars/AvatarMixer.cpp

@@ -54,8 +54,108 @@ AvatarMixer::AvatarMixer(ReceivedMessage& message) :
     packetReceiver.registerListener(PacketType::RadiusIgnoreRequest, this, "handleRadiusIgnoreRequestPacket");
     packetReceiver.registerListener(PacketType::RequestsDomainListData, this, "handleRequestsDomainListDataPacket");
 
+    packetReceiver.registerListenerForTypes({
+        PacketType::ReplicatedAvatarIdentity,
+        PacketType::ReplicatedKillAvatar
+    }, this, "handleReplicatedPacket");
+
+    packetReceiver.registerListener(PacketType::ReplicatedBulkAvatarData, this, "handleReplicatedBulkAvatarPacket");
+
     auto nodeList = DependencyManager::get<NodeList>();
     connect(nodeList.data(), &NodeList::packetVersionMismatch, this, &AvatarMixer::handlePacketVersionMismatch);
+    connect(nodeList.data(), &NodeList::nodeAdded, this, [this](const SharedNodePointer& node) {
+        if (node->getType() == NodeType::DownstreamAvatarMixer) {
+            getOrCreateClientData(node);
+            node->activatePublicSocket();
+        }
+    });
+}
+
+SharedNodePointer addOrUpdateReplicatedNode(const QUuid& nodeID, const HifiSockAddr& senderSockAddr) {
+    auto replicatedNode = DependencyManager::get<NodeList>()->addOrUpdateNode(nodeID, NodeType::Agent,
+                                                                              senderSockAddr,
+                                                                              senderSockAddr,
+                                                                              true, true);
+
+    replicatedNode->setLastHeardMicrostamp(usecTimestampNow());
+
+    return replicatedNode;
+}
+
+void AvatarMixer::handleReplicatedPacket(QSharedPointer<ReceivedMessage> message) {
+    auto nodeList = DependencyManager::get<NodeList>();
+    auto nodeID = QUuid::fromRfc4122(message->peek(NUM_BYTES_RFC4122_UUID));
+
+    auto replicatedNode = addOrUpdateReplicatedNode(nodeID, message->getSenderSockAddr());
+
+    if (message->getType() == PacketType::ReplicatedAvatarIdentity) {
+        handleAvatarIdentityPacket(message, replicatedNode);
+    } else if (message->getType() == PacketType::ReplicatedKillAvatar) {
+        handleKillAvatarPacket(message, replicatedNode);
+    }
+}
+
+void AvatarMixer::handleReplicatedBulkAvatarPacket(QSharedPointer<ReceivedMessage> message) {
+    while (message->getBytesLeftToRead()) {
+        // first, grab the node ID for this replicated avatar
+        auto nodeID = QUuid::fromRfc4122(message->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
+
+        // make sure we have an upstream replicated node that matches
+        auto replicatedNode = addOrUpdateReplicatedNode(nodeID, message->getSenderSockAddr());
+
+        // grab the size of the avatar byte array so we know how much to read
+        quint16 avatarByteArraySize;
+        message->readPrimitive(&avatarByteArraySize);
+
+        // read the avatar byte array
+        auto avatarByteArray = message->read(avatarByteArraySize);
+
+        // construct a "fake" avatar data received message from the byte array and packet list information
+        auto replicatedMessage = QSharedPointer<ReceivedMessage>::create(avatarByteArray, PacketType::AvatarData,
+                                                                         versionForPacketType(PacketType::AvatarData),
+                                                                         message->getSenderSockAddr(), nodeID);
+
+        // queue up the replicated avatar data with the client data for the replicated node
+        auto start = usecTimestampNow();
+        getOrCreateClientData(replicatedNode)->queuePacket(replicatedMessage, replicatedNode);
+        auto end = usecTimestampNow();
+        _queueIncomingPacketElapsedTime += (end - start);
+    }
+}
+
+void AvatarMixer::optionallyReplicatePacket(ReceivedMessage& message, const Node& node) {
+    // first, make sure that this is a packet from a node we are supposed to replicate
+    if (node.isReplicated()) {
+
+        // check if this is a packet type we replicate
+        // which means it must be a packet type present in REPLICATED_PACKET_MAPPING or must be the
+        // replicated version of one of those packet types
+        PacketType replicatedType = REPLICATED_PACKET_MAPPING.value(message.getType());
+
+        if (replicatedType == PacketType::Unknown) {
+            if (REPLICATED_PACKET_MAPPING.key(message.getType()) != PacketType::Unknown) {
+                replicatedType = message.getType();
+            } else {
+                qDebug() << __FUNCTION__ << "called without replicatable packet type - returning";
+                return;
+            }
+        }
+
+        std::unique_ptr<NLPacket> packet;
+
+        auto nodeList = DependencyManager::get<NodeList>();
+        nodeList->eachMatchingNode([&](const SharedNodePointer& node) {
+            return node->getType() == NodeType::DownstreamAvatarMixer;
+        }, [&](const SharedNodePointer& node) {
+            if (!packet) {
+                // construct an NLPacket to send to the replicant that has the contents of the received packet
+                packet = NLPacket::create(replicatedType, message.getSize());
+                packet->write(message.getMessage());
+            }
+
+            nodeList->sendUnreliablePacket(*packet, *node);
+        });
+    }
 }
 
 void AvatarMixer::queueIncomingPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer node) {
@@ -70,12 +170,14 @@ AvatarMixer::~AvatarMixer() {
 }
 
 void AvatarMixer::sendIdentityPacket(AvatarMixerClientData* nodeData, const SharedNodePointer& destinationNode) {
-    QByteArray individualData = nodeData->getAvatar().identityByteArray();
-    individualData.replace(0, NUM_BYTES_RFC4122_UUID, nodeData->getNodeID().toRfc4122());
-    auto identityPackets = NLPacketList::create(PacketType::AvatarIdentity, QByteArray(), true, true);
-    identityPackets->write(individualData);
-    DependencyManager::get<NodeList>()->sendPacketList(std::move(identityPackets), *destinationNode);
-    ++_sumIdentityPackets;
+    if (destinationNode->getType() == NodeType::Agent && !destinationNode->isUpstream()) {
+        QByteArray individualData = nodeData->getAvatar().identityByteArray();
+        individualData.replace(0, NUM_BYTES_RFC4122_UUID, nodeData->getNodeID().toRfc4122());
+        auto identityPackets = NLPacketList::create(PacketType::AvatarIdentity, QByteArray(), true, true);
+        identityPackets->write(individualData);
+        DependencyManager::get<NodeList>()->sendPacketList(std::move(identityPackets), *destinationNode);
+        ++_sumIdentityPackets;
+    }
 }
 
 std::chrono::microseconds AvatarMixer::timeFrame(p_high_resolution_clock::time_point& timestamp) {
@@ -132,7 +234,10 @@ void AvatarMixer::start() {
             auto start = usecTimestampNow();
             nodeList->nestedEach([&](NodeList::const_iterator cbegin, NodeList::const_iterator cend) {
                 std::for_each(cbegin, cend, [&](const SharedNodePointer& node) {
-                    manageDisplayName(node);
+                    if (node->getType() == NodeType::Agent && !node->isUpstream()) {
+                        manageIdentityData(node);
+                    }
+
                     ++_sumListeners;
                 });
             }, &lockWait, &nodeTransform, &functor);
@@ -183,8 +288,9 @@ void AvatarMixer::start() {
 
 // NOTE: nodeData->getAvatar() might be side effected, must be called when access to node/nodeData
 // is guaranteed to not be accessed by other thread
-void AvatarMixer::manageDisplayName(const SharedNodePointer& node) {
+void AvatarMixer::manageIdentityData(const SharedNodePointer& node) {
     AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData());
+    bool sendIdentity = false;
     if (nodeData && nodeData->getAvatarSessionDisplayNameMustChange()) {
         AvatarData& avatar = nodeData->getAvatar();
         const QString& existingBaseDisplayName = nodeData->getBaseDisplayName();
@@ -210,9 +316,39 @@ void AvatarMixer::manageDisplayName(const SharedNodePointer& node) {
         soFar.second++; // refcount
         nodeData->flagIdentityChange();
         nodeData->setAvatarSessionDisplayNameMustChange(false);
-        sendIdentityPacket(nodeData, node); // Tell node whose name changed about its new session display name.
+        sendIdentity = true;
         qCDebug(avatars) << "Giving session display name" << sessionDisplayName << "to node with ID" << node->getUUID();
     }
+    if (nodeData && nodeData->getAvatarSkeletonModelUrlMustChange()) { // never true for an empty _avatarWhitelist
+        nodeData->setAvatarSkeletonModelUrlMustChange(false);
+        AvatarData& avatar = nodeData->getAvatar();
+        static const QUrl emptyURL("");
+        QUrl url = avatar.cannonicalSkeletonModelURL(emptyURL);
+        if (!isAvatarInWhitelist(url)) {
+            qCDebug(avatars) << "Forbidden avatar" << nodeData->getNodeID() << avatar.getSkeletonModelURL() << "replaced with" << (_replacementAvatar.isEmpty() ? "default" : _replacementAvatar);
+            avatar.setSkeletonModelURL(_replacementAvatar);
+            sendIdentity = true;
+        }
+    }
+    if (sendIdentity) {
+        sendIdentityPacket(nodeData, node); // Tell node whose name changed about its new session display name or avatar.
+    }
+}
+
+bool AvatarMixer::isAvatarInWhitelist(const QUrl& url) {
+    // The avatar is in the whitelist if:
+    // 1. The avatar's URL's host matches one of the hosts of the URLs in the whitelist AND
+    // 2. The avatar's URL's path starts with the path of that same URL in the whitelist
+    for (const auto& whiteListedPrefix : _avatarWhitelist) {
+        auto whiteListURL = QUrl::fromUserInput(whiteListedPrefix);
+        // check if this script URL matches the whitelist domain and, optionally, is beneath the path
+        if (url.host().compare(whiteListURL.host(), Qt::CaseInsensitive) == 0 &&
+            url.path().startsWith(whiteListURL.path(), Qt::CaseInsensitive)) {
+            return true;
+        }
+    }
+
+    return false;
 }
 
 void AvatarMixer::throttle(std::chrono::microseconds duration, int frame) {
@@ -279,13 +415,38 @@ void AvatarMixer::nodeKilled(SharedNodePointer killedNode) {
            }
         }
 
+        std::unique_ptr<NLPacket> killPacket;
+        std::unique_ptr<NLPacket> replicatedKillPacket;
+
         // this was an avatar we were sending to other people
         // send a kill packet for it to our other nodes
-        auto killPacket = NLPacket::create(PacketType::KillAvatar, NUM_BYTES_RFC4122_UUID + sizeof(KillAvatarReason));
-        killPacket->write(killedNode->getUUID().toRfc4122());
-        killPacket->writePrimitive(KillAvatarReason::AvatarDisconnected);
+        nodeList->eachMatchingNode([&](const SharedNodePointer& node) {
+            // we relay avatar kill packets to agents that are not upstream
+            // and downstream avatar mixers, if the node that was just killed was being replicated
+            return (node->getType() == NodeType::Agent && !node->isUpstream())
+                || (killedNode->isReplicated() && node->getType() == NodeType::DownstreamAvatarMixer);
+        }, [&](const SharedNodePointer& node) {
+            if (node->getType() == NodeType::Agent) {
+                if (!killPacket) {
+                    killPacket = NLPacket::create(PacketType::KillAvatar, NUM_BYTES_RFC4122_UUID + sizeof(KillAvatarReason));
+                    killPacket->write(killedNode->getUUID().toRfc4122());
+                    killPacket->writePrimitive(KillAvatarReason::AvatarDisconnected);
+                }
+
+                nodeList->sendUnreliablePacket(*killPacket, *node);
+            } else {
+                // send a replicated kill packet to the downstream avatar mixer
+                if (!replicatedKillPacket) {
+                    replicatedKillPacket = NLPacket::create(PacketType::ReplicatedKillAvatar,
+                                                  NUM_BYTES_RFC4122_UUID + sizeof(KillAvatarReason));
+                    replicatedKillPacket->write(killedNode->getUUID().toRfc4122());
+                    replicatedKillPacket->writePrimitive(KillAvatarReason::AvatarDisconnected);
+                }
+
+                nodeList->sendUnreliablePacket(*replicatedKillPacket, *node);
+            }
+        });
 
-        nodeList->broadcastToNodes(std::move(killPacket), NodeSet() << NodeType::Agent);
 
         // we also want to remove sequence number data for this avatar on our other avatars
         // so invoke the appropriate method on the AvatarMixerClientData for other avatars
@@ -398,17 +559,20 @@ void AvatarMixer::handleAvatarIdentityPacket(QSharedPointer<ReceivedMessage> mes
             AvatarData& avatar = nodeData->getAvatar();
 
             // parse the identity packet and update the change timestamp if appropriate
-            AvatarData::Identity identity;
-            AvatarData::parseAvatarIdentityPacket(message->getMessage(), identity);
             bool identityChanged = false;
             bool displayNameChanged = false;
-            avatar.processAvatarIdentity(identity, identityChanged, displayNameChanged);
+            bool skeletonModelUrlChanged = false;
+            avatar.processAvatarIdentity(message->getMessage(), identityChanged, displayNameChanged, skeletonModelUrlChanged);
+
             if (identityChanged) {
                 QMutexLocker nodeDataLocker(&nodeData->getMutex());
                 nodeData->flagIdentityChange();
                 if (displayNameChanged) {
                     nodeData->setAvatarSessionDisplayNameMustChange(true);
                 }
+                if (skeletonModelUrlChanged && !_avatarWhitelist.isEmpty()) {
+                    nodeData->setAvatarSkeletonModelUrlMustChange(true);
+                }
             }
         }
     }
@@ -416,11 +580,13 @@ void AvatarMixer::handleAvatarIdentityPacket(QSharedPointer<ReceivedMessage> mes
     _handleAvatarIdentityPacketElapsedTime += (end - start);
 }
 
-void AvatarMixer::handleKillAvatarPacket(QSharedPointer<ReceivedMessage> message) {
+void AvatarMixer::handleKillAvatarPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer node) {
     auto start = usecTimestampNow();
     DependencyManager::get<NodeList>()->processKillNode(*message);
     auto end = usecTimestampNow();
     _handleKillAvatarPacketElapsedTime += (end - start);
+
+    optionallyReplicatePacket(*message, *node);
 }
 
 void AvatarMixer::handleNodeIgnoreRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode) {
@@ -672,7 +838,6 @@ void AvatarMixer::run() {
     connect(&domainHandler, &DomainHandler::settingsReceiveFail, this, &AvatarMixer::domainSettingsRequestFailed);
 
     ThreadedAssignment::commonInit(AVATAR_MIXER_LOGGING_NAME, NodeType::AvatarMixer);
-
 }
 
 AvatarMixerClientData* AvatarMixer::getOrCreateClientData(SharedNodePointer node) {
@@ -691,7 +856,7 @@ AvatarMixerClientData* AvatarMixer::getOrCreateClientData(SharedNodePointer node
 
 void AvatarMixer::domainSettingsRequestComplete() {
     auto nodeList = DependencyManager::get<NodeList>();
-    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::EntityScriptServer });
+    nodeList->addSetOfNodeTypesToNodeInterestSet({ NodeType::Agent, NodeType::DownstreamAvatarMixer, NodeType::EntityScriptServer });
 
     // parse the settings to pull out the values we need
     parseDomainServerSettings(nodeList->getDomainHandler().getSettingsObject());
@@ -764,4 +929,20 @@ void AvatarMixer::parseDomainServerSettings(const QJsonObject& domainSettings) {
     qCDebug(avatars) << "This domain requires a minimum avatar scale of" << _domainMinimumScale
                      << "and a maximum avatar scale of" << _domainMaximumScale;
 
+    const QString AVATAR_WHITELIST_DEFAULT{ "" };
+    static const QString AVATAR_WHITELIST_OPTION = "avatar_whitelist";
+    _avatarWhitelist = domainSettings[AVATARS_SETTINGS_KEY].toObject()[AVATAR_WHITELIST_OPTION].toString(AVATAR_WHITELIST_DEFAULT).split(',', QString::KeepEmptyParts);
+
+    static const QString REPLACEMENT_AVATAR_OPTION = "replacement_avatar";
+    _replacementAvatar = domainSettings[AVATARS_SETTINGS_KEY].toObject()[REPLACEMENT_AVATAR_OPTION].toString(REPLACEMENT_AVATAR_DEFAULT);
+
+    if ((_avatarWhitelist.count() == 1) && _avatarWhitelist[0].isEmpty()) {
+        _avatarWhitelist.clear(); // KeepEmptyParts above will parse "," as ["", ""] (which is ok), but "" as [""] (which is not ok).
+    }
+
+    if (_avatarWhitelist.isEmpty()) {
+        qCDebug(avatars) << "All avatars are allowed.";
+    } else {
+        qCDebug(avatars) << "Avatars other than" << _avatarWhitelist << "will be replaced by" << (_replacementAvatar.isEmpty() ? "default" : _replacementAvatar);
+    }
 }

assignment-client/src/avatars/AvatarMixer.h

@@ -42,10 +42,12 @@ private slots:
     void handleAdjustAvatarSorting(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleViewFrustumPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleAvatarIdentityPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
-    void handleKillAvatarPacket(QSharedPointer<ReceivedMessage> message);
+    void handleKillAvatarPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleNodeIgnoreRequestPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
     void handleRadiusIgnoreRequestPacket(QSharedPointer<ReceivedMessage> packet, SharedNodePointer sendingNode);
     void handleRequestsDomainListDataPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer senderNode);
+    void handleReplicatedPacket(QSharedPointer<ReceivedMessage> message);
+    void handleReplicatedBulkAvatarPacket(QSharedPointer<ReceivedMessage> message);
     void domainSettingsRequestComplete();
     void handlePacketVersionMismatch(PacketType type, const HifiSockAddr& senderSockAddr, const QUuid& senderUUID);
     void start();
@@ -59,7 +61,14 @@ private:
     void parseDomainServerSettings(const QJsonObject& domainSettings);
     void sendIdentityPacket(AvatarMixerClientData* nodeData, const SharedNodePointer& destinationNode);
 
-    void manageDisplayName(const SharedNodePointer& node);
+    void manageIdentityData(const SharedNodePointer& node);
+    bool isAvatarInWhitelist(const QUrl& url);
+
+    const QString REPLACEMENT_AVATAR_DEFAULT{ "" };
+    QStringList _avatarWhitelist { };
+    QString _replacementAvatar { REPLACEMENT_AVATAR_DEFAULT };
+
+    void optionallyReplicatePacket(ReceivedMessage& message, const Node& node);
 
     p_high_resolution_clock::time_point _lastFrameTimestamp;
 

assignment-client/src/avatars/AvatarMixerClientData.h

@@ -65,6 +65,8 @@ public:
     void flagIdentityChange() { _identityChangeTimestamp = usecTimestampNow(); }
     bool getAvatarSessionDisplayNameMustChange() const { return _avatarSessionDisplayNameMustChange; }
     void setAvatarSessionDisplayNameMustChange(bool set = true) { _avatarSessionDisplayNameMustChange = set; }
+    bool getAvatarSkeletonModelUrlMustChange() const { return _avatarSkeletonModelUrlMustChange; }
+    void setAvatarSkeletonModelUrlMustChange(bool set = true) { _avatarSkeletonModelUrlMustChange = set; }
 
     void resetNumAvatarsSentLastFrame() { _numAvatarsSentLastFrame = 0; }
     void incrementNumAvatarsSentLastFrame() { ++_numAvatarsSentLastFrame; }
@@ -146,6 +148,7 @@ private:
 
     uint64_t _identityChangeTimestamp;
     bool _avatarSessionDisplayNameMustChange{ true };
+    bool _avatarSkeletonModelUrlMustChange{ false };
 
     int _numAvatarsSentLastFrame = 0;
     int _numFramesSinceAdjustment = 0;

assignment-client/src/avatars/AvatarMixerSlave.cpp

@@ -65,15 +65,32 @@ void AvatarMixerSlave::processIncomingPackets(const SharedNodePointer& node) {
     _stats.processIncomingPacketsElapsedTime += (end - start);
 }
 
-
 int AvatarMixerSlave::sendIdentityPacket(const AvatarMixerClientData* nodeData, const SharedNodePointer& destinationNode) {
-    QByteArray individualData = nodeData->getConstAvatarData()->identityByteArray();
-    individualData.replace(0, NUM_BYTES_RFC4122_UUID, nodeData->getNodeID().toRfc4122()); // FIXME, this looks suspicious
-    auto identityPackets = NLPacketList::create(PacketType::AvatarIdentity, QByteArray(), true, true);
-    identityPackets->write(individualData);
-    DependencyManager::get<NodeList>()->sendPacketList(std::move(identityPackets), *destinationNode);
-    _stats.numIdentityPackets++;
-    return individualData.size();
+    if (destinationNode->getType() == NodeType::Agent && !destinationNode->isUpstream()) {
+        QByteArray individualData = nodeData->getConstAvatarData()->identityByteArray();
+        individualData.replace(0, NUM_BYTES_RFC4122_UUID, nodeData->getNodeID().toRfc4122()); // FIXME, this looks suspicious
+        auto identityPackets = NLPacketList::create(PacketType::AvatarIdentity, QByteArray(), true, true);
+        identityPackets->write(individualData);
+        DependencyManager::get<NodeList>()->sendPacketList(std::move(identityPackets), *destinationNode);
+        _stats.numIdentityPackets++;
+        return individualData.size();
+    } else {
+        return 0;
+    }
+}
+
+int AvatarMixerSlave::sendReplicatedIdentityPacket(const AvatarMixerClientData* nodeData, const SharedNodePointer& destinationNode) {
+    if (destinationNode->getType() == NodeType::DownstreamAvatarMixer) {
+        QByteArray individualData = nodeData->getConstAvatarData()->identityByteArray();
+        individualData.replace(0, NUM_BYTES_RFC4122_UUID, nodeData->getNodeID().toRfc4122()); // FIXME, this looks suspicious
+        auto identityPacket = NLPacket::create(PacketType::ReplicatedAvatarIdentity);
+        identityPacket->write(individualData);
+        DependencyManager::get<NodeList>()->sendUnreliablePacket(*identityPacket, *destinationNode);
+        _stats.numIdentityPackets++;
+        return individualData.size();
+    } else {
+        return 0;
+    }
 }
 
 static const int AVATAR_MIXER_BROADCAST_FRAMES_PER_SECOND = 45;
@@ -81,6 +98,18 @@ static const int AVATAR_MIXER_BROADCAST_FRAMES_PER_SECOND = 45;
 void AvatarMixerSlave::broadcastAvatarData(const SharedNodePointer& node) {
     quint64 start = usecTimestampNow();
 
+    if (node->getType() == NodeType::Agent && node->getLinkedData() && node->getActiveSocket() && !node->isUpstream()) {
+        broadcastAvatarDataToAgent(node);
+    } else if (node->getType() == NodeType::DownstreamAvatarMixer) {
+        broadcastAvatarDataToDownstreamMixer(node);
+    }
+
+    quint64 end = usecTimestampNow();
+    _stats.jobElapsedTime += (end - start);
+}
+
+void AvatarMixerSlave::broadcastAvatarDataToAgent(const SharedNodePointer& node) {
+
     auto nodeList = DependencyManager::get<NodeList>();
 
     // setup for distributed random floating point values
@@ -88,308 +117,432 @@ void AvatarMixerSlave::broadcastAvatarData(const SharedNodePointer& node) {
     std::mt19937 generator(randomDevice());
     std::uniform_real_distribution<float> distribution;
 
-    if (node->getLinkedData() && (node->getType() == NodeType::Agent) && node->getActiveSocket()) {
-        _stats.nodesBroadcastedTo++;
+    _stats.nodesBroadcastedTo++;
 
-        AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData());
+    AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData());
 
-        nodeData->resetInViewStats();
+    nodeData->resetInViewStats();
 
-        const AvatarData& avatar = nodeData->getAvatar();
-        glm::vec3 myPosition = avatar.getClientGlobalPosition();
+    const AvatarData& avatar = nodeData->getAvatar();
+    glm::vec3 myPosition = avatar.getClientGlobalPosition();
 
-        // reset the internal state for correct random number distribution
-        distribution.reset();
+    // reset the internal state for correct random number distribution
+    distribution.reset();
 
-        // reset the number of sent avatars
-        nodeData->resetNumAvatarsSentLastFrame();
+    // reset the number of sent avatars
+    nodeData->resetNumAvatarsSentLastFrame();
 
-        // keep a counter of the number of considered avatars
-        int numOtherAvatars = 0;
+    // keep a counter of the number of considered avatars
+    int numOtherAvatars = 0;
 
-        // keep track of outbound data rate specifically for avatar data
-        int numAvatarDataBytes = 0;
-        int identityBytesSent = 0;
+    // keep track of outbound data rate specifically for avatar data
+    int numAvatarDataBytes = 0;
+    int identityBytesSent = 0;
 
-        // max number of avatarBytes per frame
-        auto maxAvatarBytesPerFrame = (_maxKbpsPerNode * BYTES_PER_KILOBIT) / AVATAR_MIXER_BROADCAST_FRAMES_PER_SECOND;
+    // max number of avatarBytes per frame
+    auto maxAvatarBytesPerFrame = (_maxKbpsPerNode * BYTES_PER_KILOBIT) / AVATAR_MIXER_BROADCAST_FRAMES_PER_SECOND;
 
-        // FIXME - find a way to not send the sessionID for every avatar
-        int minimumBytesPerAvatar = AvatarDataPacket::AVATAR_HAS_FLAGS_SIZE + NUM_BYTES_RFC4122_UUID;
+    // FIXME - find a way to not send the sessionID for every avatar
+    int minimumBytesPerAvatar = AvatarDataPacket::AVATAR_HAS_FLAGS_SIZE + NUM_BYTES_RFC4122_UUID;
 
-        int overBudgetAvatars = 0;
+    int overBudgetAvatars = 0;
 
-        // keep track of the number of other avatars held back in this frame
-        int numAvatarsHeldBack = 0;
+    // keep track of the number of other avatars held back in this frame
+    int numAvatarsHeldBack = 0;
 
-        // keep track of the number of other avatar frames skipped
-        int numAvatarsWithSkippedFrames = 0;
+    // keep track of the number of other avatar frames skipped
+    int numAvatarsWithSkippedFrames = 0;
 
-        // When this is true, the AvatarMixer will send Avatar data to a client
-        // about avatars they've ignored or that are out of view
-        bool PALIsOpen = nodeData->getRequestsDomainListData();
+    // When this is true, the AvatarMixer will send Avatar data to a client
+    // about avatars they've ignored or that are out of view
+    bool PALIsOpen = nodeData->getRequestsDomainListData();
 
-        // When this is true, the AvatarMixer will send Avatar data to a client about avatars that have ignored them
-        bool getsAnyIgnored = PALIsOpen && node->getCanKick();
+    // When this is true, the AvatarMixer will send Avatar data to a client about avatars that have ignored them
+    bool getsAnyIgnored = PALIsOpen && node->getCanKick();
 
-        if (PALIsOpen) {
-            // Increase minimumBytesPerAvatar if the PAL is open
-            minimumBytesPerAvatar += sizeof(AvatarDataPacket::AvatarGlobalPosition) +
-                sizeof(AvatarDataPacket::AudioLoudness);
-        }
+    if (PALIsOpen) {
+        // Increase minimumBytesPerAvatar if the PAL is open
+        minimumBytesPerAvatar += sizeof(AvatarDataPacket::AvatarGlobalPosition) +
+        sizeof(AvatarDataPacket::AudioLoudness);
+    }
 
-        // setup a PacketList for the avatarPackets
-        auto avatarPacketList = NLPacketList::create(PacketType::BulkAvatarData);
+    // setup a PacketList for the avatarPackets
+    auto avatarPacketList = NLPacketList::create(PacketType::BulkAvatarData);
 
-        // Define the minimum bubble size
-        static const glm::vec3 minBubbleSize = glm::vec3(0.3f, 1.3f, 0.3f);
-        // Define the scale of the box for the current node
-        glm::vec3 nodeBoxScale = (nodeData->getPosition() - nodeData->getGlobalBoundingBoxCorner()) * 2.0f;
-        // Set up the bounding box for the current node
-        AABox nodeBox(nodeData->getGlobalBoundingBoxCorner(), nodeBoxScale);
-        // Clamp the size of the bounding box to a minimum scale
-        if (glm::any(glm::lessThan(nodeBoxScale, minBubbleSize))) {
-            nodeBox.setScaleStayCentered(minBubbleSize);
-        }
-        // Quadruple the scale of both bounding boxes
-        nodeBox.embiggen(4.0f);
+    // Define the minimum bubble size
+    static const glm::vec3 minBubbleSize = glm::vec3(0.3f, 1.3f, 0.3f);
+    // Define the scale of the box for the current node
+    glm::vec3 nodeBoxScale = (nodeData->getPosition() - nodeData->getGlobalBoundingBoxCorner()) * 2.0f;
+    // Set up the bounding box for the current node
+    AABox nodeBox(nodeData->getGlobalBoundingBoxCorner(), nodeBoxScale);
+    // Clamp the size of the bounding box to a minimum scale
+    if (glm::any(glm::lessThan(nodeBoxScale, minBubbleSize))) {
+        nodeBox.setScaleStayCentered(minBubbleSize);
+    }
+    // Quadruple the scale of both bounding boxes
+    nodeBox.embiggen(4.0f);
 
 
-        // 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::unordered_map<AvatarSharedPointer, SharedNodePointer> avatarDataToNodes;
+    // 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::unordered_map<AvatarSharedPointer, SharedNodePointer> avatarDataToNodes;
 
-        std::for_each(_begin, _end, [&](const SharedNodePointer& otherNode) {
+    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
+            && otherNode->getLinkedData()) {
             const AvatarMixerClientData* otherNodeData = reinterpret_cast<const AvatarMixerClientData*>(otherNode->getLinkedData());
 
-            // theoretically it's possible for a Node to be in the NodeList (and therefore end up here),
-            // but not have yet sent data that's linked to the node. Check for that case and don't
-            // consider those nodes.
-            if (otherNodeData) {
-                AvatarSharedPointer otherAvatar = otherNodeData->getAvatarSharedPointer();
-                avatarList << otherAvatar;
-                avatarDataToNodes[otherAvatar] = otherNode;
+            AvatarSharedPointer otherAvatar = otherNodeData->getAvatarSharedPointer();
+            avatarList << 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->getPosition() - avatar->getGlobalBoundingBoxCorner());
+        return glm::max(nodeBoxHalfScale.x, glm::max(nodeBoxHalfScale.y, nodeBoxHalfScale.z));
+    }, [&](AvatarSharedPointer avatar)->bool {
+        if (avatar == thisAvatar) {
+            return true; // ignore ourselves...
+        }
+
+        bool shouldIgnore = false;
+
+        // We will also ignore other nodes for a couple of different 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];
+
+        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());
+        assert(avatarNodeData); // we can't have gotten here without avatarNode having valid data
+        quint64 startIgnoreCalculation = usecTimestampNow();
+
+        // make sure we have data for this avatar, that it isn't the same node,
+        // and isn't an avatar that the viewing node has ignored
+        // or that has ignored the viewing node
+        if (!avatarNode->getLinkedData()
+            || avatarNode->getUUID() == node->getUUID()
+            || (node->isIgnoringNodeWithID(avatarNode->getUUID()) && !PALIsOpen)
+            || (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)) {
+
+                // Define the scale of the box for the current other node
+                glm::vec3 otherNodeBoxScale = (avatarNodeData->getPosition() - avatarNodeData->getGlobalBoundingBoxCorner()) * 2.0f;
+                // Set up the bounding box for the current other node
+                AABox otherNodeBox(avatarNodeData->getGlobalBoundingBoxCorner(), otherNodeBoxScale);
+                // Clamp the size of the bounding box to a minimum scale
+                if (glm::any(glm::lessThan(otherNodeBoxScale, minBubbleSize))) {
+                    otherNodeBox.setScaleStayCentered(minBubbleSize);
+                }
+                // Quadruple the scale of both bounding boxes
+                otherNodeBox.embiggen(4.0f);
+
+                // Perform the collision check between the two bounding boxes
+                if (nodeBox.touches(otherNodeBox)) {
+                    nodeData->ignoreOther(node, avatarNode);
+                    shouldIgnore = !getsAnyIgnored;
+                }
             }
-        });
+            // Not close enough to ignore
+            if (!shouldIgnore) {
+                nodeData->removeFromRadiusIgnoringSet(node, avatarNode->getUUID());
+            }
+        }
+        quint64 endIgnoreCalculation = usecTimestampNow();
+        _stats.ignoreCalculationElapsedTime += (endIgnoreCalculation - startIgnoreCalculation);
 
-        AvatarSharedPointer thisAvatar = nodeData->getAvatarSharedPointer();
-        ViewFrustum cameraView = nodeData->getViewFrustom();
-        std::priority_queue<AvatarPriority> sortedAvatars;
-        AvatarData::sortAvatars(avatarList, cameraView, sortedAvatars,
+        if (!shouldIgnore) {
+            AvatarDataSequenceNumber lastSeqToReceiver = nodeData->getLastBroadcastSequenceNumber(avatarNode->getUUID());
+            AvatarDataSequenceNumber lastSeqFromSender = avatarNodeData->getLastReceivedSequenceNumber();
 
-                [&](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());
-                },
+            // FIXME - This code does appear to be working. But it seems brittle.
+            //         It supports determining if the frame of data for this "other"
+            //         avatar has already been sent to the reciever. This has been
+            //         verified to work on a desktop display that renders at 60hz and
+            //         therefore sends to mixer at 30hz. Each second you'd expect to
+            //         have 15 (45hz-30hz) duplicate frames. In this case, the stat
+            //         avg_other_av_skips_per_second does report 15.
+            //
+            // make sure we haven't already sent this data from this sender to this receiver
+            // or that somehow we haven't sent
+            if (lastSeqToReceiver == lastSeqFromSender && lastSeqToReceiver != 0) {
+                ++numAvatarsHeldBack;
+                shouldIgnore = true;
+            } else if (lastSeqFromSender - lastSeqToReceiver > 1) {
+                // this is a skip - we still send the packet but capture the presence of the skip so we see it happening
+                ++numAvatarsWithSkippedFrames;
+            }
+        }
+        return shouldIgnore;
+    });
 
-                [&](AvatarSharedPointer avatar)->float{
-                    glm::vec3 nodeBoxHalfScale = (avatar->getPosition() - avatar->getGlobalBoundingBoxCorner());
-                    return glm::max(nodeBoxHalfScale.x, glm::max(nodeBoxHalfScale.y, nodeBoxHalfScale.z));
-                },
+    // loop through our sorted avatars and allocate our bandwidth to them accordingly
+    int avatarRank = 0;
 
-                [&](AvatarSharedPointer avatar)->bool{
-                    if (avatar == thisAvatar) {
-                        return true; // ignore ourselves...
-                    }
+    // this is overly conservative, because it includes some avatars we might not consider
+    int remainingAvatars = (int)sortedAvatars.size();
 
-                    bool shouldIgnore = false;
+    while (!sortedAvatars.empty()) {
+        AvatarPriority sortData = sortedAvatars.top();
+        sortedAvatars.pop();
+        const auto& avatarData = sortData.avatar;
+        avatarRank++;
+        remainingAvatars--;
 
-                    // We will also ignore other nodes for a couple of different 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 otherNode = avatarDataToNodes[avatarData];
+        assert(otherNode); // we can't have gotten here without the avatarData being a valid key in the map
 
-                    assert(avatarNode); // we can't have gotten here without the avatarData being a valid key in the map
+        // NOTE: Here's where we determine if we are over budget and drop to bare minimum data
+        int minimRemainingAvatarBytes = minimumBytesPerAvatar * remainingAvatars;
+        bool overBudget = (identityBytesSent + numAvatarDataBytes + minimRemainingAvatarBytes) > maxAvatarBytesPerFrame;
 
-                    const AvatarMixerClientData* avatarNodeData = reinterpret_cast<const AvatarMixerClientData*>(avatarNode->getLinkedData());
-                    assert(avatarNodeData); // we can't have gotten here without avatarNode having valid data
-                    quint64 startIgnoreCalculation = usecTimestampNow();
+        quint64 startAvatarDataPacking = usecTimestampNow();
 
-                    // make sure we have data for this avatar, that it isn't the same node,
-                    // and isn't an avatar that the viewing node has ignored
-                    // or that has ignored the viewing node
-                    if (!avatarNode->getLinkedData()
-                        || avatarNode->getUUID() == node->getUUID()
-                        || (node->isIgnoringNodeWithID(avatarNode->getUUID()) && !PALIsOpen)
-                        || (avatarNode->isIgnoringNodeWithID(node->getUUID()) && !getsAnyIgnored)) {
-                        shouldIgnore = true;
-                    } else {
+        ++numOtherAvatars;
 
-                        // 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)) {
+        const AvatarMixerClientData* otherNodeData = reinterpret_cast<const AvatarMixerClientData*>(otherNode->getLinkedData());
 
-                            // Define the scale of the box for the current other node
-                            glm::vec3 otherNodeBoxScale = (avatarNodeData->getPosition() - avatarNodeData->getGlobalBoundingBoxCorner()) * 2.0f;
-                            // Set up the bounding box for the current other node
-                            AABox otherNodeBox(avatarNodeData->getGlobalBoundingBoxCorner(), otherNodeBoxScale);
-                            // Clamp the size of the bounding box to a minimum scale
-                            if (glm::any(glm::lessThan(otherNodeBoxScale, minBubbleSize))) {
-                                otherNodeBox.setScaleStayCentered(minBubbleSize);
-                            }
-                            // Quadruple the scale of both bounding boxes
-                            otherNodeBox.embiggen(4.0f);
+        // If the time that the mixer sent AVATAR DATA about Avatar B to Avatar A is BEFORE OR EQUAL TO
+        // the time that Avatar B flagged an IDENTITY DATA change, send IDENTITY DATA about Avatar B to Avatar A.
+        if (nodeData->getLastBroadcastTime(otherNode->getUUID()) <= otherNodeData->getIdentityChangeTimestamp()) {
+            identityBytesSent += sendIdentityPacket(otherNodeData, node);
+        }
 
-                            // Perform the collision check between the two bounding boxes
-                            if (nodeBox.touches(otherNodeBox)) {
-                                nodeData->ignoreOther(node, avatarNode);
-                                shouldIgnore = !getsAnyIgnored;
-                            }
-                        }
-                        // Not close enough to ignore
-                        if (!shouldIgnore) {
-                            nodeData->removeFromRadiusIgnoringSet(node, avatarNode->getUUID());
-                        }
-                    }
-                    quint64 endIgnoreCalculation = usecTimestampNow();
-                    _stats.ignoreCalculationElapsedTime += (endIgnoreCalculation - startIgnoreCalculation);
+        const AvatarData* otherAvatar = otherNodeData->getConstAvatarData();
+        glm::vec3 otherPosition = otherAvatar->getClientGlobalPosition();
 
-                    if (!shouldIgnore) {
-                        AvatarDataSequenceNumber lastSeqToReceiver = nodeData->getLastBroadcastSequenceNumber(avatarNode->getUUID());
-                        AvatarDataSequenceNumber lastSeqFromSender = avatarNodeData->getLastReceivedSequenceNumber();
+        // determine if avatar is in view, to determine how much data to include...
+        glm::vec3 otherNodeBoxScale = (otherPosition - otherNodeData->getGlobalBoundingBoxCorner()) * 2.0f;
+        AABox otherNodeBox(otherNodeData->getGlobalBoundingBoxCorner(), otherNodeBoxScale);
+        bool isInView = nodeData->otherAvatarInView(otherNodeBox);
 
-                        // FIXME - This code does appear to be working. But it seems brittle.
-                        //         It supports determining if the frame of data for this "other"
-                        //         avatar has already been sent to the reciever. This has been
-                        //         verified to work on a desktop display that renders at 60hz and
-                        //         therefore sends to mixer at 30hz. Each second you'd expect to
-                        //         have 15 (45hz-30hz) duplicate frames. In this case, the stat
-                        //         avg_other_av_skips_per_second does report 15.
-                        //
-                        // make sure we haven't already sent this data from this sender to this receiver
-                        // or that somehow we haven't sent
-                        if (lastSeqToReceiver == lastSeqFromSender && lastSeqToReceiver != 0) {
-                            ++numAvatarsHeldBack;
-                            shouldIgnore = true;
-                        } else if (lastSeqFromSender - lastSeqToReceiver > 1) {
-                            // this is a skip - we still send the packet but capture the presence of the skip so we see it happening
-                            ++numAvatarsWithSkippedFrames;
-                        }
-                    }
-                    return shouldIgnore;
-                });
+        // start a new segment in the PacketList for this avatar
+        avatarPacketList->startSegment();
 
-        // loop through our sorted avatars and allocate our bandwidth to them accordingly
-        int avatarRank = 0;
+        AvatarData::AvatarDataDetail detail;
 
-        // this is overly conservative, because it includes some avatars we might not consider
-        int remainingAvatars = (int)sortedAvatars.size();
+        if (overBudget) {
+            overBudgetAvatars++;
+            _stats.overBudgetAvatars++;
+            detail = PALIsOpen ? AvatarData::PALMinimum : AvatarData::NoData;
+        } else if (!isInView) {
+            detail = PALIsOpen ? AvatarData::PALMinimum : AvatarData::MinimumData;
+            nodeData->incrementAvatarOutOfView();
+        } else {
+            detail = distribution(generator) < AVATAR_SEND_FULL_UPDATE_RATIO
+            ? AvatarData::SendAllData : AvatarData::CullSmallData;
+            nodeData->incrementAvatarInView();
+        }
 
-        while (!sortedAvatars.empty()) {
-            AvatarPriority sortData = sortedAvatars.top();
-            sortedAvatars.pop();
-            const auto& avatarData = sortData.avatar;
-            avatarRank++;
-            remainingAvatars--;
+        bool includeThisAvatar = true;
+        auto lastEncodeForOther = nodeData->getLastOtherAvatarEncodeTime(otherNode->getUUID());
+        QVector<JointData>& lastSentJointsForOther = nodeData->getLastOtherAvatarSentJoints(otherNode->getUUID());
+        bool distanceAdjust = true;
+        glm::vec3 viewerPosition = myPosition;
+        AvatarDataPacket::HasFlags hasFlagsOut; // the result of the toByteArray
+        bool dropFaceTracking = false;
 
-            auto otherNode = avatarDataToNodes[avatarData];
-            assert(otherNode); // we can't have gotten here without the avatarData being a valid key in the map
+        quint64 start = usecTimestampNow();
+        QByteArray bytes = otherAvatar->toByteArray(detail, lastEncodeForOther, lastSentJointsForOther,
+                                                    hasFlagsOut, dropFaceTracking, distanceAdjust, viewerPosition, &lastSentJointsForOther);
+        quint64 end = usecTimestampNow();
+        _stats.toByteArrayElapsedTime += (end - start);
 
-            // NOTE: Here's where we determine if we are over budget and drop to bare minimum data
-            int minimRemainingAvatarBytes = minimumBytesPerAvatar * remainingAvatars;
-            bool overBudget = (identityBytesSent + numAvatarDataBytes + minimRemainingAvatarBytes) > maxAvatarBytesPerFrame;
+        static const int MAX_ALLOWED_AVATAR_DATA = (1400 - NUM_BYTES_RFC4122_UUID);
+        if (bytes.size() > MAX_ALLOWED_AVATAR_DATA) {
+            qCWarning(avatars) << "otherAvatar.toByteArray() resulted in very large buffer:" << bytes.size() << "... attempt to drop facial data";
+
+            dropFaceTracking = true; // first try dropping the facial data
+            bytes = otherAvatar->toByteArray(detail, lastEncodeForOther, lastSentJointsForOther,
+                                             hasFlagsOut, dropFaceTracking, distanceAdjust, viewerPosition, &lastSentJointsForOther);
+
+            if (bytes.size() > MAX_ALLOWED_AVATAR_DATA) {
+                qCWarning(avatars) << "otherAvatar.toByteArray() without facial data resulted in very large buffer:" << bytes.size() << "... reduce to MinimumData";
+                bytes = otherAvatar->toByteArray(AvatarData::MinimumData, lastEncodeForOther, lastSentJointsForOther,
+                                                 hasFlagsOut, dropFaceTracking, distanceAdjust, viewerPosition, &lastSentJointsForOther);
+            }
+
+            if (bytes.size() > MAX_ALLOWED_AVATAR_DATA) {
+                qCWarning(avatars) << "otherAvatar.toByteArray() MinimumData resulted in very large buffer:" << bytes.size() << "... FAIL!!";
+                includeThisAvatar = false;
+            }
+        }
+
+        if (includeThisAvatar) {
+            numAvatarDataBytes += avatarPacketList->write(otherNode->getUUID().toRfc4122());
+            numAvatarDataBytes += avatarPacketList->write(bytes);
+
+            if (detail != AvatarData::NoData) {
+                _stats.numOthersIncluded++;
+
+                // increment the number of avatars sent to this reciever
+                nodeData->incrementNumAvatarsSentLastFrame();
+
+                // set the last sent sequence number for this sender on the receiver
+                nodeData->setLastBroadcastSequenceNumber(otherNode->getUUID(),
+                                                         otherNodeData->getLastReceivedSequenceNumber());
+
+                // remember the last time we sent details about this other node to the receiver
+                nodeData->setLastBroadcastTime(otherNode->getUUID(), start);
+            }
+        }
+
+        avatarPacketList->endSegment();
+
+        quint64 endAvatarDataPacking = usecTimestampNow();
+        _stats.avatarDataPackingElapsedTime += (endAvatarDataPacking - startAvatarDataPacking);
+    };
+
+    quint64 startPacketSending = usecTimestampNow();
+
+    // close the current packet so that we're always sending something
+    avatarPacketList->closeCurrentPacket(true);
+
+    _stats.numPacketsSent += (int)avatarPacketList->getNumPackets();
+    _stats.numBytesSent += numAvatarDataBytes;
+
+    // send the avatar data PacketList
+    nodeList->sendPacketList(std::move(avatarPacketList), *node);
+
+    // record the bytes sent for other avatar data in the AvatarMixerClientData
+    nodeData->recordSentAvatarData(numAvatarDataBytes);
+
+    // record the number of avatars held back this frame
+    nodeData->recordNumOtherAvatarStarves(numAvatarsHeldBack);
+    nodeData->recordNumOtherAvatarSkips(numAvatarsWithSkippedFrames);
+
+    quint64 endPacketSending = usecTimestampNow();
+    _stats.packetSendingElapsedTime += (endPacketSending - startPacketSending);
+}
+
+uint64_t REBROADCAST_IDENTITY_TO_DOWNSTREAM_EVERY_US = 5 * 1000 * 1000;
+
+void AvatarMixerSlave::broadcastAvatarDataToDownstreamMixer(const SharedNodePointer& node) {
+    _stats.downstreamMixersBroadcastedTo++;
+
+    AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData());
+    if (!nodeData) {
+        return;
+    }
+
+    // setup a PacketList for the replicated bulk avatar data
+    auto avatarPacketList = NLPacketList::create(PacketType::ReplicatedBulkAvatarData);
+
+    int numAvatarDataBytes = 0;
+
+    // reset the number of sent avatars
+    nodeData->resetNumAvatarsSentLastFrame();
+
+    std::for_each(_begin, _end, [&](const SharedNodePointer& agentNode) {
+        // collect agents that we have avatar data for that we are supposed to replicate
+        if (agentNode->getType() == NodeType::Agent && agentNode->getLinkedData() && agentNode->isReplicated()) {
+            const AvatarMixerClientData* agentNodeData = reinterpret_cast<const AvatarMixerClientData*>(agentNode->getLinkedData());
+
+            AvatarSharedPointer otherAvatar = agentNodeData->getAvatarSharedPointer();
 
             quint64 startAvatarDataPacking = usecTimestampNow();
 
-            ++numOtherAvatars;
-
-            const AvatarMixerClientData* otherNodeData = reinterpret_cast<const AvatarMixerClientData*>(otherNode->getLinkedData());
-
-            // If the time that the mixer sent AVATAR DATA about Avatar B to Avatar A is BEFORE OR EQUAL TO
-            // the time that Avatar B flagged an IDENTITY DATA change, send IDENTITY DATA about Avatar B to Avatar A.
-            if (nodeData->getLastBroadcastTime(otherNode->getUUID()) <= otherNodeData->getIdentityChangeTimestamp()) {
-                identityBytesSent += sendIdentityPacket(otherNodeData, node);
-            }
-
-            const AvatarData* otherAvatar = otherNodeData->getConstAvatarData();
-            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;
-            AABox otherNodeBox(otherNodeData->getGlobalBoundingBoxCorner(), otherNodeBoxScale);
-            bool isInView = nodeData->otherAvatarInView(otherNodeBox);
-
-            // start a new segment in the PacketList for this avatar
-            avatarPacketList->startSegment();
-
-            AvatarData::AvatarDataDetail detail;
-
-            if (overBudget) {
-                overBudgetAvatars++;
-                _stats.overBudgetAvatars++;
-                detail = PALIsOpen ? AvatarData::PALMinimum : AvatarData::NoData;
-            } else if (!isInView) {
-                detail = PALIsOpen ? AvatarData::PALMinimum : AvatarData::MinimumData;
-                nodeData->incrementAvatarOutOfView();
-            } else {
-                detail = distribution(generator) < AVATAR_SEND_FULL_UPDATE_RATIO
-                    ? AvatarData::SendAllData : AvatarData::CullSmallData;
-                nodeData->incrementAvatarInView();
-            }
-
-            bool includeThisAvatar = true;
-            auto lastEncodeForOther = nodeData->getLastOtherAvatarEncodeTime(otherNode->getUUID());
-            QVector<JointData>& lastSentJointsForOther = nodeData->getLastOtherAvatarSentJoints(otherNode->getUUID());
-            bool distanceAdjust = true;
-            glm::vec3 viewerPosition = myPosition;
-            AvatarDataPacket::HasFlags hasFlagsOut; // the result of the toByteArray
-            bool dropFaceTracking = false;
+            // we cannot send a downstream avatar mixer any updates that expect them to have previous state for this avatar
+            // since we have no idea if they're online and receiving our packets
 
+            // so we always send a full update for this avatar
+            
             quint64 start = usecTimestampNow();
-            QByteArray bytes = otherAvatar->toByteArray(detail, lastEncodeForOther, lastSentJointsForOther, 
-                                            hasFlagsOut, dropFaceTracking, distanceAdjust, viewerPosition, &lastSentJointsForOther);
+            AvatarDataPacket::HasFlags flagsOut;
+
+            QVector<JointData> emptyLastJointSendData { otherAvatar->getJointCount() };
+
+            QByteArray avatarByteArray = otherAvatar->toByteArray(AvatarData::SendAllData, 0, emptyLastJointSendData,
+                                                                  flagsOut, false, false, glm::vec3(0), nullptr);
             quint64 end = usecTimestampNow();
             _stats.toByteArrayElapsedTime += (end - start);
 
-            static const int MAX_ALLOWED_AVATAR_DATA = (1400 - NUM_BYTES_RFC4122_UUID);
-            if (bytes.size() > MAX_ALLOWED_AVATAR_DATA) {
-                qCWarning(avatars) << "otherAvatar.toByteArray() resulted in very large buffer:" << bytes.size() << "... attempt to drop facial data";
+            auto lastBroadcastTime = nodeData->getLastBroadcastTime(agentNode->getUUID());
+            if (lastBroadcastTime <= agentNodeData->getIdentityChangeTimestamp()
+                || (start - lastBroadcastTime) >= REBROADCAST_IDENTITY_TO_DOWNSTREAM_EVERY_US) {
+                sendReplicatedIdentityPacket(agentNodeData, node);
+                nodeData->setLastBroadcastTime(agentNode->getUUID(), start);
+            }
 
-                dropFaceTracking = true; // first try dropping the facial data
-                bytes = otherAvatar->toByteArray(detail, lastEncodeForOther, lastSentJointsForOther,
-                    hasFlagsOut, dropFaceTracking, distanceAdjust, viewerPosition, &lastSentJointsForOther);
+            // figure out how large our avatar byte array can be to fit in the packet list
+            // given that we need it and the avatar UUID and the size of the byte array (16 bit)
+            // to fit in a segment of the packet list
+            auto maxAvatarByteArraySize = avatarPacketList->getMaxSegmentSize();
+            maxAvatarByteArraySize -= NUM_BYTES_RFC4122_UUID;
+            maxAvatarByteArraySize -= sizeof(quint16);
 
-                if (bytes.size() > MAX_ALLOWED_AVATAR_DATA) {
-                    qCWarning(avatars) << "otherAvatar.toByteArray() without facial data resulted in very large buffer:" << bytes.size() << "... reduce to MinimumData";
-                    bytes = otherAvatar->toByteArray(AvatarData::MinimumData, lastEncodeForOther, lastSentJointsForOther,
-                        hasFlagsOut, dropFaceTracking, distanceAdjust, viewerPosition, &lastSentJointsForOther);
-                }
+            auto sequenceNumberSize = sizeof(agentNodeData->getLastReceivedSequenceNumber());
+            maxAvatarByteArraySize -= sequenceNumberSize;
 
-                if (bytes.size() > MAX_ALLOWED_AVATAR_DATA) {
-                    qCWarning(avatars) << "otherAvatar.toByteArray() MinimumData resulted in very large buffer:" << bytes.size() << "... FAIL!!";
-                    includeThisAvatar = false;
+            if (avatarByteArray.size() > maxAvatarByteArraySize) {
+                qCWarning(avatars) << "Replicated avatar data too large for" << otherAvatar->getSessionUUID()
+                    << "-" << avatarByteArray.size() << "bytes";
+
+                avatarByteArray = otherAvatar->toByteArray(AvatarData::SendAllData, 0, emptyLastJointSendData,
+                                                           flagsOut, true, false, glm::vec3(0), nullptr);
+
+                if (avatarByteArray.size() > maxAvatarByteArraySize) {
+                    qCWarning(avatars) << "Replicated avatar data without facial data still too large for"
+                        << otherAvatar->getSessionUUID() << "-" << avatarByteArray.size() << "bytes";
+
+                    avatarByteArray = otherAvatar->toByteArray(AvatarData::MinimumData, 0, emptyLastJointSendData,
+                                                               flagsOut, true, false, glm::vec3(0), nullptr);
                 }
             }
 
-            if (includeThisAvatar) {
-                numAvatarDataBytes += avatarPacketList->write(otherNode->getUUID().toRfc4122());
-                numAvatarDataBytes += avatarPacketList->write(bytes);
+            if (avatarByteArray.size() <= maxAvatarByteArraySize) {
+                // increment the number of avatars sent to this reciever
+                nodeData->incrementNumAvatarsSentLastFrame();
 
-                if (detail != AvatarData::NoData) {
-                    _stats.numOthersIncluded++;
+                // set the last sent sequence number for this sender on the receiver
+                nodeData->setLastBroadcastSequenceNumber(agentNode->getUUID(),
+                                                         agentNodeData->getLastReceivedSequenceNumber());
 
-                    // increment the number of avatars sent to this reciever
-                    nodeData->incrementNumAvatarsSentLastFrame();
+                // increment the number of avatars sent to this reciever
+                nodeData->incrementNumAvatarsSentLastFrame();
 
-                    // set the last sent sequence number for this sender on the receiver
-                    nodeData->setLastBroadcastSequenceNumber(otherNode->getUUID(), 
-                                    otherNodeData->getLastReceivedSequenceNumber());
+                // start a new segment in the packet list for this avatar
+                avatarPacketList->startSegment();
 
-                    // remember the last time we sent details about this other node to the receiver
-                    nodeData->setLastBroadcastTime(otherNode->getUUID(), start);
-                }
+                // write the node's UUID, the size of the replicated avatar data,
+                // the sequence number of the replicated avatar data, and the replicated avatar data
+                numAvatarDataBytes += avatarPacketList->write(agentNode->getUUID().toRfc4122());
+                numAvatarDataBytes += avatarPacketList->writePrimitive((quint16) (avatarByteArray.size() + sequenceNumberSize));
+                numAvatarDataBytes += avatarPacketList->writePrimitive(agentNodeData->getLastReceivedSequenceNumber());
+                numAvatarDataBytes += avatarPacketList->write(avatarByteArray);
+
+                avatarPacketList->endSegment();
+
+            } else {
+                qCWarning(avatars) << "Could not fit minimum data avatar for" << otherAvatar->getSessionUUID()
+                    << "to packet list -" << avatarByteArray.size() << "bytes";
             }
 
-            avatarPacketList->endSegment();
-
             quint64 endAvatarDataPacking = usecTimestampNow();
             _stats.avatarDataPackingElapsedTime += (endAvatarDataPacking - startAvatarDataPacking);
-        };
+        }
+    });
 
+    if (avatarPacketList->getNumPackets() > 0) {
         quint64 startPacketSending = usecTimestampNow();
 
         // close the current packet so that we're always sending something
@@ -398,21 +551,15 @@ void AvatarMixerSlave::broadcastAvatarData(const SharedNodePointer& node) {
         _stats.numPacketsSent += (int)avatarPacketList->getNumPackets();
         _stats.numBytesSent += numAvatarDataBytes;
 
-        // send the avatar data PacketList
-        nodeList->sendPacketList(std::move(avatarPacketList), *node);
+        // send the replicated bulk avatar data
+        auto nodeList = DependencyManager::get<NodeList>();
+        nodeList->sendPacketList(std::move(avatarPacketList), node->getPublicSocket());
 
         // record the bytes sent for other avatar data in the AvatarMixerClientData
         nodeData->recordSentAvatarData(numAvatarDataBytes);
 
-        // record the number of avatars held back this frame
-        nodeData->recordNumOtherAvatarStarves(numAvatarsHeldBack);
-        nodeData->recordNumOtherAvatarSkips(numAvatarsWithSkippedFrames);
-
         quint64 endPacketSending = usecTimestampNow();
         _stats.packetSendingElapsedTime += (endPacketSending - startPacketSending);
     }
-
-    quint64 end = usecTimestampNow();
-    _stats.jobElapsedTime += (end - start);
 }
 

assignment-client/src/avatars/AvatarMixerSlave.h

@@ -21,6 +21,7 @@ public:
     quint64 processIncomingPacketsElapsedTime { 0 };
 
     int nodesBroadcastedTo { 0 };
+    int downstreamMixersBroadcastedTo { 0 };
     int numPacketsSent { 0 };
     int numBytesSent { 0 };
     int numIdentityPackets { 0 };
@@ -41,6 +42,7 @@ public:
 
         // sending job stats
         nodesBroadcastedTo = 0;
+        downstreamMixersBroadcastedTo = 0;
         numPacketsSent = 0;
         numBytesSent = 0;
         numIdentityPackets = 0;
@@ -60,6 +62,7 @@ public:
         processIncomingPacketsElapsedTime += rhs.processIncomingPacketsElapsedTime;
 
         nodesBroadcastedTo += rhs.nodesBroadcastedTo;
+        downstreamMixersBroadcastedTo += rhs.downstreamMixersBroadcastedTo;
         numPacketsSent += rhs.numPacketsSent;
         numBytesSent += rhs.numBytesSent;
         numIdentityPackets += rhs.numIdentityPackets;
@@ -92,6 +95,10 @@ public:
 
 private:
     int sendIdentityPacket(const AvatarMixerClientData* nodeData, const SharedNodePointer& destinationNode);
+    int sendReplicatedIdentityPacket(const AvatarMixerClientData* nodeData, const SharedNodePointer& destinationNode);
+
+    void broadcastAvatarDataToAgent(const SharedNodePointer& node);
+    void broadcastAvatarDataToDownstreamMixer(const SharedNodePointer& node);
 
     // frame state
     ConstIter _begin;

assignment-client/src/avatars/AvatarMixerSlavePool.cpp

@@ -76,8 +76,8 @@ void AvatarMixerSlavePool::processIncomingPackets(ConstIter begin, ConstIter end
 }
 
 void AvatarMixerSlavePool::broadcastAvatarData(ConstIter begin, ConstIter end, 
-                                     p_high_resolution_clock::time_point lastFrameTimestamp, 
-                                     float maxKbpsPerNode, float throttlingRatio) {
+                                               p_high_resolution_clock::time_point lastFrameTimestamp,
+                                               float maxKbpsPerNode, float throttlingRatio) {
     _function = &AvatarMixerSlave::broadcastAvatarData;
     _configure = [&](AvatarMixerSlave& slave) { 
         slave.configureBroadcast(begin, end, lastFrameTimestamp, maxKbpsPerNode, throttlingRatio);

assignment-client/src/entities/EntityTreeHeadlessViewer.h

@@ -16,9 +16,9 @@
 #include <SharedUtil.h>
 #include <Octree.h>
 #include <OctreePacketData.h>
-#include <OctreeHeadlessViewer.h>
 #include <ViewFrustum.h>
 
+#include "../octree/OctreeHeadlessViewer.h"
 #include "EntityTree.h"
 
 class EntitySimulation;

assignment-client/src/octree/OctreeHeadlessViewer.cpp

@@ -9,17 +9,14 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
-#include <NodeList.h>
-
-#include "OctreeLogging.h"
 #include "OctreeHeadlessViewer.h"
 
-OctreeHeadlessViewer::OctreeHeadlessViewer() : OctreeRenderer() {
-    _viewFrustum.setProjection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), DEFAULT_ASPECT_RATIO, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
-}
+#include <NodeList.h>
+#include <OctreeLogging.h>
 
-void OctreeHeadlessViewer::init() {
-    OctreeRenderer::init();
+
+OctreeHeadlessViewer::OctreeHeadlessViewer() {
+    _viewFrustum.setProjection(glm::perspective(glm::radians(DEFAULT_FIELD_OF_VIEW_DEGREES), DEFAULT_ASPECT_RATIO, DEFAULT_NEAR_CLIP, DEFAULT_FAR_CLIP));
 }
 
 void OctreeHeadlessViewer::queryOctree() {

assignment-client/src/octree/OctreeHeadlessViewer.h

@@ -12,28 +12,17 @@
 #ifndef hifi_OctreeHeadlessViewer_h
 #define hifi_OctreeHeadlessViewer_h
 
-#include <udt/PacketHeaders.h>
-#include <SharedUtil.h>
-#include <ViewFrustum.h>
+#include <OctreeProcessor.h>
+#include <JurisdictionListener.h>
+#include <OctreeQuery.h>
 
-#include "JurisdictionListener.h"
-#include "Octree.h"
-#include "OctreeConstants.h"
-#include "OctreeQuery.h"
-#include "OctreeRenderer.h"
-#include "OctreeSceneStats.h"
-#include "Octree.h"
 
 // Generic client side Octree renderer class.
-class OctreeHeadlessViewer : public OctreeRenderer {
+class OctreeHeadlessViewer : public OctreeProcessor {
     Q_OBJECT
 public:
     OctreeHeadlessViewer();
     virtual ~OctreeHeadlessViewer() {};
-    virtual void renderElement(OctreeElementPointer element, RenderArgs* args) override { /* swallow these */ }
-
-    virtual void init() override ;
-    virtual void render(RenderArgs* renderArgs) override { /* swallow these */ }
 
     void setJurisdictionListener(JurisdictionListener* jurisdictionListener) { _jurisdictionListener = jurisdictionListener; }
     
@@ -71,6 +60,7 @@ private:
     JurisdictionListener* _jurisdictionListener = nullptr;
     OctreeQuery _octreeQuery;
 
+    ViewFrustum _viewFrustum;
     float _voxelSizeScale { DEFAULT_OCTREE_SIZE_SCALE };
     int _boundaryLevelAdjust { 0 };
     int _maxPacketsPerSecond { DEFAULT_MAX_OCTREE_PPS };

assignment-client/src/scripts/EntityScriptServer.h

@@ -19,10 +19,10 @@
 #include <QtCore/QUuid>
 
 #include <EntityEditPacketSender.h>
-#include <EntityTreeHeadlessViewer.h>
 #include <plugins/CodecPlugin.h>
 #include <ScriptEngine.h>
 #include <ThreadedAssignment.h>
+#include "../entities/EntityTreeHeadlessViewer.h"
 
 class EntityScriptServer : public ThreadedAssignment {
     Q_OBJECT

cmake/externals/quazip/CMakeLists.txt

@@ -12,12 +12,19 @@ elseif ($ENV{QT_CMAKE_PREFIX_PATH})
     set(QT_CMAKE_PREFIX_PATH $ENV{QT_CMAKE_PREFIX_PATH})
 endif ()
 
+set(QUAZIP_CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> -DCMAKE_PREFIX_PATH=${QT_CMAKE_PREFIX_PATH} -DCMAKE_INSTALL_NAME_DIR:PATH=<INSTALL_DIR>/lib -DZLIB_ROOT=${ZLIB_ROOT} -DCMAKE_POSITION_INDEPENDENT_CODE=ON)
+
+if (APPLE)
+else ()
+    set(QUAZIP_CMAKE_ARGS ${QUAZIP_CMAKE_ARGS} -DCMAKE_CXX_STANDARD=11)
+endif ()
+
 ExternalProject_Add(
   ${EXTERNAL_NAME}
   URL https://s3-us-west-1.amazonaws.com/hifi-production/dependencies/quazip-0.7.2.zip
   URL_MD5 2955176048a31262c09259ca8d309d19
   BINARY_DIR ${EXTERNAL_PROJECT_PREFIX}/build
-  CMAKE_ARGS -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR> -DCMAKE_PREFIX_PATH=${QT_CMAKE_PREFIX_PATH} -DCMAKE_INSTALL_NAME_DIR:PATH=<INSTALL_DIR>/lib -DZLIB_ROOT=${ZLIB_ROOT} -DCMAKE_POSITION_INDEPENDENT_CODE=ON
+  CMAKE_ARGS ${QUAZIP_CMAKE_ARGS}
   LOG_DOWNLOAD 1
   LOG_CONFIGURE 1
   LOG_BUILD 1

cmake/macros/LinkHifiLibraries.cmake

@@ -7,16 +7,18 @@
 #  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 # 
 
-macro(LINK_HIFI_LIBRARIES)
+function(LINK_HIFI_LIBRARIES)
   
   file(RELATIVE_PATH RELATIVE_LIBRARY_DIR_PATH ${CMAKE_CURRENT_SOURCE_DIR} "${HIFI_LIBRARY_DIR}")
   
   set(LIBRARIES_TO_LINK ${ARGN})
-  
-  foreach(HIFI_LIBRARY ${LIBRARIES_TO_LINK})    
+  foreach(HIFI_LIBRARY ${LIBRARIES_TO_LINK})
     if (NOT TARGET ${HIFI_LIBRARY})
       add_subdirectory("${RELATIVE_LIBRARY_DIR_PATH}/${HIFI_LIBRARY}" "${RELATIVE_LIBRARY_DIR_PATH}/${HIFI_LIBRARY}")
     endif ()
+  endforeach()
+
+  foreach(HIFI_LIBRARY ${LIBRARIES_TO_LINK})
   
     include_directories("${HIFI_LIBRARY_DIR}/${HIFI_LIBRARY}/src")
     include_directories("${CMAKE_BINARY_DIR}/libraries/${HIFI_LIBRARY}/shaders")
@@ -29,4 +31,4 @@ macro(LINK_HIFI_LIBRARIES)
 
   setup_memory_debugger()
 
-endmacro(LINK_HIFI_LIBRARIES)
+endfunction()

domain-server/resources/describe-settings.json

@@ -147,6 +147,7 @@
     {
       "name": "security",
       "label": "Security",
+      "restart": false,
       "settings": [
         {
           "name": "http_username",
@@ -866,6 +867,22 @@
           "help": "Limits the scale of avatars in your domain. Cannot be greater than 1000.",
           "placeholder": 3.0,
           "default": 3.0
+        },
+        {
+          "name": "avatar_whitelist",
+          "label": "Avatars Allowed from:",
+          "help": "Comma separated list of URLs (with optional paths) that avatar .fst files are allowed from. If someone attempts to use an avatar with a different domain, it will be rejected and the replacement avatar will be used. If left blank, any domain is allowed.",
+          "placeholder": "",
+          "default": "",
+          "advanced": true
+        },
+        {
+          "name": "replacement_avatar",
+          "label": "Replacement Avatar for disallowed avatars",
+          "help": "A URL for an avatar .fst to be used when someone tries to use an avatar that is not allowed. If left blank, the generic default avatar is used.",
+          "placeholder": "",
+          "default": "",
+          "advanced": true
         }
       ]
     },
@@ -1318,6 +1335,68 @@
           "advanced": true
         }
       ]
+    },
+    {
+      "name": "broadcasting",
+      "label": "Broadcasting",
+      "settings": [
+        {
+          "name": "users",
+          "label": "Broadcasted Users",
+          "type": "table",
+          "advanced": true,
+          "can_add_new_rows": true,
+          "help": "Users that are broadcasted to downstream servers",
+          "numbered": false,
+          "columns": [
+            {
+              "name": "user",
+              "label": "User",
+              "can_set": true
+            }
+          ]
+        },
+        {
+          "name": "downstream_servers",
+          "label": "Receiving Servers",
+          "assignment-types": [0,1],
+          "type": "table",
+          "advanced": true,
+          "can_add_new_rows": true,
+          "help": "Servers that receive data for broadcasted users",
+          "numbered": false,
+          "columns": [
+            {
+              "name": "address",
+              "label": "Address",
+              "can_set": true
+            },
+            {
+              "name": "port",
+              "label": "Port",
+              "can_set": true
+            },
+            {
+              "name": "server_type",
+              "label": "Server Type",
+              "type": "select",
+              "placeholder": "Audio Mixer",
+              "default": "Audio Mixer",
+              "can_set": true,
+              "options": [
+                {
+                  "value": "Audio Mixer",
+                  "label": "Audio Mixer"
+                },
+                {
+                  "value": "Avatar Mixer",
+                  "label": "Avatar Mixer"
+                }
+              ]
+            }
+          ]
+        }
+      ]
     }
   ]
 }

domain-server/resources/web/header.html

@@ -10,7 +10,6 @@
     <link href="/css/sweetalert.css" rel="stylesheet" media="screen">
     <link href="/css/bootstrap-switch.min.css" rel="stylesheet" media="screen">
 
-
   </head>
   <body>
     <nav class="navbar navbar-default" role="navigation">
@@ -38,8 +37,23 @@
             </li>
             <li><a href="/content/">Content</a></li>
             <li><a href="/settings/">Settings</a></li>
+            <li><a href="#" id="restart-server"><span class="glyphicon glyphicon-refresh"></span> Restart</a></li>
           </ul>
         </div>
       </div><!-- /.container-fluid -->
     </nav>
+
+    <div class="modal fade" id="restart-modal">
+      <div class="modal-dialog">
+        <div class="modal-content">
+          <div class="modal-header">
+            <h4 class="modal-title">domain-server is restarting</h4>
+          </div>
+          <div class="modal-body">
+            <h5>This page will automatically refresh in <span id="refresh-time">3 seconds</span>.</h5>
+          </div>
+        </div><!-- /.modal-content -->
+      </div><!-- /.modal-dialog -->
+    </div><!-- /.modal -->
+
     <div class="container-fluid">

domain-server/resources/web/js/domain-server.js

@@ -1,3 +1,28 @@
+function showRestartModal() {
+  $('#restart-modal').modal({
+    backdrop: 'static',
+    keyboard: false
+  });
+
+  var secondsElapsed = 0;
+  var numberOfSecondsToWait = 3;
+
+  var refreshSpan = $('span#refresh-time')
+  refreshSpan.html(numberOfSecondsToWait +  " seconds");
+
+  // call ourselves every 1 second to countdown
+  var refreshCountdown = setInterval(function(){
+    secondsElapsed++;
+    secondsLeft = numberOfSecondsToWait - secondsElapsed
+    refreshSpan.html(secondsLeft + (secondsLeft == 1 ? " second" : " seconds"))
+
+    if (secondsElapsed == numberOfSecondsToWait) {
+      location.reload(true);
+      clearInterval(refreshCountdown);
+    }
+  }, 1000);
+}
+
 $(document).ready(function(){
   var url = window.location;
   // Will only work if string in href matches with location
@@ -7,4 +32,10 @@ $(document).ready(function(){
   $('ul.nav a').filter(function() {
       return this.href == url;
   }).parent().addClass('active');  
+
+  $('body').on('click', '#restart-server', function(e){
+    $.get("/restart");
+    showRestartModal();
+    return false;
+  });
 });

domain-server/resources/web/settings/index.shtml

@@ -26,7 +26,7 @@
         </ul>
 
         <button id="advanced-toggle-button" class="btn btn-info advanced-toggle">Show advanced</button>
-        <button class="btn btn-success save-button">Save and restart</button>
+        <button class="btn btn-success save-button">Save</button>
       </div>
     </div>
 
@@ -77,23 +77,10 @@
   </div>
 
   <div class="col-xs-12 hidden-sm hidden-md hidden-lg">
-    <button class="btn btn-success save-button" id="small-save-button">Save and restart</button>
+    <button class="btn btn-success save-button" id="small-save-button">Save</button>
   </div>
 </div>
 
-<div class="modal fade" id="restart-modal">
-  <div class="modal-dialog">
-    <div class="modal-content">
-      <div class="modal-header">
-        <h4 class="modal-title">domain-server is restarting</h4>
-      </div>
-      <div class="modal-body">
-        <h5>This page will automatically refresh in <span id="refresh-time">3 seconds</span>.</h5>
-      </div>
-    </div><!-- /.modal-content -->
-  </div><!-- /.modal-dialog -->
-</div><!-- /.modal -->
-
 <!--#include virtual="footer.html"-->
 <script src='/js/underscore-min.js'></script>
 <script src='/js/underscore-keypath.min.js'></script>

domain-server/resources/web/settings/js/settings.js

@@ -39,7 +39,8 @@ var Settings = {
   ACCESS_TOKEN_SELECTOR: '[name="metaverse.access_token"]',
   PLACES_TABLE_ID: 'places-table',
   FORM_ID: 'settings-form',
-  INVALID_ROW_CLASS: 'invalid-input'
+  INVALID_ROW_CLASS: 'invalid-input',
+  DATA_ROW_INDEX: 'data-row-index'
 };
 
 var viewHelpers = {
@@ -223,10 +224,10 @@ $(document).ready(function(){
             // set focus to the first input in the new row
             $target.closest('table').find('tr.inputs input:first').focus();
           }
-          
+
           var tableRows = sibling.parent();
           var tableBody = tableRows.parent();
-          
+
           // if theres no more siblings, we should jump to a new row
           if (sibling.next().length == 0 && tableRows.nextAll().length == 1) {
               tableBody.find("." + Settings.ADD_ROW_BUTTON_CLASS).click();
@@ -1005,7 +1006,7 @@ function saveSettings() {
       var password = formJSON["security"]["http_password"];
       var verify_password = formJSON["security"]["verify_http_password"];
 
-      // if they've only emptied out the default password field, we should go ahead and acknowledge 
+      // if they've only emptied out the default password field, we should go ahead and acknowledge
       // the verify password field
       if (password != undefined && verify_password == undefined) {
         verify_password = "";
@@ -1158,8 +1159,9 @@ function makeTable(setting, keypath, setting_value) {
       }
 
       html += "<tr class='" + Settings.DATA_ROW_CLASS + "' " +
-                   (isCategorized ? ("data-category='" + categoryValue + "'") : "") + " " +
-                   (isArray ? "" : "name='" + keypath + "." + rowIndexOrName + "'") + ">";
+        (isCategorized ? ("data-category='" + categoryValue + "'") : "") + " " +
+        (isArray ? "" : "name='" + keypath + "." + rowIndexOrName + "'") +
+        (isArray ? Settings.DATA_ROW_INDEX + "='" + (row_num - 1) + "'" : "" ) + ">";
 
       if (setting.numbered === true) {
         html += "<td class='numbered'>" + row_num + "</td>"
@@ -1289,6 +1291,17 @@ function makeTableHiddenInputs(setting, initialValues, categoryValue) {
           "<input type='checkbox' style='display: none;' class='form-control table-checkbox' " +
                  "name='" + col.name + "'" + (defaultValue ? " checked" : "") + "/>" +
         "</td>";
+    } else if (col.type === "select") {
+        html += "<td class='" + Settings.DATA_COL_CLASS + "'name='" + col.name + "'>"
+        html += "<select style='display: none;' class='form-control' data-hidden-input='" + col.name + "'>'"
+
+        for (var i in col.options) {
+            var option = col.options[i];
+            html += "<option value='" + option.value + "' " + (option.value == defaultValue ? 'selected' : '') + ">" + option.label + "</option>";
+        }
+
+        html += "</select>";
+        html += "<input type='hidden' class='table-dropdown form-control trigger-change' name='" + col.name + "' value='" +  defaultValue + "'></td>";
     } else {
       html +=
         "<td " + (col.hidden ? "style='display: none;'" : "") + " class='" + Settings.DATA_COL_CLASS + "' " +
@@ -1328,6 +1341,18 @@ function makeTableCategoryInput(setting, numVisibleColumns) {
   return html;
 }
 
+function getDescriptionForKey(key) {
+  for (var i in Settings.data.descriptions) {
+    if (Settings.data.descriptions[i].name === key) {
+      return Settings.data.descriptions[i];
+    }
+  }
+}
+
+var SAVE_BUTTON_LABEL_SAVE = "Save";
+var SAVE_BUTTON_LABEL_RESTART = "Save and restart";
+var reasonsForRestart = [];
+
 function badgeSidebarForDifferences(changedElement) {
   // figure out which group this input is in
   var panelParentID = changedElement.closest('.panel').attr('id');
@@ -1350,13 +1375,24 @@ function badgeSidebarForDifferences(changedElement) {
   }
 
   var badgeValue = 0
+  var description = getDescriptionForKey(panelParentID);
 
   // badge for any settings we have that are not the same or are not present in initialValues
   for (var setting in panelJSON) {
     if ((!_.has(initialPanelJSON, setting) && panelJSON[setting] !== "") ||
       (!_.isEqual(panelJSON[setting], initialPanelJSON[setting])
       && (panelJSON[setting] !== "" || _.has(initialPanelJSON, setting)))) {
-      badgeValue += 1
+      badgeValue += 1;
+
+      // add a reason to restart
+      if (description && description.restart != false) {
+        reasonsForRestart.push(setting);
+      }
+    } else {
+        // remove a reason to restart
+        if (description && description.restart != false) {
+          reasonsForRestart = $.grep(reasonsForRestart, function(v) { return v != setting; });
+      }
     }
   }
 
@@ -1365,6 +1401,7 @@ function badgeSidebarForDifferences(changedElement) {
     badgeValue = ""
   }
 
+  $(".save-button").html(reasonsForRestart.length > 0 ? SAVE_BUTTON_LABEL_RESTART : SAVE_BUTTON_LABEL_SAVE);
   $("a[href='#" + panelParentID + "'] .badge").html(badgeValue);
 }
 
@@ -1387,6 +1424,21 @@ function addTableRow(row) {
   var setting_name = table.attr("name");
   row.addClass(Settings.DATA_ROW_CLASS + " " + Settings.NEW_ROW_CLASS);
 
+  // if this is an array, add the row index (which is the index of the last row + 1)
+  // as a data attribute to the row
+  var row_index = 0;
+  if (isArray) {
+    var previous_row = row.siblings('.' + Settings.DATA_ROW_CLASS + ':last');
+
+    if (previous_row.length > 0) {
+      row_index = parseInt(previous_row.attr(Settings.DATA_ROW_INDEX), 10) + 1;
+    } else {
+      row_index = 0;
+    }
+
+    row.attr(Settings.DATA_ROW_INDEX, row_index);
+  }
+
   var focusChanged = false;
 
   _.each(row.children(), function(element) {
@@ -1416,19 +1468,23 @@ function addTableRow(row) {
       input.show();
 
       var isCheckbox = input.hasClass("table-checkbox");
+      var isDropdown = input.hasClass("table-dropdown");
 
       if (isArray) {
-        var row_index = row.siblings('.' + Settings.DATA_ROW_CLASS).length
         var key = $(element).attr('name');
 
         // are there multiple columns or just one?
         // with multiple we have an array of Objects, with one we have an array of whatever the value type is
         var num_columns = row.children('.' + Settings.DATA_COL_CLASS).length
+        var newName = setting_name + "[" + row_index + "]" + (num_columns > 1 ? "." + key : "");
 
-        if (isCheckbox) {
-          input.attr("name", setting_name + "[" + row_index + "]" + (num_columns > 1 ? "." + key : ""))
-        } else {
-          input.attr("name", setting_name + "[" + row_index + "]" + (num_columns > 1 ? "." + key : ""))
+        input.attr("name", newName);
+
+        if (isDropdown) {
+          // default values for hidden inputs inside child selects gets cleared so we need to remind it
+          var selectElement = $(element).children("select");
+          selectElement.attr("data-hidden-input", newName);
+          $(element).children("input").val(selectElement.val());
         }
       } else {
         // because the name of the setting in question requires the key
@@ -1444,6 +1500,12 @@ function addTableRow(row) {
           focusChanged = true;
       }
 
+      // if we are adding a dropdown, we should go ahead and make its select
+      // element is visible
+      if (isDropdown) {
+          $(element).children("select").attr("style", "");
+      }
+
       if (isCheckbox) {
         $(input).find("input").attr("data-changed", "true");
       } else {
@@ -1656,31 +1718,6 @@ function updateDataChangedForSiblingRows(row, forceTrue) {
   })
 }
 
-function showRestartModal() {
-  $('#restart-modal').modal({
-    backdrop: 'static',
-    keyboard: false
-  });
-
-  var secondsElapsed = 0;
-  var numberOfSecondsToWait = 3;
-
-  var refreshSpan = $('span#refresh-time')
-  refreshSpan.html(numberOfSecondsToWait +  " seconds");
-
-  // call ourselves every 1 second to countdown
-  var refreshCountdown = setInterval(function(){
-    secondsElapsed++;
-    secondsLeft = numberOfSecondsToWait - secondsElapsed
-    refreshSpan.html(secondsLeft + (secondsLeft == 1 ? " second" : " seconds"))
-
-    if (secondsElapsed == numberOfSecondsToWait) {
-      location.reload(true);
-      clearInterval(refreshCountdown);
-    }
-  }, 1000);
-}
-
 function cleanupFormValues(node) {
   if (node.type && node.type === 'checkbox') {
     return { name: node.name, value: node.checked ? true : false };

domain-server/src/DomainServer.cpp

@@ -117,6 +117,10 @@ DomainServer::DomainServer(int argc, char* argv[]) :
     // if permissions are updated, relay the changes to the Node datastructures
     connect(&_settingsManager, &DomainServerSettingsManager::updateNodePermissions,
             &_gatekeeper, &DomainGatekeeper::updateNodePermissions);
+    connect(&_settingsManager, &DomainServerSettingsManager::settingsUpdated,
+            this, &DomainServer::updateReplicatedNodes);
+    connect(&_settingsManager, &DomainServerSettingsManager::settingsUpdated,
+            this, &DomainServer::updateDownstreamNodes);
 
     setupGroupCacheRefresh();
 
@@ -129,6 +133,9 @@ DomainServer::DomainServer(int argc, char* argv[]) :
 
     setupNodeListAndAssignments();
 
+    updateReplicatedNodes();
+    updateDownstreamNodes();
+
     if (_type != NonMetaverse) {
         // if we have a metaverse domain, we'll use an access token for API calls
         resetAccountManagerAccessToken();
@@ -958,6 +965,11 @@ void DomainServer::handleConnectedNode(SharedNodePointer newNode) {
         emit userConnected();
     }
 
+    if (shouldReplicateNode(*newNode)) {
+        qDebug() << "Setting node to replicated: " << newNode->getUUID();
+        newNode->setIsReplicated(true);
+    }
+
     // send out this node to our other connected nodes
     broadcastNewNode(newNode);
 }
@@ -1650,6 +1662,7 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url
     const QString URI_NODES = "/nodes";
     const QString URI_SETTINGS = "/settings";
     const QString URI_ENTITY_FILE_UPLOAD = "/content/upload";
+    const QString URI_RESTART = "/restart";
 
     const QString UUID_REGEX_STRING = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 
@@ -1804,6 +1817,10 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url
             // send the response
             connection->respond(HTTPConnection::StatusCode200, nodesDocument.toJson(), qPrintable(JSON_MIME_TYPE));
 
+            return true;
+        } else if (url.path() == URI_RESTART) {
+            connection->respond(HTTPConnection::StatusCode200);
+            restart();
             return true;
         } else {
             // check if this is for json stats for a node
@@ -2210,6 +2227,131 @@ void DomainServer::refreshStaticAssignmentAndAddToQueue(SharedAssignmentPointer&
     _unfulfilledAssignments.enqueue(assignment);
 }
 
+static const QString BROADCASTING_SETTINGS_KEY = "broadcasting";
+
+void DomainServer::updateDownstreamNodes() {
+    auto settings = _settingsManager.getSettingsMap();
+    if (settings.contains(BROADCASTING_SETTINGS_KEY)) {
+        auto nodeList = DependencyManager::get<LimitedNodeList>();
+        std::vector<HifiSockAddr> downstreamNodesInSettings;
+        auto replicationSettings = settings.value(BROADCASTING_SETTINGS_KEY).toMap();
+        if (replicationSettings.contains("downstream_servers")) {
+            auto serversSettings = replicationSettings.value("downstream_servers").toList();
+
+            std::vector<HifiSockAddr> knownDownstreamNodes;
+            nodeList->eachNode([&](const SharedNodePointer& otherNode) {
+                if (NodeType::isDownstream(otherNode->getType())) {
+                    knownDownstreamNodes.push_back(otherNode->getPublicSocket());
+                }
+            });
+
+            for (auto& server : serversSettings) {
+                auto downstreamServer = server.toMap();
+
+                static const QString DOWNSTREAM_SERVER_ADDRESS = "address";
+                static const QString DOWNSTREAM_SERVER_PORT = "port";
+                static const QString DOWNSTREAM_SERVER_TYPE = "server_type";
+
+                // make sure we have the settings we need for this downstream server
+                if (downstreamServer.contains(DOWNSTREAM_SERVER_ADDRESS) && downstreamServer.contains(DOWNSTREAM_SERVER_PORT)) {
+
+                    auto nodeType = NodeType::fromString(downstreamServer[DOWNSTREAM_SERVER_TYPE].toString());
+                    auto downstreamNodeType = NodeType::downstreamType(nodeType);
+
+                    // read the address and port and construct a HifiSockAddr from them
+                    HifiSockAddr downstreamServerAddr {
+                        downstreamServer[DOWNSTREAM_SERVER_ADDRESS].toString(),
+                        (quint16) downstreamServer[DOWNSTREAM_SERVER_PORT].toString().toInt()
+                    };
+                    downstreamNodesInSettings.push_back(downstreamServerAddr);
+
+                    bool knownNode = find(knownDownstreamNodes.cbegin(), knownDownstreamNodes.cend(),
+                                          downstreamServerAddr) != knownDownstreamNodes.cend();
+                    if (!knownNode) {
+                        // manually add the downstream node to our node list
+                        auto node = nodeList->addOrUpdateNode(QUuid::createUuid(), downstreamNodeType,
+                                                              downstreamServerAddr, downstreamServerAddr);
+                        node->setIsForcedNeverSilent(true);
+
+                        qDebug() << "Adding downstream node:" << node->getUUID() << downstreamServerAddr;
+
+                        // manually activate the public socket for the downstream node
+                        node->activatePublicSocket();
+                    }
+                }
+
+            }
+        }
+
+        // enumerate the nodes to determine which are no longer downstream for this domain
+        // collect them in a vector to separately remove them with handleKillNode (since eachNode has a read lock and
+        // we cannot recursively take the write lock required by handleKillNode)
+        std::vector<SharedNodePointer> nodesToKill;
+        nodeList->eachNode([&](const SharedNodePointer& otherNode) {
+            if (NodeType::isDownstream(otherNode->getType())) {
+                bool nodeInSettings = find(downstreamNodesInSettings.cbegin(), downstreamNodesInSettings.cend(),
+                                           otherNode->getPublicSocket()) != downstreamNodesInSettings.cend();
+                if (!nodeInSettings) {
+                    qDebug() << "Removing downstream node:" << otherNode->getUUID() << otherNode->getPublicSocket();
+                    nodesToKill.push_back(otherNode);
+                }
+            }
+        });
+
+        for (auto& node : nodesToKill) {
+            handleKillNode(node);
+        }
+    }
+}
+
+void DomainServer::updateReplicatedNodes() {
+    // Make sure we have downstream nodes in our list
+    auto settings = _settingsManager.getSettingsMap();
+
+    static const QString REPLICATED_USERS_KEY = "users";
+    _replicatedUsernames.clear();
+    
+    if (settings.contains(BROADCASTING_SETTINGS_KEY)) {
+        auto replicationSettings = settings.value(BROADCASTING_SETTINGS_KEY).toMap();
+        if (replicationSettings.contains(REPLICATED_USERS_KEY)) {
+            auto usersSettings = replicationSettings.value(REPLICATED_USERS_KEY).toList();
+            for (auto& username : usersSettings) {
+                _replicatedUsernames.push_back(username.toString().toLower());
+            }
+        }
+    }
+
+    auto nodeList = DependencyManager::get<LimitedNodeList>();
+    nodeList->eachMatchingNode([this](const SharedNodePointer& otherNode) -> bool {
+            return otherNode->getType() == NodeType::Agent;
+        }, [this](const SharedNodePointer& otherNode) {
+            auto shouldReplicate = shouldReplicateNode(*otherNode);
+            auto isReplicated = otherNode->isReplicated();
+            if (isReplicated && !shouldReplicate) {
+                qDebug() << "Setting node to NOT be replicated:"
+                    << otherNode->getPermissions().getVerifiedUserName() << otherNode->getUUID();
+            } else if (!isReplicated && shouldReplicate) {
+                qDebug() << "Setting node to replicated:"
+                    << otherNode->getPermissions().getVerifiedUserName() << otherNode->getUUID();
+            }
+            otherNode->setIsReplicated(shouldReplicate);
+        }
+    );
+}
+
+bool DomainServer::shouldReplicateNode(const Node& node) {
+    if (node.getType() == NodeType::Agent) {
+        QString verifiedUsername = node.getPermissions().getVerifiedUserName();
+
+        // Both the verified username and usernames in _replicatedUsernames are lowercase, so
+        // comparisons here are case-insensitive.
+        auto it = find(_replicatedUsernames.cbegin(), _replicatedUsernames.cend(), verifiedUsername);
+        return it != _replicatedUsernames.end();
+    } else {
+        return false;
+    }
+};
+
 void DomainServer::nodeAdded(SharedNodePointer node) {
     // we don't use updateNodeWithData, so add the DomainServerNodeData to the node here
     node->setLinkedData(std::unique_ptr<DomainServerNodeData> { new DomainServerNodeData() });

domain-server/src/DomainServer.h

@@ -102,6 +102,9 @@ private slots:
 
     void handleOctreeFileReplacement(QByteArray octreeFile);
 
+    void updateReplicatedNodes();
+    void updateDownstreamNodes();
+
 signals:
     void iceServerChanged();
     void userConnected();
@@ -161,12 +164,16 @@ private:
     QJsonObject jsonForSocket(const HifiSockAddr& socket);
     QJsonObject jsonObjectForNode(const SharedNodePointer& node);
 
+    bool shouldReplicateNode(const Node& node);
+
     void setupGroupCacheRefresh();
 
     QString pathForRedirect(QString path = QString()) const;
 
     SubnetList _acSubnetWhitelist;
 
+    std::vector<QString> _replicatedUsernames;
+
     DomainGatekeeper _gatekeeper;
 
     HTTPManager _httpManager;

domain-server/src/DomainServerSettingsManager.cpp

@@ -991,6 +991,7 @@ bool DomainServerSettingsManager::handleAuthenticatedHTTPRequest(HTTPConnection
             unpackPermissions();
             apiRefreshGroupInformation();
             emit updateNodePermissions();
+            emit settingsUpdated();
         }
 
         return true;
@@ -1196,13 +1197,14 @@ QJsonObject DomainServerSettingsManager::settingDescriptionFromGroup(const QJson
 bool DomainServerSettingsManager::recurseJSONObjectAndOverwriteSettings(const QJsonObject& postedObject) {
     static const QString SECURITY_ROOT_KEY = "security";
     static const QString AC_SUBNET_WHITELIST_KEY = "ac_subnet_whitelist";
+    static const QString BROADCASTING_KEY = "broadcasting";
 
     auto& settingsVariant = _configMap.getConfig();
     bool needRestart = false;
 
     // Iterate on the setting groups
     foreach(const QString& rootKey, postedObject.keys()) {
-        QJsonValue rootValue = postedObject[rootKey];
+        const QJsonValue& rootValue = postedObject[rootKey];
 
         if (!settingsVariant.contains(rootKey)) {
             // we don't have a map below this key yet, so set it up now
@@ -1247,7 +1249,7 @@ bool DomainServerSettingsManager::recurseJSONObjectAndOverwriteSettings(const QJ
 
             if (!matchingDescriptionObject.isEmpty()) {
                 updateSetting(rootKey, rootValue, *thisMap, matchingDescriptionObject);
-                if (rootKey != SECURITY_ROOT_KEY) {
+                if (rootKey != SECURITY_ROOT_KEY && rootKey != BROADCASTING_KEY) {
                     needRestart = true;
                 }
             } else {
@@ -1261,9 +1263,10 @@ bool DomainServerSettingsManager::recurseJSONObjectAndOverwriteSettings(const QJ
 
                 // if we matched the setting then update the value
                 if (!matchingDescriptionObject.isEmpty()) {
-                    QJsonValue settingValue = rootValue.toObject()[settingKey];
+                    const QJsonValue& settingValue = rootValue.toObject()[settingKey];
                     updateSetting(settingKey, settingValue, *thisMap, matchingDescriptionObject);
-                    if (rootKey != SECURITY_ROOT_KEY || settingKey == AC_SUBNET_WHITELIST_KEY) {
+                    if ((rootKey != SECURITY_ROOT_KEY && rootKey != BROADCASTING_KEY)
+                        || settingKey == AC_SUBNET_WHITELIST_KEY) {
                         needRestart = true;
                     }
                 } else {

domain-server/src/DomainServerSettingsManager.h

@@ -108,6 +108,7 @@ public:
 
 signals:
     void updateNodePermissions();
+    void settingsUpdated();
 
 public slots:
     void apiGetGroupIDJSONCallback(QNetworkReply& requestReply);

interface/resources/icons/tablet-icons/mic-mute-a.svg

@@ -1,70 +1,25 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?xml version="1.0" encoding="utf-8"?>
 <!-- Generator: Adobe Illustrator 19.2.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   version="1.1"
-   x="0px"
-   y="0px"
-   viewBox="0 0 50 50"
-   style="enable-background:new 0 0 50 50;"
-   xml:space="preserve"
-   id="svg2"
-   inkscape:version="0.91 r13725"
-   sodipodi:docname="mic-mute-a.svg"><metadata
-     id="metadata22"><rdf:RDF><cc:Work
-         rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" /><dc:title></dc:title></cc:Work></rdf:RDF></metadata><defs
-     id="defs20" /><sodipodi:namedview
-     pagecolor="#ff0000"
-     bordercolor="#666666"
-     borderopacity="1"
-     objecttolerance="10"
-     gridtolerance="10"
-     guidetolerance="10"
-     inkscape:pageopacity="0"
-     inkscape:pageshadow="2"
-     inkscape:window-width="852"
-     inkscape:window-height="480"
-     id="namedview18"
-     showgrid="false"
-     inkscape:zoom="4.72"
-     inkscape:cx="25"
-     inkscape:cy="25"
-     inkscape:window-x="0"
-     inkscape:window-y="0"
-     inkscape:window-maximized="0"
-     inkscape:current-layer="svg2" /><style
-     type="text/css"
-     id="style4">
-	.st0{fill:#FFFFFF;}
-</style><g
-     id="Layer_2" /><g
-     id="Layer_1"
-     style="fill:#000000;fill-opacity:1"><path
-       class="st0"
-       d="M28.9,17.1v-0.5c0-2-1.7-3.6-3.7-3.6h0c-2,0-3.7,1.6-3.7,3.6v6.9L28.9,17.1z"
-       id="path8"
-       style="fill:#000000;fill-opacity:1" /><path
-       class="st0"
-       d="M21.5,29.2v0.2c0,2,1.6,3.6,3.7,3.6h0c2,0,3.7-1.6,3.7-3.6v-6.6L21.5,29.2z"
-       id="path10"
-       style="fill:#000000;fill-opacity:1" /><path
-       class="st0"
-       d="M39.1,16.8L13.6,39.1c-0.7,0.6-1.8,0.5-2.4-0.2l-0.2-0.2c-0.6-0.7-0.5-1.8,0.2-2.4l25.4-22.4   c0.7-0.6,1.8-0.5,2.4,0.2l0.2,0.2C39.8,15.1,39.7,16.1,39.1,16.8z"
-       id="path12"
-       style="fill:#000000;fill-opacity:1" /><path
-       class="st0"
-       d="M23.4,40.2l0,3.4h-4.3c-1,0-1.8,0.8-1.8,1.8c0,1,0.8,1.8,1.8,1.8h12.3c1,0,1.8-0.8,1.8-1.8   c0-1-0.8-1.8-1.8-1.8h-4.4l0-3.4c5.2-0.8,9.2-5,9.2-10.1c0-0.1,0-5.1,0-5.3c0-1-0.9-1.7-1.8-1.7c-1,0-1.7,0.8-1.7,1.8   c0,0.3,0,4.8,0,5.2c0,3.7-3.4,6.7-7.5,6.7c-3.6,0-6.7-2.3-7.3-5.4L15,34C16.4,37.2,19.6,39.7,23.4,40.2z"
-       id="path14"
-       style="fill:#000000;fill-opacity:1" /><path
-       class="st0"
-       d="M17.7,24.9c0-1-0.7-1.8-1.6-1.8c-1-0.1-1.8,0.7-1.9,1.6c0,0.2,0,4.2,0,5.3l3.5-3.1   C17.7,25.9,17.7,25,17.7,24.9z"
-       id="path16"
-       style="fill:#000000;fill-opacity:1" /></g></svg>
+<svg version="1.1"
+	 id="svg2" inkscape:version="0.91 r13725" sodipodi:docname="mic-mute-a.svg" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:svg="http://www.w3.org/2000/svg"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 50 50"
+	 style="enable-background:new 0 0 50 50;" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#EA4C5F;}
+</style>
+<sodipodi:namedview  bordercolor="#666666" borderopacity="1" gridtolerance="10" guidetolerance="10" id="namedview18" inkscape:current-layer="svg2" inkscape:cx="25" inkscape:cy="25" inkscape:pageopacity="0" inkscape:pageshadow="2" inkscape:window-height="480" inkscape:window-maximized="0" inkscape:window-width="852" inkscape:window-x="0" inkscape:window-y="0" inkscape:zoom="4.72" objecttolerance="10" pagecolor="#ff0000" showgrid="false">
+	</sodipodi:namedview>
+<g id="Layer_2">
+</g>
+<g id="Layer_1">
+	<path id="path8" class="st0" d="M28.9,17.1v-0.5c0-2-1.7-3.6-3.7-3.6l0,0c-2,0-3.7,1.6-3.7,3.6v6.9L28.9,17.1z"/>
+	<path id="path10" class="st0" d="M21.5,29.2v0.2c0,2,1.6,3.6,3.7,3.6l0,0c2,0,3.7-1.6,3.7-3.6v-6.6L21.5,29.2z"/>
+	<path id="path12" class="st0" d="M39.1,16.8L13.6,39.1c-0.7,0.6-1.8,0.5-2.4-0.2L11,38.7c-0.6-0.7-0.5-1.8,0.2-2.4l25.4-22.4
+		c0.7-0.6,1.8-0.5,2.4,0.2l0.2,0.2C39.8,15.1,39.7,16.1,39.1,16.8z"/>
+	<path id="path14" class="st0" d="M23.4,40.2v3.4h-4.3c-1,0-1.8,0.8-1.8,1.8s0.8,1.8,1.8,1.8h12.3c1,0,1.8-0.8,1.8-1.8
+		s-0.8-1.8-1.8-1.8H27v-3.4c5.2-0.8,9.2-5,9.2-10.1c0-0.1,0-5.1,0-5.3c0-1-0.9-1.7-1.8-1.7c-1,0-1.7,0.8-1.7,1.8c0,0.3,0,4.8,0,5.2
+		c0,3.7-3.4,6.7-7.5,6.7c-3.6,0-6.7-2.3-7.3-5.4L15,34C16.4,37.2,19.6,39.7,23.4,40.2z"/>
+	<path id="path16" class="st0" d="M17.7,24.9c0-1-0.7-1.8-1.6-1.8c-1-0.1-1.8,0.7-1.9,1.6c0,0.2,0,4.2,0,5.3l3.5-3.1
+		C17.7,25.9,17.7,25,17.7,24.9z"/>
+</g>
+</svg>

interface/resources/icons/tablet-icons/mic-mute-i.svg

@@ -1,21 +1,25 @@
 <?xml version="1.0" encoding="utf-8"?>
 <!-- Generator: Adobe Illustrator 19.2.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
-<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
-	 viewBox="0 0 50 50" style="enable-background:new 0 0 50 50;" xml:space="preserve">
+<svg version="1.1"
+	 id="svg2" inkscape:version="0.91 r13725" sodipodi:docname="mic-mute-a.svg" xmlns:cc="http://creativecommons.org/ns#" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:svg="http://www.w3.org/2000/svg"
+	 xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 50 50"
+	 style="enable-background:new 0 0 50 50;" xml:space="preserve">
 <style type="text/css">
-	.st0{fill:#FFFFFF;}
+	.st0{fill:#EA4C5F;}
 </style>
+<sodipodi:namedview  bordercolor="#666666" borderopacity="1" gridtolerance="10" guidetolerance="10" id="namedview18" inkscape:current-layer="svg2" inkscape:cx="25" inkscape:cy="25" inkscape:pageopacity="0" inkscape:pageshadow="2" inkscape:window-height="480" inkscape:window-maximized="0" inkscape:window-width="852" inkscape:window-x="0" inkscape:window-y="0" inkscape:zoom="4.72" objecttolerance="10" pagecolor="#ff0000" showgrid="false">
+	</sodipodi:namedview>
 <g id="Layer_2">
 </g>
 <g id="Layer_1">
-	<path class="st0" d="M28.9,17.1v-0.5c0-2-1.7-3.6-3.7-3.6h0c-2,0-3.7,1.6-3.7,3.6v6.9L28.9,17.1z"/>
-	<path class="st0" d="M21.5,29.2v0.2c0,2,1.6,3.6,3.7,3.6h0c2,0,3.7-1.6,3.7-3.6v-6.6L21.5,29.2z"/>
-	<path class="st0" d="M39.1,16.8L13.6,39.1c-0.7,0.6-1.8,0.5-2.4-0.2l-0.2-0.2c-0.6-0.7-0.5-1.8,0.2-2.4l25.4-22.4
+	<path id="path8" class="st0" d="M28.9,17.1v-0.5c0-2-1.7-3.6-3.7-3.6l0,0c-2,0-3.7,1.6-3.7,3.6v6.9L28.9,17.1z"/>
+	<path id="path10" class="st0" d="M21.5,29.2v0.2c0,2,1.6,3.6,3.7,3.6l0,0c2,0,3.7-1.6,3.7-3.6v-6.6L21.5,29.2z"/>
+	<path id="path12" class="st0" d="M39.1,16.8L13.6,39.1c-0.7,0.6-1.8,0.5-2.4-0.2L11,38.7c-0.6-0.7-0.5-1.8,0.2-2.4l25.4-22.4
 		c0.7-0.6,1.8-0.5,2.4,0.2l0.2,0.2C39.8,15.1,39.7,16.1,39.1,16.8z"/>
-	<path class="st0" d="M23.4,40.2l0,3.4h-4.3c-1,0-1.8,0.8-1.8,1.8c0,1,0.8,1.8,1.8,1.8h12.3c1,0,1.8-0.8,1.8-1.8
-		c0-1-0.8-1.8-1.8-1.8h-4.4l0-3.4c5.2-0.8,9.2-5,9.2-10.1c0-0.1,0-5.1,0-5.3c0-1-0.9-1.7-1.8-1.7c-1,0-1.7,0.8-1.7,1.8
-		c0,0.3,0,4.8,0,5.2c0,3.7-3.4,6.7-7.5,6.7c-3.6,0-6.7-2.3-7.3-5.4L15,34C16.4,37.2,19.6,39.7,23.4,40.2z"/>
-	<path class="st0" d="M17.7,24.9c0-1-0.7-1.8-1.6-1.8c-1-0.1-1.8,0.7-1.9,1.6c0,0.2,0,4.2,0,5.3l3.5-3.1
+	<path id="path14" class="st0" d="M23.4,40.2v3.4h-4.3c-1,0-1.8,0.8-1.8,1.8s0.8,1.8,1.8,1.8h12.3c1,0,1.8-0.8,1.8-1.8
+		s-0.8-1.8-1.8-1.8H27v-3.4c5.2-0.8,9.2-5,9.2-10.1c0-0.1,0-5.1,0-5.3c0-1-0.9-1.7-1.8-1.7c-1,0-1.7,0.8-1.7,1.8c0,0.3,0,4.8,0,5.2
+		c0,3.7-3.4,6.7-7.5,6.7c-3.6,0-6.7-2.3-7.3-5.4L15,34C16.4,37.2,19.6,39.7,23.4,40.2z"/>
+	<path id="path16" class="st0" d="M17.7,24.9c0-1-0.7-1.8-1.6-1.8c-1-0.1-1.8,0.7-1.9,1.6c0,0.2,0,4.2,0,5.3l3.5-3.1
 		C17.7,25.9,17.7,25,17.7,24.9z"/>
 </g>
 </svg>

interface/resources/qml/AvatarInputs.qml

@@ -12,84 +12,21 @@ import QtQuick.Controls 1.3
 import QtGraphicalEffects 1.0
 import Qt.labs.settings 1.0
 
+import "./hifi/audio" as HifiAudio
+
 Hifi.AvatarInputs {
-    id: root
+    id: root;
     objectName: "AvatarInputs"
-    width: rootWidth
-    height: controls.height
-    x: 10; y: 5
+    width: audio.width;
+    height: audio.height;
+    x: 10; y: 5;
 
-    readonly property int rootWidth: 265
-    readonly property int iconSize: 24
-    readonly property int iconPadding: 5
+    readonly property bool shouldReposition: true;
 
-    readonly property bool shouldReposition: true
-
-    Settings {
-        category: "Overlay.AvatarInputs"
-        property alias x: root.x
-        property alias y: root.y
-    }
-    
-    MouseArea {
-        id: hover
-        hoverEnabled: true
-        drag.target: parent
-        anchors.fill: parent
-    }
-
-    Item {
-        id: controls
-        width: root.rootWidth
-        height: 44
-        visible: root.showAudioTools
-
-        Rectangle {
-            anchors.fill: parent
-            color: "#00000000"
-
-            Item {
-                id: audioMeter
-                anchors.verticalCenter: parent.verticalCenter
-                anchors.left: parent.left
-                anchors.leftMargin: root.iconPadding
-                anchors.right: parent.right
-                anchors.rightMargin: root.iconPadding
-                height: 8
-                Rectangle {
-                    id: blueRect
-                    color: "blue"
-                    anchors.top: parent.top
-                    anchors.bottom: parent.bottom
-                    anchors.left: parent.left
-                    width: parent.width / 4
-                }
-                Rectangle {
-                    id: greenRect
-                    color: "green"
-                    anchors.top: parent.top
-                    anchors.bottom: parent.bottom
-                    anchors.left: blueRect.right
-                    anchors.right: redRect.left
-                }
-                Rectangle {
-                    id: redRect
-                    color: "red"
-                    anchors.top: parent.top
-                    anchors.bottom: parent.bottom
-                    anchors.right: parent.right
-                    width: parent.width / 5
-                }
-                Rectangle {
-                    z: 100
-                    anchors.top: parent.top
-                    anchors.bottom: parent.bottom
-                    anchors.right: parent.right
-                    width: (1.0 - root.audioLevel) * parent.width
-                    color: "black"
-                }
-           }
-        }
+    HifiAudio.MicBar {
+        id: audio;
+        visible: root.showAudioTools;
+        standalone: true;
+	    dragTarget: parent;
     }
 }
-

interface/resources/qml/QmlWindow.qml

@@ -65,6 +65,12 @@ Windows.Window {
             root.dynamicContent.fromScript(message);
         }
     }
+
+    function clearDebugWindow() {
+        if (root.dynamicContent && root.dynamicContent.clearWindow) {
+            root.dynamicContent.clearWindow();
+        }
+    }
     
     // Handle message traffic from our loaded QML to the script that launched us
     signal sendToScript(var message);

interface/resources/qml/controls-uit/CheckBox.qml

@@ -18,10 +18,12 @@ Original.CheckBox {
     id: checkBox
 
     property int colorScheme: hifi.colorSchemes.light
+    property string color: hifi.colors.lightGray
     readonly property bool isLightColorScheme: colorScheme == hifi.colorSchemes.light
     property bool isRedCheck: false
     property int boxSize: 14
-    readonly property int boxRadius: 3
+    property int boxRadius: 3
+    property bool wrap: true;
     readonly property int checkSize: Math.max(boxSize - 8, 10)
     readonly property int checkRadius: 2
     activeFocusOnPress: true
@@ -89,9 +91,10 @@ Original.CheckBox {
 
         label: Label {
             text: control.text
-            colorScheme: checkBox.colorScheme
+            color: control.color
             x: 2
-            wrapMode: Text.Wrap
+            wrapMode: checkBox.wrap ? Text.Wrap : Text.NoWrap
+            elide: checkBox.wrap ? Text.ElideNone : Text.ElideRight
             enabled: checkBox.enabled
         }
     }

interface/resources/qml/controls-uit/ComboBox.qml

@@ -20,6 +20,7 @@ FocusScope {
     HifiConstants { id: hifi }
 
     property alias model: comboBox.model;
+    property alias editable: comboBox.editable
     property alias comboBox: comboBox
     readonly property alias currentText: comboBox.currentText;
     property alias currentIndex: comboBox.currentIndex;

interface/resources/qml/desktop/Desktop.qml

@@ -353,6 +353,14 @@ FocusScope {
         showDesktop();
     }
 
+    function ensureTitleBarVisible(targetWindow) {
+        // Reposition window to ensure that title bar is vertically inside window.
+        if (targetWindow.frame && targetWindow.frame.decoration) {
+            var topMargin = -targetWindow.frame.decoration.anchors.topMargin;  // Frame's topMargin is a negative value.
+            targetWindow.y = Math.max(targetWindow.y, topMargin);
+        }
+    }
+
     function centerOnVisible(item) {
         var targetWindow = d.getDesktopWindow(item);
         if (!targetWindow) {
@@ -375,11 +383,12 @@ FocusScope {
         targetWindow.x = newX;
         targetWindow.y = newY;
 
+        ensureTitleBarVisible(targetWindow);
+
         // If we've noticed that our recommended desktop rect has changed, record that change here.
         if (recommendedRect != newRecommendedRect) {
             recommendedRect = newRecommendedRect;
         }
-
     }
 
     function repositionOnVisible(item) {
@@ -394,7 +403,6 @@ FocusScope {
             return;
         }
 
-
         var oldRecommendedRect = recommendedRect;
         var oldRecommendedDimmensions = { x: oldRecommendedRect.width, y: oldRecommendedRect.height };
         var newRecommendedRect = Controller.getRecommendedOverlayRect();
@@ -426,7 +434,6 @@ FocusScope {
             newPosition.y = -1
         }
 
-
         if (newPosition.x === -1 && newPosition.y === -1) {
             var originRelativeX = (targetWindow.x - oldRecommendedRect.x);
             var originRelativeY = (targetWindow.y - oldRecommendedRect.y);
@@ -444,6 +451,8 @@ FocusScope {
         }
         targetWindow.x = newPosition.x;
         targetWindow.y = newPosition.y;
+
+        ensureTitleBarVisible(targetWindow);
     }
 
     Component { id: messageDialogBuilder; MessageDialog { } }

interface/resources/qml/hifi/Audio.qml

@@ -1,266 +0,0 @@
-//
-//  Audio.qml
-//  qml/hifi
-//
-//  Audio setup
-//
-//  Created by Vlad Stelmahovsky on 03/22/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
-//
-
-import QtQuick 2.5
-import QtQuick.Controls 1.4
-import QtGraphicalEffects 1.0
-
-import "../styles-uit"
-import "../controls-uit" as HifiControls
-
-import "components"
-
-Rectangle {
-    id: audio;
-
-    //put info text here
-    property alias infoText: infoArea.text
-
-    color: "#404040";
-
-    HifiConstants { id: hifi; }
-    objectName: "AudioWindow"
-
-    property string title: "Audio Options"
-    signal sendToScript(var message);
-
-
-    Component {
-        id: separator
-        LinearGradient {
-            start: Qt.point(0, 0)
-            end: Qt.point(0, 4)
-            gradient: Gradient {
-                GradientStop { position: 0.0; color: "#303030" }
-                GradientStop { position: 0.33; color: "#252525" }  // Equivalent of darkGray0 over baseGray background.
-                GradientStop { position: 0.5; color: "#303030" }
-                GradientStop { position: 0.6; color: "#454a49" }
-                GradientStop { position: 1.0; color: "#454a49" }
-            }
-            cached: true
-        }
-    }
-
-    Column {
-        anchors { left: parent.left; right: parent.right }
-        spacing: 8
-
-        RalewayRegular {
-            anchors { left: parent.left; right: parent.right; leftMargin: 30 }
-            height: 45
-            size: 20
-            color: "white"
-            text: audio.title
-        }
-
-        Loader {
-            width: parent.width
-            height: 5
-            sourceComponent: separator
-        }
-
-        //connections required to syncronize with Menu
-        Connections {
-            target: AudioDevice
-            onMuteToggled: {
-                audioMute.checkbox.checked = AudioDevice.getMuted()
-            }
-        }
-
-        Connections {
-            target: AvatarInputs !== undefined ? AvatarInputs : null
-            onShowAudioToolsChanged: {
-                audioTools.checkbox.checked = showAudioTools
-            }
-        }
-
-        AudioCheckbox {
-            id: audioMute
-            width: parent.width
-            anchors { left: parent.left; right: parent.right; leftMargin: 30 }
-            checkbox.checked: AudioDevice.muted
-            text.text: qsTr("Mute microphone")
-            onCheckBoxClicked: {
-                AudioDevice.muted = checked
-            }
-        }
-
-        AudioCheckbox {
-            id: audioTools
-            width: parent.width
-            anchors { left: parent.left; right: parent.right; leftMargin: 30 }
-            checkbox.checked: AvatarInputs !== undefined ? AvatarInputs.showAudioTools : false
-            text.text: qsTr("Show audio level meter")
-            onCheckBoxClicked: {
-                if (AvatarInputs !== undefined) {
-                    AvatarInputs.showAudioTools = checked
-                }
-            }
-        }
-
-        Loader {
-            width: parent.width
-            height: 5
-            sourceComponent: separator
-        }
-
-        Row {
-            anchors { left: parent.left; right: parent.right; leftMargin: 30 }
-            height: 40
-            spacing: 8
-
-            HiFiGlyphs {
-                text: hifi.glyphs.mic
-                color: hifi.colors.primaryHighlight
-                anchors.verticalCenter: parent.verticalCenter
-                size: 32
-            }
-            RalewayRegular {
-                anchors.verticalCenter: parent.verticalCenter
-                size: 16
-                color: "#AFAFAF"
-                text: qsTr("CHOOSE INPUT DEVICE")
-            }
-        }
-
-        ListView {
-            id: inputAudioListView
-            anchors { left: parent.left; right: parent.right; leftMargin: 70 }
-            height: 125
-            spacing: 0
-            clip: true
-            snapMode: ListView.SnapToItem
-            model: AudioDevice
-            delegate: Item {
-                width: parent.width
-                visible: devicemode === 0
-                height:  visible ? 36 : 0
-
-                AudioCheckbox {
-                    id: cbin
-                    anchors.verticalCenter: parent.verticalCenter
-                    Binding {
-                        target: cbin.checkbox
-                        property: 'checked'
-                        value: devicechecked
-                    }
-
-                    width: parent.width
-                    cbchecked: devicechecked
-                    text.text: devicename
-                    onCheckBoxClicked: {
-                        if (checked) {
-                            if (devicename.length > 0) {
-                                console.log("Audio.qml about to call AudioDevice.setInputDeviceAsync().devicename:" + devicename);
-                                AudioDevice.setInputDeviceAsync(devicename);
-                            } else {
-                                console.log("Audio.qml attempted to set input device to empty device name.");
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        Loader {
-            width: parent.width
-            height: 5
-            sourceComponent: separator
-        }
-
-        Row {
-            anchors { left: parent.left; right: parent.right; leftMargin: 30 }
-            height: 40
-            spacing: 8
-
-            HiFiGlyphs {
-                text: hifi.glyphs.unmuted
-                color: hifi.colors.primaryHighlight
-                anchors.verticalCenter: parent.verticalCenter
-                size: 32
-            }
-            RalewayRegular {
-                anchors.verticalCenter: parent.verticalCenter
-                size: 16
-                color: "#AFAFAF"
-                text: qsTr("CHOOSE OUTPUT DEVICE")
-            }
-        }
-
-        ListView {
-            id: outputAudioListView
-            anchors { left: parent.left; right: parent.right; leftMargin: 70 }
-            height: 250
-            spacing: 0
-            clip: true
-            snapMode: ListView.SnapToItem
-            model: AudioDevice
-            delegate: Item {
-                width: parent.width
-                visible: devicemode === 1
-                height: visible ? 36 : 0
-                AudioCheckbox {
-                    id: cbout
-                    width: parent.width
-                    anchors.verticalCenter: parent.verticalCenter
-                    Binding {
-                        target: cbout.checkbox
-                        property: 'checked'
-                        value: devicechecked
-                    }
-                    text.text: devicename
-                    onCheckBoxClicked: {
-                        if (checked) {
-                            if (devicename.length > 0) {
-                                console.log("Audio.qml about to call AudioDevice.setOutputDeviceAsync().devicename:" + devicename);
-                                AudioDevice.setOutputDeviceAsync(devicename);
-                            } else {
-                                console.log("Audio.qml attempted to set output device to empty device name.");
-                            }
-
-                        }
-                    }
-                }
-            }
-        }
-
-        Loader {
-            id: lastSeparator
-            width: parent.width
-            height: 6
-            sourceComponent: separator
-        }
-
-        Row {
-            anchors { left: parent.left; right: parent.right; leftMargin: 30 }
-            height: 40
-            spacing: 8
-
-            HiFiGlyphs {
-                id: infoSign
-                text: hifi.glyphs.info
-                color: "#AFAFAF"
-                anchors.verticalCenter: parent.verticalCenter
-                size: 60
-            }
-            RalewayRegular {
-                id: infoArea
-                width: parent.width - infoSign.implicitWidth - parent.spacing - 10
-                wrapMode: Text.WordWrap
-                anchors.verticalCenter: parent.verticalCenter
-                size: 12
-                color: hifi.colors.baseGrayHighlight
-            }
-        }
-    }
-}

interface/resources/qml/hifi/NameCard.qml

@@ -590,14 +590,11 @@ Item {
             console.log("This avatar is no longer present. goToUserInDomain() failed.");
             return;
         }
-        var vector = Vec3.subtract(avatar.position, MyAvatar.position);
-        var distance = Vec3.length(vector);
-        var target = Vec3.multiply(Vec3.normalize(vector), distance - 2.0);
         // FIXME: We would like the avatar to recompute the avatar's "maybe fly" test at the new position, so that if high enough up,
         // the avatar goes into fly mode rather than falling. However, that is not exposed to Javascript right now.
         // FIXME: it would be nice if this used the same teleport steps and smoothing as in the teleport.js script.
         // Note, however, that this script allows teleporting to a person in the air, while teleport.js is going to a grounded target.
-        MyAvatar.orientation = Quat.lookAtSimple(MyAvatar.position, avatar.position);
-        MyAvatar.position = Vec3.sum(MyAvatar.position, target);
+        MyAvatar.position = Vec3.sum(avatar.position, Vec3.multiplyQbyV(avatar.orientation, {x: 0, y: 0, z: -2}));
+        MyAvatar.orientation = Quat.multiply(avatar.orientation, {y: 1});
     }
 }

interface/resources/qml/hifi/audio/Audio.qml

@@ -0,0 +1,188 @@
+//
+//  Audio.qml
+//  qml/hifi/audio
+//
+//  Audio setup
+//
+//  Created by Vlad Stelmahovsky on 03/22/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
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtQuick.Layouts 1.3
+
+import "../../styles-uit"
+import "../../controls-uit" as HifiControls
+import "../../windows"
+import "./" as AudioControls
+
+Rectangle {
+    id: root;
+
+    HifiConstants { id: hifi; }
+
+    property var eventBridge;
+    property string title: "Audio Settings - " + Audio.context;
+    signal sendToScript(var message);
+
+    color: hifi.colors.baseGray;
+
+    // only show the title if loaded through a "loader"
+    function showTitle() {
+        return root.parent.objectName == "loader";
+    }
+
+    Column {
+        y: 16; // padding does not work
+        spacing: 16;
+        width: parent.width;
+
+        RalewayRegular {
+            x: 16; // padding does not work
+            size: 16;
+            color: "white";
+            text: root.title;
+
+            visible: root.showTitle();
+        }
+
+        Separator { visible: root.showTitle() }
+
+        ColumnLayout {
+            x: 16; // padding does not work
+            spacing: 16;
+
+            // mute is in its own row
+            RowLayout {
+                AudioControls.CheckBox {
+                    text: qsTr("Mute microphone");
+                    isRedCheck: true;
+                    checked: Audio.muted;
+                    onClicked: {
+                        Audio.muted = checked;
+                        checked = Qt.binding(function() { return Audio.muted; }); // restore binding
+                    }
+                }
+            }
+
+            RowLayout {
+                spacing: 16;
+                AudioControls.CheckBox {
+                    text: qsTr("Enable noise reduction");
+                    checked: Audio.noiseReduction;
+                    onClicked: {
+                        Audio.noiseReduction = checked;
+                        checked = Qt.binding(function() { return Audio.noiseReduction; }); // restore binding
+                    }
+                }
+                AudioControls.CheckBox {
+                    text: qsTr("Show audio level meter");
+                    checked: AvatarInputs.showAudioTools;
+                    onClicked: {
+                        AvatarInputs.showAudioTools = checked;
+                        checked = Qt.binding(function() { return AvatarInputs.showAudioTools; }); // restore binding
+                    }
+                }
+            }
+        }
+
+        Separator {}
+
+        RowLayout {
+            HiFiGlyphs {
+                text: hifi.glyphs.mic;
+                color: hifi.colors.primaryHighlight;
+                anchors.verticalCenter: parent.verticalCenter;
+                size: 28;
+            }
+            RalewayRegular {
+                anchors.verticalCenter: parent.verticalCenter;
+                size: 16;
+                color: hifi.colors.lightGrayText;
+                text: qsTr("CHOOSE INPUT DEVICE");
+            }
+        }
+
+        ListView {
+            anchors { left: parent.left; right: parent.right; leftMargin: 70 }
+            height: 125;
+            spacing: 0;
+            snapMode: ListView.SnapToItem;
+            clip: true;
+            model: Audio.devices.input;
+            delegate: Item {
+                width: parent.width;
+                height: 36;
+
+                RowLayout {
+                    width: parent.width;
+
+                    AudioControls.CheckBox {
+                        Layout.maximumWidth: parent.width - level.width - 40;
+                        text: display;
+                        wrap: false;
+                        checked: selected;
+                        onClicked: {
+                            selected = checked;
+                            checked = Qt.binding(function() { return selected; }); // restore binding
+                        }
+                    }
+                    InputLevel {
+                        id: level;
+                        Layout.alignment: Qt.AlignRight;
+                        Layout.rightMargin: 30;
+                        visible: selected;
+                    }
+                }
+            }
+        }
+
+        Separator {}
+
+        RowLayout {
+            Column {
+                RowLayout {
+                    HiFiGlyphs {
+                        text: hifi.glyphs.unmuted;
+                        color: hifi.colors.primaryHighlight;
+                        anchors.verticalCenter: parent.verticalCenter;
+                        size: 36;
+                    }
+                    RalewayRegular {
+                        anchors.verticalCenter: parent.verticalCenter;
+                        size: 16;
+                        color: hifi.colors.lightGrayText;
+                        text: qsTr("CHOOSE OUTPUT DEVICE");
+                    }
+                }
+
+                PlaySampleSound { anchors { left: parent.left; leftMargin: 60 }}
+            }
+        }
+
+        ListView {
+            anchors { left: parent.left; right: parent.right; leftMargin: 70 }
+            height: 125;
+            spacing: 0;
+            snapMode: ListView.SnapToItem;
+            clip: true;
+            model: Audio.devices.output;
+            delegate: Item {
+                width: parent.width;
+                height: 36;
+                AudioControls.CheckBox {
+                    text: display;
+                    checked: selected;
+                    onClicked: {
+                        selected = checked;
+                        checked = Qt.binding(function() { return selected; }); // restore binding
+                    }
+                }
+            }
+        }
+    }
+}

interface/resources/qml/hifi/audio/CheckBox.qml

@@ -0,0 +1,18 @@
+//
+//  CheckBox.qml
+//  qml/hifi/audio
+//
+//  Created by Zach Pomerantz on 6/12/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
+//
+
+import QtQuick 2.5
+
+import "../../controls-uit" as HifiControls
+
+HifiControls.CheckBox {
+    color: "white"
+}

interface/resources/qml/hifi/audio/InputLevel.qml

@@ -0,0 +1,105 @@
+//
+//  InputLevel.qml
+//  qml/hifi/audio
+//
+//  Created by Zach Pomerantz on 6/20/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
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtQuick.Layouts 1.3
+import QtGraphicalEffects 1.0
+
+Rectangle {
+    readonly property var level: Audio.inputLevel;
+
+    width: 70;
+    height: 8;
+
+    color: "transparent";
+
+    Item {
+        id: colors;
+
+        readonly property string muted: "#E2334D";
+        readonly property string gutter: "#575757";
+        readonly property string greenStart: "#39A38F";
+        readonly property string greenEnd: "#1FC6A6";
+        readonly property string red: colors.muted;
+    }
+
+    Text {
+        id: status;
+
+        anchors {
+            horizontalCenter: parent.horizontalCenter;
+            verticalCenter: parent.verticalCenter;
+        }
+
+        visible: Audio.muted;
+        color: colors.muted;
+
+        text: "MUTED";
+        font.pointSize: 10;
+    }
+
+    Item {
+        id: bar;
+
+        width: parent.width;
+        height: parent.height;
+
+        anchors { fill: parent }
+
+        visible: !status.visible;
+
+        Rectangle { // base
+            radius: 4;
+            anchors { fill: parent }
+            color: colors.gutter;
+        }
+
+        Rectangle { // mask
+            id: mask;
+            width: parent.width * level;
+            radius: 5;
+            anchors {
+                bottom: parent.bottom;
+                bottomMargin: 0;
+                top: parent.top;
+                topMargin: 0;
+                left: parent.left;
+                leftMargin: 0;
+            }
+        }
+
+        LinearGradient {
+            anchors { fill: mask }
+            source: mask
+            start: Qt.point(0, 0);
+            end: Qt.point(70, 0);
+            gradient: Gradient {
+                GradientStop {
+                    position: 0;
+                    color: colors.greenStart;
+                }
+                GradientStop {
+                    position: 0.8;
+                    color: colors.greenEnd;
+                }
+                GradientStop {
+                    position: 0.801;
+                    color: colors.red;
+                }
+                GradientStop {
+                    position: 1;
+                    color: colors.red;
+                }
+            }
+        }
+    }
+}

interface/resources/qml/hifi/audio/MicBar.qml

@@ -0,0 +1,223 @@
+//
+//  MicBar.qml
+//  qml/hifi/audio
+//
+//  Created by Zach Pomerantz on 6/14/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
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtQuick.Layouts 1.3
+import QtGraphicalEffects 1.0
+
+Rectangle {
+    readonly property var level: Audio.inputLevel;
+
+    property bool standalone: false;
+    property var dragTarget: null;
+
+    width: 240;
+    height: 50;
+
+    radius: 5;
+
+    color: "#00000000";
+    border {
+        width: (standalone || Audio.muted || mouseArea.containsMouse) ? 2 : 0;
+        color: colors.border;
+    }
+
+    // borders are painted over fill, so reduce the fill to fit inside the border
+    Rectangle {
+        color: standalone ? colors.fill : "#00000000";
+        width: 236;
+        height: 46;
+
+        radius: 5;
+
+        anchors {
+            verticalCenter: parent.verticalCenter;
+            horizontalCenter: parent.horizontalCenter;
+        }
+    }
+
+    MouseArea {
+        id: mouseArea;
+
+        anchors {
+            left: icon.left;
+            right: bar.right;
+            top: icon.top;
+            bottom: icon.bottom;
+        }
+
+        hoverEnabled: true;
+        scrollGestureEnabled: false;
+        onClicked: { Audio.muted = !Audio.muted; }
+        drag.target: dragTarget;
+    }
+
+    Item {
+        id: colors;
+
+        readonly property string unmuted: "#FFF";
+        readonly property string muted: "#E2334D";
+        readonly property string gutter: "#575757";
+        readonly property string greenStart: "#39A38F";
+        readonly property string greenEnd: "#1FC6A6";
+        readonly property string red: colors.muted;
+        readonly property string fill: "#55000000";
+        readonly property string border: standalone ? "#80FFFFFF" : "#55FFFFFF";
+        readonly property string icon: (Audio.muted && !mouseArea.containsMouse) ? muted : unmuted;
+    }
+
+    Item {
+        id: icon;
+
+        anchors {
+            left: parent.left;
+            leftMargin: 5;
+            verticalCenter: parent.verticalCenter;
+        }
+
+        width: 40;
+        height: 40;
+
+        Item {
+            Image {
+                readonly property string unmutedIcon: "../../../icons/tablet-icons/mic-unmute-i.svg";
+                readonly property string mutedIcon: "../../../icons/tablet-icons/mic-mute-i.svg";
+
+                function exclusiveOr(a, b) { return (a || b) && !(a && b); }
+
+                id: image;
+                source: exclusiveOr(Audio.muted, mouseArea.containsMouse) ? mutedIcon : unmutedIcon;
+
+                width: 30;
+                height: 30;
+                anchors {
+                    left: parent.left;
+                    leftMargin: 5;
+                    top: parent.top;
+                    topMargin: 5;
+                }
+            }
+
+            ColorOverlay {
+                anchors { fill: image }
+                source: image;
+                color: colors.icon;
+            }
+        }
+    }
+
+    Item {
+        id: status;
+
+        readonly property string color: (Audio.muted && !mouseArea.containsMouse) ? colors.muted : colors.unmuted;
+
+        visible: Audio.muted || mouseArea.containsMouse;
+
+        anchors {
+            left: parent.left;
+            leftMargin: 50;
+            verticalCenter: parent.verticalCenter;
+        }
+
+        width: 170;
+        height: 8
+
+        Text {
+            anchors {
+        horizontalCenter: parent.horizontalCenter;
+                verticalCenter: parent.verticalCenter;
+            }
+
+            color: parent.color;
+
+            text: Audio.muted ? (mouseArea.containsMouse ? "UNMUTE" : "MUTED") : "MUTE";
+        font.pointSize: 12;
+        }
+
+        Rectangle {
+            anchors {
+                left: parent.left;
+                verticalCenter: parent.verticalCenter;
+            }
+
+            width: 50;
+        height: 4;
+            color: parent.color;
+        }
+
+        Rectangle {
+            anchors {
+                right: parent.right;
+                verticalCenter: parent.verticalCenter;
+            }
+
+            width: 50;
+        height: 4;
+            color: parent.color;
+        }
+    }
+
+    Item {
+        id: bar;
+
+        visible: !status.visible;
+
+        anchors.fill: status;
+
+        width: status.width;
+
+        Rectangle { // base
+            radius: 4;
+            anchors { fill: parent }
+            color: colors.gutter;
+        }
+
+        Rectangle { // mask
+            id: mask;
+            width: parent.width * level;
+            radius: 5;
+            anchors {
+                bottom: parent.bottom;
+                bottomMargin: 0;
+                top: parent.top;
+                topMargin: 0;
+                left: parent.left;
+                leftMargin: 0;
+            }
+        }
+
+        LinearGradient {
+            anchors { fill: mask }
+            source: mask
+            start: Qt.point(0, 0);
+            end: Qt.point(170, 0);
+            gradient: Gradient {
+                GradientStop {
+                    position: 0;
+                    color: colors.greenStart;
+                }
+                GradientStop {
+                    position: 0.8;
+                    color: colors.greenEnd;
+                }
+                GradientStop {
+                    position: 0.81;
+                    color: colors.red;
+                }
+                GradientStop {
+                    position: 1;
+                    color: colors.red;
+                }
+            }
+        }
+    }
+}

interface/resources/qml/hifi/audio/PlaySampleSound.qml

@@ -0,0 +1,86 @@
+//
+//  PlaySampleSound.qml
+//  qml/hifi/audio
+//
+//  Created by Zach Pomerantz on 6/13/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
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtQuick.Controls.Styles 1.4
+import QtQuick.Layouts 1.3
+
+import "../../styles-uit"
+import "../../controls-uit" as HifiControls
+
+RowLayout {
+    property var sound: null;
+    property var sample: null;
+    property bool isPlaying: false;
+    function createSampleSound() {
+        var SOUND = Qt.resolvedUrl("../../../sounds/sample.wav");
+        sound = SoundCache.getSound(SOUND);
+        sample = null;
+    }
+    function playSound() {
+        // FIXME: MyAvatar is not properly exposed to QML; MyAvatar.qmlPosition is a stopgap
+        // FIXME: Audio.playSystemSound should not require position
+        sample = Audio.playSystemSound(sound, MyAvatar.qmlPosition);
+        isPlaying = true;
+        sample.finished.connect(function() { isPlaying = false; sample = null; });
+    }
+    function stopSound() {
+        sample && sample.stop();
+    }
+
+    Component.onCompleted: createSampleSound();
+    Component.onDestruction: stopSound();
+    onVisibleChanged: {
+        if (!visible) {
+            stopSound();
+        }
+    }
+
+    HifiConstants { id: hifi; }
+
+    Button {
+        style: ButtonStyle {
+            background: Rectangle {
+                implicitWidth: 20;
+                implicitHeight: 20;
+                radius: hifi.buttons.radius;
+                gradient: Gradient {
+                    GradientStop {
+                        position: 0.2;
+                        color: isPlaying ? hifi.buttons.colorStart[hifi.buttons.blue] : hifi.buttons.colorStart[hifi.buttons.black];
+                    }
+                    GradientStop {
+                        position: 1.0;
+                        color: isPlaying ? hifi.buttons.colorFinish[hifi.buttons.blue] : hifi.buttons.colorFinish[hifi.buttons.black];
+                    }
+                }
+            }
+            label: HiFiGlyphs {
+                // absolutely position due to asymmetry in glyph
+                x: isPlaying ? 0 : 1;
+                y: 1;
+                size: 14;
+                color: (control.pressed || control.hovered) ? (isPlaying ? "black" : hifi.colors.primaryHighlight) : "white";
+                text: isPlaying ? hifi.glyphs.stop_square : hifi.glyphs.playback_play;
+            }
+        }
+        onClicked: isPlaying ? stopSound() : playSound();
+    }
+
+    RalewayRegular {
+        Layout.leftMargin: 2;
+        size: 14;
+        color: "white";
+        text: isPlaying ? qsTr("Stop sample sound") : qsTr("Play sample sound");
+    }
+
+}

interface/resources/qml/hifi/components/AudioCheckbox.qml

@@ -1,30 +0,0 @@
-import QtQuick 2.5
-import QtQuick.Controls 1.4
-
-import "../../styles-uit"
-import "../../controls-uit" as HifiControls
-
-Row {
-    id: row
-    spacing: 16
-    property alias checkbox: cb
-    property alias cbchecked: cb.checked
-    property alias text: txt
-    signal checkBoxClicked(bool checked)
-
-    HifiControls.CheckBox {
-        id: cb
-        boxSize: 20
-        colorScheme: hifi.colorSchemes.dark
-        anchors.verticalCenter: parent.verticalCenter
-        onClicked: checkBoxClicked(cb.checked)
-    }
-    RalewayBold {
-        id: txt
-        wrapMode: Text.WordWrap
-        width: parent.width - cb.boxSize - 30
-        anchors.verticalCenter: parent.verticalCenter
-        size: 16
-        color: "white"
-    }
-}

interface/resources/qml/hifi/dialogs/Audio.qml

@@ -0,0 +1,27 @@
+//
+// Audio.qml
+//
+// Created by Zach Pomerantz on 6/12/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
+//
+
+import "../../windows"
+import "../audio"
+
+ScrollingWindow {
+    id: root;
+
+    resizable: true;
+    destroyOnHidden: true;
+    width: 400;
+    height: 577;
+    minSize: Qt.vector2d(400, 500);
+
+    Audio { id: audio; width: root.width }
+
+    objectName: "AudioDialog";
+    title: audio.title;
+}

interface/resources/qml/hifi/dialogs/AudioBuffers.qml

@@ -5,9 +5,9 @@ import "../../dialogs"
 
 PreferencesDialog {
     id: root
-    objectName: "AudioPreferencesDialog"
+    objectName: "AudioBuffersDialog"
     title: "Audio Settings"
-    showCategories: ["Audio"]
+    showCategories: ["Audio Buffers"]
     property var settings: Settings {
         category: root.objectName
         property alias x: root.x
@@ -16,4 +16,3 @@ PreferencesDialog {
         property alias height: root.height
     }
 }
-

interface/resources/qml/hifi/dialogs/RunningScripts.qml

@@ -51,7 +51,20 @@ ScrollingWindow {
     }
 
     function updateRunningScripts() {
+        function simplify(path) {
+            // trim URI querystring/fragment
+            path = (path+'').replace(/[#?].*$/,'');
+            // normalize separators and grab last path segment (ie: just the filename)
+            path = path.replace(/\\/g, '/').split('/').pop();
+            // return lowercased because we want to sort mnemonically
+            return path.toLowerCase();
+        }
         var runningScripts = ScriptDiscoveryService.getRunning();
+        runningScripts.sort(function(a,b) {
+            a = simplify(a.path);
+            b = simplify(b.path);
+            return a < b ? -1 : a > b ? 1 : 0;
+        });
         runningScriptsModel.clear()
         for (var i = 0; i < runningScripts.length; ++i) {
             runningScriptsModel.append(runningScripts[i]);

interface/resources/qml/hifi/tablet/CalibratingScreen.qml

@@ -0,0 +1,213 @@
+//
+//  Created by Dante Ruiz on 6/1/17.
+//  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
+//
+
+
+import QtQuick 2.5
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtGraphicalEffects 1.0
+import QtQuick.Controls.Styles 1.4
+import "../../styles-uit"
+import "../../controls"
+import "../../controls-uit" as HifiControls
+
+
+Rectangle {
+    id: info
+
+
+    signal canceled()
+    signal restart()
+
+    property int count: 3
+    property string calibratingText: "CALIBRATING..."
+    property string calibratingCountText: "CALIBRATION STARTING IN"
+    property string calibrationSuccess: "CALIBRATION COMPLETED"
+    property string calibrationFailed: "CALIBRATION FAILED"
+    
+    HifiConstants { id: hifi }
+    visible: true
+    color: hifi.colors.baseGray
+
+    property string whiteIndicator: "../../../images/loader-calibrate-white.png"
+    property string blueIndicator: "../../../images/loader-calibrate-blue.png"
+    
+    Image {
+        id: busyIndicator
+        width: 350
+        height: 350
+
+        property bool running: true
+
+        anchors {
+            horizontalCenter: parent.horizontalCenter
+            top: parent.top
+            topMargin: 60
+        }
+        visible: busyIndicator.running
+        source: blueIndicator
+        NumberAnimation on rotation {
+            id: busyRotation
+            running: busyIndicator.running
+            loops: Animation.Infinite
+            duration: 1000
+            from: 0 ; to: 360
+        }
+    }
+
+
+    HiFiGlyphs {
+        id: image
+        text: hifi.glyphs.avatar1
+        size: 190
+        color: hifi.colors.white
+
+        anchors {
+            top: busyIndicator.top
+            topMargin: 40
+            horizontalCenter: busyIndicator.horizontalCenter
+        }
+    }
+
+    RalewayBold {
+        id: statusText
+        text: info.calibratingCountText
+        size: 16
+        color: hifi.colors.blueHighlight
+
+        anchors {
+            top: image.bottom
+            topMargin: 15
+            horizontalCenter: image.horizontalCenter
+        }
+    }
+
+
+    RalewayBold {
+        id: countDown
+        text: info.count
+        color: hifi.colors.blueHighlight
+
+        anchors {
+            top: statusText.bottom
+            topMargin: 12
+            horizontalCenter: statusText.horizontalCenter
+        }
+    }
+    
+
+    RalewayBold {
+        id: directions
+
+        anchors {
+            top: busyIndicator.bottom
+            topMargin: 100
+            horizontalCenter: parent.horizontalCenter
+        }
+
+        color: hifi.colors.white
+        size: hifi.fontSizes.rootMenuDisclosure
+        text: "Please stand in a T-Pose during calibration"
+    }
+
+    NumberAnimation {
+        id: numberAnimation
+        target: info
+        property: "count"
+        to: 0
+    }
+
+    Timer {
+        id: timer
+
+        repeat: false
+        interval: 3000
+        onTriggered: {
+            info.calibrating();
+        }
+    }
+
+    Timer {
+        id: closeWindow
+        repeat: false
+        interval: 3000
+        onTriggered: stack.pop();
+    }
+
+    Row {
+
+        spacing: 20
+        anchors {
+            top: directions.bottom
+            topMargin: 30
+            horizontalCenter: parent.horizontalCenter
+        }
+
+
+        HifiControls.Button {
+            width: 120
+            height: 30
+            color: hifi.buttons.red
+            text: "RESTART"
+
+            onClicked: {
+                restart();
+                numberAnimation.stop();
+                info.count = (timer.interval / 1000);
+                numberAnimation.start();
+                timer.restart();
+            }
+        }
+
+        HifiControls.Button {
+            width: 120
+            height: 30
+            color: hifi.buttons.black
+            text: "CANCEL"
+
+            onClicked: {
+                canceled();
+                stack.pop()
+            }
+        }
+    }
+    
+    function start(interval, countNumber) {
+        countDown.visible = true;
+        statusText.color = hifi.colors.blueHighlight;
+        numberAnimation.duration = interval
+        info.count = countNumber;
+        timer.interval = interval;
+        numberAnimation.start();
+        timer.start();
+    }
+
+    function calibrating() {
+        countDown.visible = false;
+        busyIndicator.source = whiteIndicator;
+        busyRotation.from = 360
+        busyRotation.to = 0
+        statusText.text = info.calibratingText;
+        statusText.color = hifi.colors.white
+    }
+
+    function success() {
+        busyIndicator.running = false;
+        statusText.text = info.calibrationSuccess
+        statusText.color = hifi.colors.greenHighlight
+        closeWindow.start();
+    }
+
+    function failure() {
+        busyIndicator.running = false;
+        statusText.text = info.calibrationFailed
+        statusText.color = hifi.colors.redHighlight
+        closeWindow.start();
+    }
+}

interface/resources/qml/hifi/tablet/ControllerSettings.qml

@@ -0,0 +1,218 @@
+//
+//  Created by Dante Ruiz on 6/1/17.
+//  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
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtGraphicalEffects 1.0
+import "../../styles-uit"
+import "../../controls"
+import "../../controls-uit" as HifiControls
+
+StackView {
+    id: stack
+    initialItem: inputConfiguration
+    Rectangle {
+        id: inputConfiguration
+        anchors.fill: parent
+
+        HifiConstants { id: hifi }
+
+        color: hifi.colors.baseGray
+
+        property var pluginSettings: null
+
+        Rectangle {
+            width: inputConfiguration.width
+            height: 1
+            color: hifi.colors.baseGrayShadow
+            x: -hifi.dimensions.contentMargin.x
+        }
+
+        RalewayRegular {
+            id: header
+            text: "Controller Settings"
+            size: 22
+            color: "white"
+
+            anchors.top: inputConfiguration.top
+            anchors.left: inputConfiguration.left
+            anchors.leftMargin: 20
+            anchors.topMargin: 20
+        }
+
+
+        Separator {
+            id: headerSeparator
+            width: inputConfiguration.width
+            anchors.top: header.bottom
+            anchors.topMargin: 10
+        }
+
+        HiFiGlyphs {
+            id: sourceGlyph
+            text: hifi.glyphs.source
+            size: 36
+            color: hifi.colors.blueHighlight
+
+            anchors.top: headerSeparator.bottom
+            anchors.left: inputConfiguration.left
+            anchors.leftMargin: 40
+            anchors.topMargin: 20
+        }
+
+        RalewayRegular {
+            id: configuration
+            text: "SELECT DEVICE"
+            size: 15
+            color: hifi.colors.lightGrayText
+
+
+            anchors.top: headerSeparator.bottom
+            anchors.left: sourceGlyph.right
+            anchors.leftMargin: 10
+            anchors.topMargin: 30
+        }
+
+        Row {
+            id: configRow
+            z: 999
+            anchors.top: sourceGlyph.bottom
+            anchors.topMargin: 20
+            anchors.left: sourceGlyph.left
+            anchors.leftMargin: 40
+            spacing: 10
+            HifiControls.ComboBox {
+                id: box
+                width: 160
+                z: 999
+                editable: true
+                colorScheme: hifi.colorSchemes.dark
+                model: inputPlugins()
+                label: ""
+
+                onCurrentIndexChanged: {
+                    changeSource();
+                }
+            }
+
+            HifiControls.CheckBox {
+                id: checkBox
+                colorScheme: hifi.colorSchemes.dark
+                text: "show all input devices"
+
+                onClicked: {
+                    inputPlugins();
+                    changeSource();
+                }
+            }
+        }
+
+
+        Separator {
+            id: configurationSeparator
+            z: 0
+            width: inputConfiguration.width
+            anchors.top: configRow.bottom
+            anchors.topMargin: 10
+        }
+
+
+        HiFiGlyphs {
+            id: sliderGlyph
+            text: hifi.glyphs.sliders
+            size: 36
+            color: hifi.colors.blueHighlight
+
+            anchors.top: configurationSeparator.bottom
+            anchors.left: inputConfiguration.left
+            anchors.leftMargin: 40
+            anchors.topMargin: 20
+        }
+
+        RalewayRegular {
+            id: configurationHeader
+            text: "CONFIGURATION"
+            size: 15
+            color: hifi.colors.lightGrayText
+
+
+            anchors.top: configurationSeparator.bottom
+            anchors.left: sliderGlyph.right
+            anchors.leftMargin: 10
+            anchors.topMargin: 30
+        }
+
+        Loader {
+            id: loader
+            asynchronous: false
+
+            width: inputConfiguration.width
+            anchors.left: inputConfiguration.left
+            anchors.right: inputConfiguration.right
+            anchors.top: configurationHeader.bottom
+            anchors.topMargin: 10
+            anchors.bottom: inputConfiguration.bottom
+
+            source: InputConfiguration.configurationLayout(box.currentText);
+            onLoaded: {
+                if (loader.item.hasOwnProperty("pluginName")) {
+                    if (box.currentText === "Vive") {
+                        loader.item.pluginName = "OpenVR";
+                    } else {
+                        loader.item.pluginName = box.currentText;
+                    }
+                }
+                
+                if (loader.item.hasOwnProperty("displayInformation")) {
+                    loader.item.displayConfiguration();
+                }
+            }
+        }
+    }
+
+
+    function inputPlugins() {
+        if (checkBox.checked) {
+            return InputConfiguration.inputPlugins();
+        } else {
+            return InputConfiguration.activeInputPlugins();
+        }
+    }
+    
+    function initialize() {
+        changeSource();
+    }
+    
+    function changeSource() {
+        loader.source = "";
+        var source = "";
+        if (box.currentText == "Vive") {
+            source = InputConfiguration.configurationLayout("OpenVR");
+        } else { 
+            source = InputConfiguration.configurationLayout(box.currentText);
+        }
+        
+        loader.source = source;
+        if (source === "") {
+            box.label = "(not configurable)";
+        } else {
+            box.label = "";
+        }
+    }
+    
+    Timer {
+        id: timer
+        repeat: false
+        interval: 300
+        onTriggered: initialize()
+    }
+    
+    Component.onCompleted: {
+        timer.start();
+    }
+}

interface/resources/qml/hifi/tablet/OpenVrConfiguration.qml

@@ -0,0 +1,879 @@
+//
+//  Created by Dante Ruiz on 6/5/17.
+//  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
+//
+
+import QtQuick 2.5
+import QtQuick.Controls 1.4
+import QtGraphicalEffects 1.0
+import QtQuick.Controls 1.4 as Original
+import QtQuick.Controls.Styles 1.4
+import "../../styles-uit"
+import "../../controls"
+import "../../controls-uit" as HifiControls
+import "."
+
+
+Rectangle {
+    id: openVrConfiguration
+
+    width: parent.width
+    height: parent.height
+    anchors.fill: parent
+
+    property int leftMargin: 75
+    property int countDown: 0
+    property string pluginName: ""
+    property var displayInformation: null
+
+    readonly property bool feetChecked: feetBox.checked
+    readonly property bool hipsChecked: hipBox.checked
+    readonly property bool chestChecked: chestBox.checked
+    readonly property bool shouldersChecked: shoulderBox.checked
+    readonly property bool hmdHead: headBox.checked
+    readonly property bool headPuck: headPuckBox.checked
+    readonly property bool handController: handBox.checked
+    readonly property bool handPuck: handPuckBox.checked
+
+    property int state: buttonState.disabled
+    property var lastConfiguration: null
+
+    HifiConstants { id: hifi }
+
+    Component {  id: screen; CalibratingScreen {} }
+    QtObject {
+        id: buttonState
+        readonly property int disabled: 0
+        readonly property int apply: 1
+        readonly property int applyAndCalibrate: 2
+        readonly property int calibrate: 3
+        
+    }
+        
+
+    MouseArea {
+        id: mouseArea
+
+        anchors.fill: parent
+        propagateComposedEvents: true
+        onPressed: {
+            parent.forceActiveFocus()
+            mouse.accepted = false;
+        }
+    }
+    color: hifi.colors.baseGray
+
+    RalewayBold {
+        id: head
+
+        text: "Head:"
+        size: 12
+
+        color: "white"
+
+        anchors.left: parent.left
+        anchors.leftMargin: leftMargin
+    }
+
+    Row {
+        id: headConfig
+        anchors.top: head.bottom
+        anchors.topMargin: 5
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+
+        HifiControls.CheckBox {
+            id: headBox
+            width: 15
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (checked) {
+                    headPuckBox.checked = false;
+                } else {
+                    checked = true;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Vive HMD"
+            color: hifi.colors.lightGrayText
+        }
+
+        HifiControls.CheckBox {
+            id: headPuckBox
+            width: 15
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (checked) {
+                    headBox.checked = false;
+                } else {
+                    checked = true;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Tracker"
+            color: hifi.colors.lightGrayText
+        }
+    }
+
+    Row {
+        id: headOffsets
+        anchors.top: headConfig.bottom
+        anchors.topMargin: 5
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+        visible: headPuckBox.checked
+        HifiControls.SpinBox {
+            id: headYOffset
+            decimals: 4
+            width: 112
+            label: "Y: offset"
+            minimumValue: -10
+            stepSize: 0.0254
+            colorScheme: hifi.colorSchemes.dark
+
+            onEditingFinished: {
+                sendConfigurationSettings();
+            }
+        }
+
+
+        HifiControls.SpinBox {
+            id: headZOffset
+            width: 112
+            label: "Z: offset"
+            minimumValue: -10
+            stepSize: 0.0254
+            decimals: 4
+            colorScheme: hifi.colorSchemes.dark
+            
+            onEditingFinished: {
+                sendConfigurationSettings();
+            }
+        }
+    }
+        
+    
+    RalewayBold {
+        id: hands
+
+        text: "Hands:"
+        size: 12
+
+        color: "white"
+
+        anchors.top: (headOffsets.visible ? headOffsets.bottom : headConfig.bottom)
+        anchors.topMargin: (headOffsets.visible ? 22 : 10)
+        anchors.left: parent.left
+        anchors.leftMargin: leftMargin
+    }
+
+    Row {
+        id: handConfig
+        anchors.top: hands.bottom
+        anchors.topMargin: 5
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+
+        HifiControls.CheckBox {
+            id: handBox
+            width: 15
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (checked) {
+                    handPuckBox.checked = false;
+                } else {
+                    checked = true;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Controllers"
+            color: hifi.colors.lightGrayText
+        }
+
+        HifiControls.CheckBox {
+            id: handPuckBox
+            width: 12
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (checked) {
+                    handBox.checked = false;
+                } else {
+                    checked = true;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Trackers"
+            color: hifi.colors.lightGrayText
+        }
+    }
+
+    Row {
+        id: handOffset
+        visible: handPuckBox.checked
+        anchors.top: handConfig.bottom
+        anchors.topMargin: 5
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+        
+        HifiControls.SpinBox {
+            id: handYOffset
+            decimals: 4
+            width: 112
+            label: "Y: offset"
+            minimumValue: -10
+            stepSize: 0.0254
+            colorScheme: hifi.colorSchemes.dark
+
+            onEditingFinished: {
+                sendConfigurationSettings();
+            }
+        }
+
+
+        HifiControls.SpinBox {
+            id: handZOffset
+            width: 112
+            label: "Z: offset"
+            minimumValue: -10
+            stepSize: 0.0254
+            decimals: 4
+            colorScheme: hifi.colorSchemes.dark
+            
+            onEditingFinished: {
+                sendConfigurationSettings();
+            }
+        }
+    }
+
+    RalewayBold {
+        id: additional
+
+        text: "Additional Trackers"
+        size: 12
+
+        color: hifi.colors.white
+
+        anchors.top: (handOffset.visible ? handOffset.bottom : handConfig.bottom)
+        anchors.topMargin: (handOffset.visible ? 22 : 10)
+        anchors.left: parent.left
+        anchors.leftMargin: leftMargin
+    }
+
+    Row {
+        id: feetConfig
+        anchors.top: additional.bottom
+        anchors.topMargin: 15
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+
+        HifiControls.CheckBox {
+            id: feetBox
+            width: 15
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (!checked) {
+                    shoulderBox.checked = false;
+                    chestBox.checked = false;
+                    hipBox.checked = false;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Feet"
+            color: hifi.colors.lightGrayText
+        }
+    }
+
+    Row {
+        id: hipConfig
+        anchors.top: feetConfig.bottom
+        anchors.topMargin: 15
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+
+        HifiControls.CheckBox {
+            id: hipBox
+            width: 15
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (checked) {
+                    feetBox.checked = true;
+                }
+
+                if (chestChecked) {
+                    checked = true;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Hips"
+            color: hifi.colors.lightGrayText
+        }
+
+        RalewayRegular {
+            size: 12
+            text: "requires feet"
+            color: hifi.colors.lightGray
+        }
+    }
+
+
+     Row {
+        id: chestConfig
+        anchors.top: hipConfig.bottom
+        anchors.topMargin: 15
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+
+        HifiControls.CheckBox {
+            id: chestBox
+            width: 15
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (checked) {
+                    hipBox.checked = true;
+                    feetBox.checked = true;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Chest"
+            color: hifi.colors.lightGrayText
+        }
+
+        RalewayRegular {
+            size: 12
+            text: "requires hips"
+            color: hifi.colors.lightGray
+        }
+     }
+
+
+    Row {
+        id: shoulderConfig
+        anchors.top: chestConfig.bottom
+        anchors.topMargin: 15
+        anchors.left: openVrConfiguration.left
+        anchors.leftMargin: leftMargin + 10
+        spacing: 10
+
+        HifiControls.CheckBox {
+            id: shoulderBox
+            width: 15
+            height: 15
+            boxRadius: 7
+
+            onClicked: {
+                if (checked) {
+                    hipBox.checked = true;
+                    feetBox.checked = true;
+                }
+                sendConfigurationSettings();
+            }
+        }
+
+        RalewayBold {
+            size: 12
+            text: "Shoulders"
+            color: hifi.colors.lightGrayText
+        }
+
+        RalewayRegular {
+            size: 12
+            text: "requires hips"
+            color: hifi.colors.lightGray
+        }
+    }
+
+    Separator {
+        id: bottomSeperator
+        width: parent.width
+        anchors.top: shoulderConfig.bottom
+        anchors.topMargin: 10
+    }
+
+
+
+    Rectangle {
+        id: calibrationButton
+        property int color: hifi.buttons.blue
+        property int colorScheme: hifi.colorSchemes.light
+        property string glyph: hifi.glyphs.avatar1
+        property bool enabled: false
+        property bool pressed: false
+        property bool hovered: false
+        property int size: 32
+        property string text: "apply"
+        property int padding: 12
+
+        width: glyphButton.width + calibrationText.width + padding
+        height: hifi.dimensions.controlLineHeight
+        anchors.top: bottomSeperator.bottom
+        anchors.topMargin: 10
+        anchors.left: parent.left
+        anchors.leftMargin: leftMargin
+
+        radius: hifi.buttons.radius
+        
+        gradient: Gradient {
+            GradientStop {
+                position: 0.2
+                color: {
+                    if (!calibrationButton.enabled) {
+                        hifi.buttons.disabledColorStart[calibrationButton.colorScheme]
+                    } else if (calibrationButton.pressed) {
+                        hifi.buttons.pressedColor[calibrationButton.color]
+                    } else if (calibrationButton.hovered) {
+                        hifi.buttons.hoveredColor[calibrationButton.color]
+                    } else {
+                        hifi.buttons.colorStart[calibrationButton.color]
+                    }
+                }
+            }
+            
+            GradientStop {
+                position: 1.0
+                color: {
+                    if (!calibrationButton.enabled) {
+                        hifi.buttons.disabledColorFinish[calibrationButton.colorScheme]
+                    } else if (calibrationButton.pressed) {
+                        hifi.buttons.pressedColor[calibrationButton.color]
+                    } else if (calibrationButton.hovered) {
+                        hifi.buttons.hoveredColor[calibrationButton.color]
+                    } else {
+                        hifi.buttons.colorFinish[calibrationButton.color]
+                    }
+                }
+            }
+        }
+    
+
+
+       
+        HiFiGlyphs {
+            id: glyphButton
+            color: enabled ? hifi.buttons.textColor[calibrationButton.color]
+                : hifi.buttons.disabledTextColor[calibrationButton.colorScheme]
+            text: calibrationButton.glyph
+            size: calibrationButton.size
+
+            anchors {
+                top: parent.top
+                bottom: parent.bottom
+                bottomMargin: 1
+            }
+        }
+            
+        RalewayBold {
+            id: calibrationText
+            font.capitalization: Font.AllUppercase
+            color: enabled ? hifi.buttons.textColor[calibrationButton.color]
+                : hifi.buttons.disabledTextColor[calibrationButton.colorScheme]
+            size: hifi.fontSizes.buttonLabel
+            text: calibrationButton.text
+
+            anchors {
+                left: glyphButton.right
+                top: parent.top
+                topMargin: 7
+            }
+        }
+    
+
+        MouseArea {
+            anchors.fill: parent
+            hoverEnabled: true
+            onClicked: {
+                if (calibrationButton.enabled) {
+                    if (openVrConfiguration.state === buttonState.apply) {
+                        InputConfiguration.uncalibratePlugin(pluginName);
+                        updateCalibrationButton();
+                    } else {
+                        calibrationTimer.interval = timeToCalibrate.value * 1000
+                        openVrConfiguration.countDown = timeToCalibrate.value;
+                        var calibratingScreen = screen.createObject();
+                        stack.push(calibratingScreen);
+                        calibratingScreen.canceled.connect(cancelCalibration);
+                        calibratingScreen.restart.connect(restartCalibration);
+                        calibratingScreen.start(calibrationTimer.interval, timeToCalibrate.value);
+                        calibrationTimer.start();
+                    }
+                }
+            }
+            
+            onPressed: {
+                calibrationButton.pressed = true;
+            }
+            
+            onReleased: {
+                calibrationButton.pressed = false;
+            }
+            
+            onEntered: {
+                calibrationButton.hovered = true;
+            }
+            
+            onExited: {
+                calibrationButton.hovered = false;
+            }
+        }
+    }
+
+    Timer {
+        id: calibrationTimer
+        repeat: false
+        interval: 20
+        onTriggered: {
+            InputConfiguration.calibratePlugin(pluginName)
+        }
+    }
+
+    Timer {
+        id: displayTimer
+        repeat: false
+        interval: 3000
+        onTriggered: {
+        }
+    }
+
+    Component.onCompleted: {
+        InputConfiguration.calibrationStatus.connect(calibrationStatusInfo);
+        lastConfiguration = composeConfigurationSettings();
+    }
+
+    HifiControls.SpinBox {
+        id: timeToCalibrate
+        width: 70
+        anchors.top: calibrationButton.bottom
+        anchors.topMargin: 40
+        anchors.left: parent.left
+        anchors.leftMargin: leftMargin
+
+        minimumValue: 3
+        value: 3
+        colorScheme: hifi.colorSchemes.dark
+
+        onEditingFinished: {
+            calibrationTimer.interval = value * 1000;
+            openVrConfiguration.countDown = value;
+            numberAnimation.duration = calibrationTimer.interval;
+        }
+    }
+
+    RalewayBold {
+        id: delayTextInfo
+        size: 10
+        text: "Delay Before Calibration Starts"
+        color: hifi.colors.white
+
+        anchors {
+            left: timeToCalibrate.right
+            leftMargin: 20
+            verticalCenter: timeToCalibrate.verticalCenter
+        }
+    }
+
+    RalewayRegular {
+        size: 12
+        text: "sec"
+        color: hifi.colors.lightGray
+
+        anchors {
+            left: delayTextInfo.right
+            leftMargin: 10
+            verticalCenter: delayTextInfo.verticalCenter
+        }
+    }
+
+    NumberAnimation {
+        id: numberAnimation
+        target: openVrConfiguration
+        property: "countDown"
+        to: 0
+    }
+
+    function calibrationStatusInfo(status) {
+        var calibrationScreen = stack.currentItem;
+        if (status["calibrated"]) {
+            calibrationScreen.success();
+        } else if (!status["calibrated"]) {
+            var uncalibrated = status["success"];
+            if (!uncalibrated) {
+                calibrationScreen.failure();
+            }
+        }
+
+        updateCalibrationButton();
+    }
+
+
+    function trackersForConfiguration() {
+        var pucksNeeded = 0;
+
+        if (headPuckBox.checked) {
+            pucksNeeded++;
+        }
+
+        if (feetBox.checked) {
+            pucksNeeded++;
+        }
+
+        if (hipBox.checked) {
+            pucksNeeded++;
+        }
+
+        if (chestBox.checked) {
+            pucksNeeded++;
+        }
+
+        if (shoulderBox.checked) {
+            pucksNeeded++;
+        }
+
+        return pucksNeeded;
+    }
+
+    function cancelCalibration() {
+        calibrationTimer.stop();
+    }
+
+    function restartCalibration() {
+        calibrationTimer.restart();
+    }
+
+    function displayConfiguration() {
+        var settings = InputConfiguration.configurationSettings(pluginName);
+        var configurationType = settings["trackerConfiguration"];
+        displayTrackerConfiguration(configurationType);
+
+
+        var HmdHead = settings["HMDHead"];
+        var viveController = settings["handController"];
+
+        if (HmdHead) {
+            headBox.checked = true;
+            headPuckBox.checked = false;
+        } else {
+            headPuckBox.checked = true;
+            headBox.checked = false;
+        }
+
+        if (viveController) {
+            handBox.checked = true;
+            handPuckBox.checked = false;
+        } else {
+            handPuckBox.checked = true;
+            handBox.checked = false;
+        }
+
+        initializeButtonState();
+        updateCalibrationText();
+    }
+
+    function displayTrackerConfiguration(type) {
+        if (type === "Feet") {
+            feetBox.checked = true;
+        } else if (type === "FeetAndHips") {
+            feetBox.checked = true;
+            hipBox.checked = true;
+        } else if (type === "FeetHipsChest") {
+            feetBox.checked = true;
+            hipBox.checked = true;
+            chestBox.checked = true;
+        } else if (type === "FeetHipsAndShoulders") {
+            feetBox.checked = true;
+            hipBox.checked = true;
+            shoulderBox.checked = true;
+        } else if (type === "FeetHipsChestAndShoulders") {
+            feetBox.checked = true;
+            hipBox.checked = true;
+            chestBox.checked = true;
+            shoulderBox.checked = true;
+        }
+    }
+
+    function updateButtonState() {
+        var settings = composeConfigurationSettings();
+        var bodySetting = settings["bodyConfiguration"];
+        var headSetting = settings["headConfiguration"];
+        var headOverride = headSetting["override"];
+        var handSetting = settings["handConfiguration"];
+        var handOverride = handSetting["override"];
+
+        var settingsChanged = false;
+        
+        if (lastConfiguration["bodyConfiguration"] !== bodySetting) {
+            settingsChanged = true;
+        }
+        
+        var lastHead = lastConfiguration["headConfiguration"];
+        if (lastHead["override"] !== headOverride) {
+            settingsChanged = true;
+        }
+
+        var lastHand = lastConfiguration["handConfiguration"];
+        if (lastHand["override"] !== handOverride) {
+            settingsChanged = true;
+        }
+        
+        if (settingsChanged) {
+            if ((!handOverride) && (!headOverride) && (bodySetting === "None")) {
+                state = buttonState.apply;
+            } else {
+                state = buttonState.applyAndCalibrate;
+            }   
+        } else {
+            if (state == buttonState.apply) {
+                state = buttonState.disabled;
+            } else if (state == buttonState.applyAndCalibrate) {
+                state = buttonState.calibrate;
+            }
+        }
+        
+        lastConfiguration = settings;
+    }
+
+    function initializeButtonState() {
+        var settings = composeConfigurationSettings();
+        var bodySetting = settings["bodyConfiguration"];
+        var headSetting = settings["headConfiguration"];
+        var headOverride = headSetting["override"];
+        var handSetting = settings["handConfiguration"];
+        var handOverride = handSetting["override"];
+
+
+        if ((!handOverride) && (!headOverride) && (bodySetting === "None")) {
+            state = buttonState.disabled;
+        } else {
+            state = buttonState.calibrate;
+        }   
+    }
+
+    function updateCalibrationButton() {
+        updateButtonState();
+        updateCalibrationText();
+    }
+
+    function updateCalibrationText() {
+        if (buttonState.disabled == state) {
+            calibrationButton.enabled = false;
+            calibrationButton.text = "Apply";
+        } else if (buttonState.apply == state) {
+            calibrationButton.enabled = true;
+            calibrationButton.text = "Apply";
+        } else if (buttonState.applyAndCalibrate == state) {
+            calibrationButton.enabled = true;
+            calibrationButton.text =  "Apply And Calibrate";
+        } else if (buttonState.calibrate == state) {
+            calibrationButton.enabled = true;
+            calibrationButton.text = "Calibrate";
+        }
+    }
+
+    function composeConfigurationSettings() {
+        var trackerConfiguration = "";
+        var overrideHead = false;
+        var overrideHandController = false;
+
+        if (shouldersChecked && chestChecked) {
+            trackerConfiguration = "FeetHipsChestAndShoulders";
+        } else if (shouldersChecked) {
+            trackerConfiguration = "FeetHipsAndShoulders";
+        } else if (chestChecked) {
+            trackerConfiguration = "FeetHipsAndChest";
+        } else if (hipsChecked) {
+            trackerConfiguration = "FeetAndHips";
+        } else if (feetChecked) {
+            trackerConfiguration = "Feet";
+        } else {
+            trackerConfiguration = "None";
+        }
+
+        if (headPuck) {
+            overrideHead = true;
+        } else if (hmdHead) {
+            overrideHead = false;
+        }
+
+        if (handController) {
+            overrideHandController = false;
+        } else if (handPuck) {
+            overrideHandController = true;
+        }
+
+        var headObject = {
+            "override": overrideHead,
+            "Y": headYOffset.value,
+            "Z": headZOffset.value
+        }
+
+        var handObject = {
+            "override": overrideHandController,
+            "Y": handYOffset.value,
+            "Z": handZOffset.value
+        }
+        
+        var settingsObject = {
+            "bodyConfiguration": trackerConfiguration,
+            "headConfiguration": headObject,
+            "handConfiguration": handObject 
+        }
+
+        return settingsObject;
+    }
+
+    function sendConfigurationSettings() {
+        var settings = composeConfigurationSettings();
+        InputConfiguration.setConfigurationSettings(settings, pluginName);
+        updateCalibrationButton();
+    }
+}

interface/resources/qml/hifi/tablet/Tablet.qml

@@ -1,26 +1,16 @@
 import QtQuick 2.5
 import QtGraphicalEffects 1.0
+
 import "../../styles-uit"
+import "../audio" as HifiAudio
 
 Item {
     id: tablet
     objectName: "tablet"
-    property double micLevel: 0.8
-    property bool micEnabled: true
     property int rowIndex: 0
     property int columnIndex: 0
     property int count: (flowMain.children.length - 1)
 
-    // called by C++ code to keep mic state updated
-    function setMicEnabled(newMicEnabled) {
-        tablet.micEnabled = newMicEnabled;
-    }
-
-    // called by C++ code to keep audio bar updated
-    function setMicLevel(newMicLevel) {
-        tablet.micLevel = newMicLevel;
-    }
-
     // used to look up a button by its uuid
     function findButtonIndex(uuid) {
         if (!uuid) {
@@ -89,6 +79,16 @@ Item {
     Rectangle {
         id: bgTopBar
         height: 90
+
+        anchors {
+            top: parent.top
+            topMargin: 0
+            left: parent.left
+            leftMargin: 0
+            right: parent.right
+            rightMargin: 0
+        }
+
         gradient: Gradient {
             GradientStop {
                 position: 0
@@ -100,108 +100,13 @@ Item {
                 color: "#1e1e1e"
             }
         }
-        anchors.right: parent.right
-        anchors.rightMargin: 0
-        anchors.left: parent.left
-        anchors.leftMargin: 0
-        anchors.topMargin: 0
-        anchors.top: parent.top
 
-        Item {
-            id: audioIcon
-            anchors.verticalCenter: parent.verticalCenter
-            width: 40
-            height: 40
-            anchors.left: parent.left
-            anchors.leftMargin: 5
-
-            Image {
-                id: micIcon
-                source: "../../../icons/tablet-icons/mic.svg"
-            }
-
-            Item {
-                visible: (!tablet.micEnabled && !toggleMuteMouseArea.containsMouse)
-                         || (tablet.micEnabled && toggleMuteMouseArea.containsMouse)
-
-                Image {
-                    id: muteIcon
-                    source: "../../../icons/tablet-icons/mic-mute.svg"
-                }
-
-                ColorOverlay {
-                    anchors.fill: muteIcon
-                    source: muteIcon
-                    color: toggleMuteMouseArea.containsMouse ? "#a0a0a0" : "#ff0000"
-                }
-            }
-        }
-
-        Item {
-            id: audioBar
-            width: 170
-            height: 10
-            anchors.left: parent.left
-            anchors.leftMargin: 50
-            anchors.verticalCenter: parent.verticalCenter
-            Rectangle {
-                id: audioBarBase
-                color: "#333333"
-                radius: 5
-                anchors.fill: parent
-            }
-            Rectangle {
-                id: audioBarMask
-                width: parent.width * tablet.micLevel
-                color: "#333333"
-                radius: 5
-                anchors.bottom: parent.bottom
-                anchors.bottomMargin: 0
-                anchors.top: parent.top
-                anchors.topMargin: 0
-                anchors.left: parent.left
-                anchors.leftMargin: 0
-            }
-            LinearGradient {
-                anchors.fill: audioBarMask
-                source: audioBarMask
-                start: Qt.point(0, 0)
-                end: Qt.point(170, 0)
-                gradient: Gradient {
-                    GradientStop {
-                        position: 0
-                        color: "#2c8e72"
-                    }
-                    GradientStop {
-                        position: 0.8
-                        color: "#1fc6a6"
-                    }
-                    GradientStop {
-                        position: 0.81
-                        color: "#ea4c5f"
-                    }
-                    GradientStop {
-                        position: 1
-                        color: "#ea4c5f"
-                    }
-                }
-            }
-        }
-
-        MouseArea {
-            id: toggleMuteMouseArea
+        HifiAudio.MicBar {
             anchors {
-                left: audioIcon.left
-                right: audioBar.right
-                top: audioIcon.top
-                bottom: audioIcon.bottom
+                left: parent.left
+                leftMargin: 30
+                verticalCenter: parent.verticalCenter
             }
-
-            hoverEnabled: true
-            preventStealing: true
-            propagateComposedEvents: false
-            scrollGestureEnabled: false
-            onClicked: tabletRoot.toggleMicEnabled()
         }
 
         RalewaySemiBold {
@@ -260,27 +165,6 @@ Item {
         }
     }
 
-    states: [
-        State {
-            name: "muted state"
-
-            PropertyChanges {
-                target: muteText
-                text: "UNMUTE"
-            }
-
-            PropertyChanges {
-                target: muteIcon
-                visible: micEnabled
-            }
-
-            PropertyChanges {
-                target: tablet
-                micLevel: 0
-            }
-        }
-    ]
-
     function setCurrentItemState(state) {
         var index = rowIndex + columnIndex;
 

interface/resources/qml/hifi/tablet/TabletAudioBuffers.qml

@@ -1,7 +1,7 @@
 //
-//  TabletAudioPreferences.qml
+//  TabletAudioBuffers.qml
 //
-//  Created by Davd Rowe on 7 Mar 2017.
+//  Created by Zach Pomerantz on 6/5/2017.
 //  Copyright 2017 High Fidelity, Inc.
 //
 //  Distributed under the Apache License, Version 2.0.
@@ -17,7 +17,9 @@ StackView {
     id: profileRoot
     initialItem: root
     objectName: "stack"
-    property string title: "Audio Settings"
+    property string title: "Audio Buffers"
+    property alias gotoPreviousApp: root.gotoPreviousApp;
+    property var eventBridge;
 
     signal sendToScript(var message);
 
@@ -31,7 +33,7 @@ StackView {
 
     TabletPreferencesDialog {
         id: root
-        objectName: "TabletAudioPreferences"
-        showCategories: ["Audio"]
+        objectName: "TabletAudioBuffersDialog"
+        showCategories: ["Audio Buffers"]
     }
 }

interface/resources/qml/hifi/tablet/TabletRoot.qml

@@ -147,10 +147,6 @@ Item {
         }
     }
 
-    function toggleMicEnabled() {
-        ApplicationInterface.toggleMuteAudio();
-    }
-
     function setUsername(newUsername) {
         username = newUsername;
     }

interface/resources/qml/hifi/tablet/WindowRoot.qml

@@ -71,10 +71,6 @@ Windows.ScrollingWindow {
         }
     }
 
-    function toggleMicEnabled() {
-        ApplicationInterface.toggleMuteAudio();
-    }
-
     function setUsername(newUsername) {
         username = newUsername;
     }

interface/resources/qml/styles-uit/HifiConstants.qml

@@ -333,5 +333,8 @@ Item {
         readonly property string vol_x_2: "\ue015"
         readonly property string vol_x_3: "\ue016"
         readonly property string vol_x_4: "\ue017"
+        readonly property string source: "\ue01c"
+        readonly property string playback_play: "\ue01d"
+        readonly property string stop_square: "\ue01e"
     }
 }

interface/resources/qml/styles-uit/Separator.qml

@@ -0,0 +1,41 @@
+//
+//  Separator.qml
+//
+//  Created by Zach Fox on 2017-06-06
+//  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
+//
+
+import QtQuick 2.5
+import "../styles-uit"
+
+Item {
+    // Size
+    height: 2;
+    width: parent.width;
+
+    Rectangle {
+        // Size
+        width: parent.width;
+        height: 1;
+        // Anchors
+        anchors.left: parent.left;
+        anchors.bottom: parent.bottom;
+        anchors.bottomMargin: height;
+        // Style
+        color: hifi.colors.baseGrayShadow;
+    }
+
+    Rectangle {
+        // Size
+        width: parent.width;
+        height: 1;
+        // Anchors
+        anchors.left: parent.left;
+        anchors.bottom: parent.bottom;
+        // Style
+        color: hifi.colors.baseGrayHighlight;
+    }
+}

interface/src/Application.cpp

@@ -88,6 +88,7 @@
 #include <UserActivityLoggerScriptingInterface.h>
 #include <LogHandler.h>
 #include "LocationBookmarks.h"
+#include <LocationScriptingInterface.h>
 #include <MainWindow.h>
 #include <MappingRequest.h>
 #include <MessagesClient.h>
@@ -108,6 +109,7 @@
 #include <plugins/PluginManager.h>
 #include <plugins/PluginUtils.h>
 #include <plugins/SteamClientPlugin.h>
+#include <plugins/InputConfiguration.h>
 #include <RecordingScriptingInterface.h>
 #include <RenderableWebEntityItem.h>
 #include <RenderShadowTask.h>
@@ -115,6 +117,7 @@
 #include <RenderDeferredTask.h>
 #include <RenderForwardTask.h>
 #include <RenderViewTask.h>
+#include <SecondaryCamera.h>
 #include <ResourceCache.h>
 #include <ResourceRequest.h>
 #include <SandboxUtils.h>
@@ -149,16 +152,15 @@
 #include "InterfaceLogging.h"
 #include "LODManager.h"
 #include "ModelPackager.h"
+#include "scripting/Audio.h"
 #include "networking/CloseEventSender.h"
 #include "scripting/TestScriptingInterface.h"
 #include "scripting/AccountScriptingInterface.h"
 #include "scripting/AssetMappingsScriptingInterface.h"
-#include "scripting/AudioDeviceScriptingInterface.h"
 #include "scripting/ClipboardScriptingInterface.h"
 #include "scripting/DesktopScriptingInterface.h"
 #include "scripting/GlobalServicesScriptingInterface.h"
 #include "scripting/HMDScriptingInterface.h"
-#include "scripting/LocationScriptingInterface.h"
 #include "scripting/MenuScriptingInterface.h"
 #include "scripting/SettingsScriptingInterface.h"
 #include "scripting/WindowScriptingInterface.h"
@@ -250,6 +252,8 @@ static const QString MARKETPLACE_CDN_HOSTNAME = "mpassets.highfidelity.com";
 static const int INTERVAL_TO_CHECK_HMD_WORN_STATUS = 500; // milliseconds
 static const QString DESKTOP_DISPLAY_PLUGIN_NAME = "Desktop";
 
+static const QString SYSTEM_TABLET = "com.highfidelity.interface.tablet.system";
+
 const QHash<QString, Application::AcceptURLMethod> Application::_acceptedExtensions {
     { SVO_EXTENSION, &Application::importSVOFromURL },
     { SVO_JSON_EXTENSION, &Application::importSVOFromURL },
@@ -438,6 +442,34 @@ static const QString STATE_NAV_FOCUSED = "NavigationFocused";
 
 bool setupEssentials(int& argc, char** argv, bool runningMarkerExisted) {
     const char** constArgv = const_cast<const char**>(argv);
+
+    // HRS: I could not figure out how to move these any earlier in startup, so when using this option, be sure to also supply
+    // --allowMultipleInstances
+    auto reportAndQuit = [&](const char* commandSwitch, std::function<void(FILE* fp)> report) {
+        const char* reportfile = getCmdOption(argc, constArgv, commandSwitch);
+        // Reports to the specified file, because stdout is set up to be captured for logging.
+        if (reportfile) {
+            FILE* fp = fopen(reportfile, "w");
+            if (fp) {
+                report(fp);
+                fclose(fp);
+                if (!runningMarkerExisted) { // don't leave ours around
+                    RunningMarker runingMarker(RUNNING_MARKER_FILENAME);
+                    runingMarker.deleteRunningMarkerFile(); // happens in deleter, but making the side-effect explicit.
+                }
+                _exit(0);
+            }
+        }
+    };
+    reportAndQuit("--protocolVersion", [&](FILE* fp) {
+        DependencyManager::set<AddressManager>();
+        auto version = DependencyManager::get<AddressManager>()->protocolVersion();
+        fputs(version.toLatin1().data(), fp);
+    });
+    reportAndQuit("--version", [&](FILE* fp) {
+        fputs(BuildInfo::VERSION.toLatin1().data(), fp);
+    });
+
     const char* portStr = getCmdOption(argc, constArgv, "--listenPort");
     const int listenPort = portStr ? atoi(portStr) : INVALID_PORT;
 
@@ -507,6 +539,7 @@ bool setupEssentials(int& argc, char** argv, bool runningMarkerExisted) {
     DependencyManager::set<HMDScriptingInterface>();
     DependencyManager::set<ResourceScriptingInterface>();
     DependencyManager::set<TabletScriptingInterface>();
+    DependencyManager::set<InputConfiguration>();
     DependencyManager::set<ToolbarScriptingInterface>();
     DependencyManager::set<UserActivityLoggerScriptingInterface>();
     DependencyManager::set<AssetMappingsScriptingInterface>();
@@ -577,7 +610,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     _undoStackScriptingInterface(&_undoStack),
     _entitySimulation(new PhysicalEntitySimulation()),
     _physicsEngine(new PhysicsEngine(Vectors::ZERO)),
-    _entityClipboardRenderer(false, this, this),
     _entityClipboard(new EntityTree()),
     _lastQueriedTime(usecTimestampNow()),
     _previousScriptLocation("LastScriptLocation", DESKTOP_LOCATION),
@@ -710,9 +742,9 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
             recorder->recordFrame(AUDIO_FRAME_TYPE, audio);
         }
     });
+    audioIO->startThread();
 
-    auto audioScriptingInterface = DependencyManager::set<AudioScriptingInterface>();
-    connect(audioIO.data(), &AudioClient::muteToggled, this, &Application::audioMuteToggled);
+    auto audioScriptingInterface = DependencyManager::set<AudioScriptingInterface, scripting::Audio>();
     connect(audioIO.data(), &AudioClient::mutedByMixer, audioScriptingInterface.data(), &AudioScriptingInterface::mutedByMixer);
     connect(audioIO.data(), &AudioClient::receivedFirstPacket, audioScriptingInterface.data(), &AudioScriptingInterface::receivedFirstPacket);
     connect(audioIO.data(), &AudioClient::disconnected, audioScriptingInterface.data(), &AudioScriptingInterface::disconnected);
@@ -728,8 +760,8 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
             audioScriptingInterface->environmentMuted();
         }
     });
-
-    audioIO->startThread();
+    connect(this, &Application::activeDisplayPluginChanged,
+        reinterpret_cast<scripting::Audio*>(audioScriptingInterface.data()), &scripting::Audio::onContextChanged);
 
     ResourceManager::init();
     // Make sure we don't time out during slow operations at startup
@@ -952,7 +984,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     // Make sure we don't time out during slow operations at startup
     updateHeartbeat();
 
-    connect(this, SIGNAL(aboutToQuit()), this, SLOT(aboutToQuit()));
+    connect(this, SIGNAL(aboutToQuit()), this, SLOT(onAboutToQuit()));
 
     // hook up bandwidth estimator
     QSharedPointer<BandwidthRecorder> bandwidthRecorder = DependencyManager::get<BandwidthRecorder>();
@@ -1446,7 +1478,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     });
     sendStatsTimer->start();
 
-
     // Periodically check for count of nearby avatars
     static int lastCountOfNearbyAvatars = -1;
     QTimer* checkNearbyAvatarsTimer = new QTimer(this);
@@ -1604,12 +1635,12 @@ QString Application::getUserAgent() {
     return userAgent;
 }
 
-void Application::toggleTabletUI() const {
+void Application::toggleTabletUI(bool shouldOpen) const {
     auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
     auto hmd = DependencyManager::get<HMDScriptingInterface>();
-    TabletProxy* tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
+    TabletProxy* tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet(SYSTEM_TABLET));
     bool messageOpen = tablet->isMessageDialogOpen();
-    if (!messageOpen || (messageOpen && !hmd->getShouldShowTablet())) {
+    if ((!messageOpen || (messageOpen && !hmd->getShouldShowTablet())) && !(shouldOpen && hmd->getShouldShowTablet())) {
         auto HMD = DependencyManager::get<HMDScriptingInterface>();
         HMD->toggleShouldShowTablet();
     }
@@ -1641,7 +1672,7 @@ void Application::updateHeartbeat() const {
     static_cast<DeadlockWatchdogThread*>(_deadlockWatchdogThread)->updateHeartbeat();
 }
 
-void Application::aboutToQuit() {
+void Application::onAboutToQuit() {
     emit beforeAboutToQuit();
 
     foreach(auto inputPlugin, PluginManager::getInstance()->getInputPlugins()) {
@@ -1720,6 +1751,10 @@ void Application::cleanupBeforeQuit() {
 
     // Cleanup all overlays after the scripts, as scripts might add more
     _overlays.cleanupAllOverlays();
+    // The cleanup process enqueues the transactions but does not process them.  Calling this here will force the actual 
+    // removal of the items.  
+    // See https://highfidelity.fogbugz.com/f/cases/5328
+    _main3DScene->processTransactionQueue();
 
     // first stop all timers directly or by invokeMethod
     // depending on what thread they run in
@@ -1866,6 +1901,7 @@ void Application::initializeGL() {
     render::CullFunctor cullFunctor = LODManager::shouldRender;
     static const QString RENDER_FORWARD = "HIFI_RENDER_FORWARD";
     bool isDeferred = !QProcessEnvironment::systemEnvironment().contains(RENDER_FORWARD);
+    _renderEngine->addJob<SecondaryCameraRenderTask>("SecondaryCameraFrame", cullFunctor);
     _renderEngine->addJob<RenderViewTask>("RenderMainView", cullFunctor, isDeferred);
     _renderEngine->load();
     _renderEngine->registerScene(_main3DScene);
@@ -1980,7 +2016,6 @@ void Application::initializeUi() {
     surfaceContext->setContextProperty("Stats", Stats::getInstance());
     surfaceContext->setContextProperty("Settings", SettingsScriptingInterface::getInstance());
     surfaceContext->setContextProperty("ScriptDiscoveryService", DependencyManager::get<ScriptEngines>().data());
-    surfaceContext->setContextProperty("AudioDevice", AudioDeviceScriptingInterface::getInstance());
     surfaceContext->setContextProperty("AvatarBookmarks", DependencyManager::get<AvatarBookmarks>().data());
     surfaceContext->setContextProperty("LocationBookmarks", DependencyManager::get<LocationBookmarks>().data());
 
@@ -1989,6 +2024,7 @@ void Application::initializeUi() {
     surfaceContext->setContextProperty("TextureCache", DependencyManager::get<TextureCache>().data());
     surfaceContext->setContextProperty("ModelCache", DependencyManager::get<ModelCache>().data());
     surfaceContext->setContextProperty("SoundCache", DependencyManager::get<SoundCache>().data());
+    surfaceContext->setContextProperty("InputConfiguration", DependencyManager::get<InputConfiguration>().data());
 
     surfaceContext->setContextProperty("Account", AccountScriptingInterface::getInstance());
     surfaceContext->setContextProperty("Tablet", DependencyManager::get<TabletScriptingInterface>().data());
@@ -2309,12 +2345,6 @@ void Application::runTests() {
     runUnitTests();
 }
 
-void Application::audioMuteToggled() const {
-    QAction* muteAction = Menu::getInstance()->getActionForOption(MenuOption::MuteAudio);
-    Q_CHECK_PTR(muteAction);
-    muteAction->setChecked(DependencyManager::get<AudioClient>()->isMuted());
-}
-
 void Application::faceTrackerMuteToggled() {
 
     QAction* muteAction = Menu::getInstance()->getActionForOption(MenuOption::MuteFaceTracking);
@@ -2384,7 +2414,7 @@ void Application::showHelp() {
     queryString.addQueryItem("handControllerName", handControllerName);
     queryString.addQueryItem("defaultTab", defaultTab);
     auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
-    TabletProxy* tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
+    TabletProxy* tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet(SYSTEM_TABLET));
     tablet->gotoWebScreen(INFO_HELP_PATH + "?" + queryString.toString());
     //InfoView::show(INFO_HELP_PATH, false, queryString.toString());
 }
@@ -2477,8 +2507,11 @@ void Application::handleSandboxStatus(QNetworkReply* reply) {
     Setting::Handle<bool> tutorialComplete{ "tutorialComplete", false };
     Setting::Handle<bool> firstRun{ Settings::firstRun, true };
 
+    const QString HIFI_SKIP_TUTORIAL_COMMAND_LINE_KEY = "--skipTutorial";
+    // Skips tutorial/help behavior, and does NOT clear firstRun setting.
+    bool skipTutorial = arguments().contains(HIFI_SKIP_TUTORIAL_COMMAND_LINE_KEY);
     bool isTutorialComplete = tutorialComplete.get();
-    bool shouldGoToTutorial = isUsingHMDAndHandControllers && hasTutorialContent && !isTutorialComplete;
+    bool shouldGoToTutorial = isUsingHMDAndHandControllers && hasTutorialContent && !isTutorialComplete && !skipTutorial;
 
     qCDebug(interfaceapp) << "HMD:" << hasHMD << ", Hand Controllers: " << hasHandControllers << ", Using HMD: " << isUsingHMDAndHandControllers;
     qCDebug(interfaceapp) << "Tutorial version:" << contentVersion << ", sufficient:" << hasTutorialContent <<
@@ -2521,14 +2554,9 @@ void Application::handleSandboxStatus(QNetworkReply* reply) {
         }
     } else {
 
-        bool isFirstRun = firstRun.get();
-
-        if (isFirstRun) {
-            showHelp();
-        }
-
         // If this is a first run we short-circuit the address passed in
-        if (isFirstRun) {
+        if (firstRun.get() && !skipTutorial) {
+            showHelp();
             if (isUsingHMDAndHandControllers) {
                 if (sandboxIsRunning) {
                     qCDebug(interfaceapp) << "Home sandbox appears to be running, going to Home.";
@@ -2566,7 +2594,9 @@ void Application::handleSandboxStatus(QNetworkReply* reply) {
     _connectionMonitor.init();
 
     // After all of the constructor is completed, then set firstRun to false.
-    firstRun.set(false);
+    if (!skipTutorial) {
+        firstRun.set(false);
+    }
 }
 
 bool Application::importJSONFromURL(const QString& urlString) {
@@ -2840,7 +2870,7 @@ void Application::keyPressEvent(QKeyEvent* event) {
                 if (isShifted && isMeta) {
                     auto offscreenUi = DependencyManager::get<OffscreenUi>();
                     offscreenUi->togglePinned();
-                    //offscreenUi->getRootContext()->engine()->clearComponentCache();
+                    //offscreenUi->getSurfaceContext()->engine()->clearComponentCache();
                     //OffscreenUi::information("Debugging", "Component cache cleared");
                     // placeholder for dialogs being converted to QML.
                 }
@@ -2881,6 +2911,12 @@ void Application::keyPressEvent(QKeyEvent* event) {
                 Menu::getInstance()->triggerOption(MenuOption::DefaultSkybox);
                 break;
 
+            case Qt::Key_M:
+                if (isMeta) {
+                    DependencyManager::get<AudioClient>()->toggleMute();
+                }
+                break;
+
             case Qt::Key_N:
                 if (!isOption && !isShifted && isMeta) {
                     DependencyManager::get<NodeList>()->toggleIgnoreRadius();
@@ -3978,11 +4014,6 @@ void Application::init() {
     DependencyManager::get<NodeList>()->sendDomainServerCheckIn();
 
     getEntities()->init();
-    {
-        QMutexLocker viewLocker(&_viewMutex);
-        getEntities()->setViewFrustum(_viewFrustum);
-    }
-
     getEntities()->setEntityLoadingPriorityFunction([this](const EntityItem& item) {
         auto dims = item.getDimensions();
         auto maxSize = glm::compMax(dims);
@@ -4012,13 +4043,6 @@ void Application::init() {
     // of events related clicking, hovering over, and entering entities
     getEntities()->connectSignalsToSlots(entityScriptingInterface.data());
 
-    _entityClipboardRenderer.init();
-    {
-        QMutexLocker viewLocker(&_viewMutex);
-        _entityClipboardRenderer.setViewFrustum(_viewFrustum);
-    }
-    _entityClipboardRenderer.setTree(_entityClipboard);
-
     // Make sure any new sounds are loaded as soon as know about them.
     connect(tree.get(), &EntityTree::newCollisionSoundURL, this, [this](QUrl newURL, EntityItemID id) {
         EntityTreePointer tree = getEntities()->getTree();
@@ -4122,7 +4146,7 @@ void Application::updateMyAvatarLookAtPosition() {
                 lookAtSpot = transformPoint(worldHeadMat, glm::vec3(0.0f, 0.0f, TREE_SCALE));
             } else {
                 lookAtSpot = myAvatar->getHead()->getEyePosition() +
-                    (myAvatar->getHead()->getFinalOrientationInWorldFrame() * glm::vec3(0.0f, 0.0f, -TREE_SCALE));
+                    (myAvatar->getHead()->getFinalOrientationInWorldFrame() * glm::vec3(0.0f, 0.0f, TREE_SCALE));
             }
         }
 
@@ -4462,10 +4486,11 @@ void Application::update(float deltaTime) {
             } else {
                 const quint64 MUTE_MICROPHONE_AFTER_USECS = 5000000;  //5 secs
                 Menu* menu = Menu::getInstance();
-                if (menu->isOptionChecked(MenuOption::AutoMuteAudio) && !menu->isOptionChecked(MenuOption::MuteAudio)) {
+                auto audioClient = DependencyManager::get<AudioClient>();
+                if (menu->isOptionChecked(MenuOption::AutoMuteAudio) && !audioClient->isMuted()) {
                     if (_lastFaceTrackerUpdate > 0
                         && ((usecTimestampNow() - _lastFaceTrackerUpdate) > MUTE_MICROPHONE_AFTER_USECS)) {
-                        menu->triggerOption(MenuOption::MuteAudio);
+                        audioClient->toggleMute();
                         _lastFaceTrackerUpdate = 0;
                     }
                 } else {
@@ -5017,9 +5042,6 @@ QRect Application::getDesirableApplicationGeometry() const {
     return applicationGeometry;
 }
 
-// FIXME, preprocessor guard this check to occur only in DEBUG builds
-static QThread * activeRenderingThread = nullptr;
-
 PickRay Application::computePickRay(float x, float y) const {
     vec2 pickPoint { x, y };
     PickRay result;
@@ -5090,7 +5112,6 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
     auto myAvatar = getMyAvatar();
     myAvatar->preDisplaySide(renderArgs);
 
-    activeRenderingThread = QThread::currentThread();
     PROFILE_RANGE(render, __FUNCTION__);
     PerformanceTimer perfTimer("display");
     PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "Application::displaySide()");
@@ -5163,8 +5184,6 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
         // Before the deferred pass, let's try to use the render engine
         _renderEngine->run();
     }
-
-    activeRenderingThread = nullptr;
 }
 
 void Application::resetSensors(bool andReload) {
@@ -5294,6 +5313,11 @@ void Application::nodeActivated(SharedNodePointer node) {
 
     if (node->getType() == NodeType::AvatarMixer) {
         // new avatar mixer, send off our identity packet on next update loop
+        // Reset skeletonModelUrl if the last server modified our choice.
+        static const QUrl empty{};
+        if (getMyAvatar()->getFullAvatarURLFromPreferences() != getMyAvatar()->cannonicalSkeletonModelURL(empty)) {
+            getMyAvatar()->resetFullAvatarURL();
+        }
         getMyAvatar()->markIdentityDataChanged();
         getMyAvatar()->resetLastSent();
     }
@@ -5514,7 +5538,6 @@ void Application::registerScriptEngineWithApplicationServices(ScriptEngine* scri
     scriptEngine->registerGlobalObject("Stats", Stats::getInstance());
     scriptEngine->registerGlobalObject("Settings", SettingsScriptingInterface::getInstance());
     scriptEngine->registerGlobalObject("Snapshot", DependencyManager::get<Snapshot>().data());
-    scriptEngine->registerGlobalObject("AudioDevice", AudioDeviceScriptingInterface::getInstance());
     scriptEngine->registerGlobalObject("AudioStats", DependencyManager::get<AudioClient>()->getStats().data());
     scriptEngine->registerGlobalObject("AudioScope", DependencyManager::get<AudioScope>().data());
     scriptEngine->registerGlobalObject("AvatarBookmarks", DependencyManager::get<AvatarBookmarks>().data());
@@ -5579,6 +5602,7 @@ void Application::registerScriptEngineWithApplicationServices(ScriptEngine* scri
     connect(scriptEngine, &ScriptEngine::errorMessage, DependencyManager::get<ScriptEngines>().data(), &ScriptEngines::onErrorMessage);
     connect(scriptEngine, &ScriptEngine::warningMessage, DependencyManager::get<ScriptEngines>().data(), &ScriptEngines::onWarningMessage);
     connect(scriptEngine, &ScriptEngine::infoMessage, DependencyManager::get<ScriptEngines>().data(), &ScriptEngines::onInfoMessage);
+    connect(scriptEngine, &ScriptEngine::clearDebugWindow, DependencyManager::get<ScriptEngines>().data(), &ScriptEngines::onClearDebugWindow);
 }
 
 bool Application::canAcceptURL(const QString& urlString) const {
@@ -5793,38 +5817,24 @@ bool Application::displayAvatarAttachmentConfirmationDialog(const QString& name)
     }
 }
 
-void Application::toggleRunningScriptsWidget() const {    
-    auto scriptEngines = DependencyManager::get<ScriptEngines>();
-    bool scriptsRunning = !scriptEngines->getRunningScripts().isEmpty();
-    auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
-    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
+void Application::showDialog(const QUrl& widgetUrl, const QUrl& tabletUrl, const QString& name) const {
+    auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet(SYSTEM_TABLET);
+    auto hmd = DependencyManager::get<HMDScriptingInterface>();
+    bool onTablet = false;
 
-    if (tablet->getToolbarMode() || false == scriptsRunning) {
-        static const QUrl url("hifi/dialogs/RunningScripts.qml");
-        DependencyManager::get<OffscreenUi>()->show(url, "RunningScripts");
-    } else {
-        auto hmd = DependencyManager::get<HMDScriptingInterface>();
-        if (!hmd->getShouldShowTablet() && !isHMDMode()) {
-            static const QUrl url("hifi/dialogs/RunningScripts.qml");
-            DependencyManager::get<OffscreenUi>()->show(url, "RunningScripts");
-        } else {
-            static const QUrl url("../../hifi/dialogs/TabletRunningScripts.qml");
-            tablet->pushOntoStack(url);
+    if (!tablet->getToolbarMode()) {
+        onTablet = tablet->pushOntoStack(tabletUrl);
+        if (onTablet) {
+            toggleTabletUI(true);
         }
     }
-    //DependencyManager::get<OffscreenUi>()->show(url, "RunningScripts");
-    //if (_runningScriptsWidget->isVisible()) {
-    //    if (_runningScriptsWidget->hasFocus()) {
-    //        _runningScriptsWidget->hide();
-    //    } else {
-    //        _runningScriptsWidget->raise();
-    //        setActiveWindow(_runningScriptsWidget);
-    //        _runningScriptsWidget->setFocus();
-    //    }
-    //} else {
-    //    _runningScriptsWidget->show();
-    //    _runningScriptsWidget->setFocus();
-    //}
+
+    if (!onTablet) {
+        DependencyManager::get<OffscreenUi>()->show(widgetUrl, name);
+    }
+    if (tablet->getToolbarMode()) {
+        DependencyManager::get<OffscreenUi>()->show(widgetUrl, name);
+    }
 }
 
 void Application::showScriptLogs() {
@@ -5846,7 +5856,7 @@ void Application::showAssetServerWidget(QString filePath) {
         }
     };
     auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
-    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
+    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet(SYSTEM_TABLET));
     auto hmd = DependencyManager::get<HMDScriptingInterface>();
     if (tablet->getToolbarMode()) {
         DependencyManager::get<OffscreenUi>()->show(url, "AssetServer", startUpload);
@@ -5881,21 +5891,6 @@ void Application::addAssetToWorldFromURL(QString url) {
     request->send();
 }
 
-void Application::showDialog(const QString& desktopURL, const QString& tabletURL, const QString& name) const {
-    auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
-    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
-    auto hmd = DependencyManager::get<HMDScriptingInterface>();
-    if (tablet->getToolbarMode()) {
-        DependencyManager::get<OffscreenUi>()->show(desktopURL, name);
-    } else {
-        tablet->pushOntoStack(tabletURL);
-        if (!hmd->getShouldShowTablet() && !isHMDMode()) {
-            hmd->openTablet();
-        }
-        
-    }
-}
-
 void Application::addAssetToWorldFromURLRequestFinished() {
     auto request = qobject_cast<ResourceRequest*>(sender());
     auto url = request->getUrl().toString();
@@ -6379,7 +6374,7 @@ void Application::loadScriptURLDialog() const {
 
 void Application::loadLODToolsDialog() {
     auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
-    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
+    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet(SYSTEM_TABLET));
     if (tablet->getToolbarMode() || (!tablet->getTabletRoot() && !isHMDMode())) {
         auto dialogsManager = DependencyManager::get<DialogsManager>();
         dialogsManager->lodTools();
@@ -6391,7 +6386,7 @@ void Application::loadLODToolsDialog() {
 
 void Application::loadEntityStatisticsDialog() {
     auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
-    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
+    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet(SYSTEM_TABLET));
     if (tablet->getToolbarMode() || (!tablet->getTabletRoot() && !isHMDMode())) {
         auto dialogsManager = DependencyManager::get<DialogsManager>();
         dialogsManager->octreeStatsDetails();
@@ -6402,7 +6397,7 @@ void Application::loadEntityStatisticsDialog() {
 
 void Application::loadDomainConnectionDialog() {
     auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
-    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet("com.highfidelity.interface.tablet.system"));
+    auto tablet = dynamic_cast<TabletProxy*>(tabletScriptingInterface->getTablet(SYSTEM_TABLET));
     if (tablet->getToolbarMode() || (!tablet->getTabletRoot() && !isHMDMode())) {
         auto dialogsManager = DependencyManager::get<DialogsManager>();
         dialogsManager->showDomainConnectionDialog();
@@ -7059,11 +7054,6 @@ void Application::updateSystemTabletMode() {
     }
 }
 
-void Application::toggleMuteAudio() {
-    auto menu = Menu::getInstance();
-    menu->setIsOptionChecked(MenuOption::MuteAudio, !menu->isOptionChecked(MenuOption::MuteAudio));
-}
-
 OverlayID Application::getTabletScreenID() const {
     auto HMD = DependencyManager::get<HMDScriptingInterface>();
     return HMD->getCurrentTabletScreenID();

interface/src/Application.h

@@ -181,7 +181,6 @@ public:
     QUndoStack* getUndoStack() { return &_undoStack; }
     MainWindow* getWindow() const { return _window; }
     EntityTreePointer getEntityClipboard() const { return _entityClipboard; }
-    EntityTreeRenderer* getEntityClipboardRenderer() { return &_entityClipboardRenderer; }
     EntityEditPacketSender* getEntityEditPacketSender() { return &_entityEditSender; }
 
     ivec2 getMouse() const;
@@ -318,11 +317,10 @@ public slots:
     Q_INVOKABLE void loadScriptURLDialog() const;
     void toggleLogDialog();
     void toggleEntityScriptServerLogDialog();
-    void toggleRunningScriptsWidget() const;
     Q_INVOKABLE void showAssetServerWidget(QString filePath = "");
     Q_INVOKABLE void loadAddAvatarBookmarkDialog() const;
 
-    void showDialog(const QString& desktopURL, const QString& tabletURL, const QString& name) const;
+    void showDialog(const QUrl& widgetUrl, const QUrl& tabletUrl, const QString& name) const;
 
     // FIXME: Move addAssetToWorld* methods to own class?
     void addAssetToWorldFromURL(QString url);
@@ -391,7 +389,6 @@ public slots:
 
     void addAssetToWorldMessageClose();
 
-    Q_INVOKABLE void toggleMuteAudio();
     void loadLODToolsDialog();
     void loadEntityStatisticsDialog();
     void loadDomainConnectionDialog();
@@ -401,11 +398,10 @@ private slots:
     void showDesktop();
     void clearDomainOctreeDetails();
     void clearDomainAvatars();
-    void aboutToQuit();
+    void onAboutToQuit();
 
     void resettingDomain();
 
-    void audioMuteToggled() const;
     void faceTrackerMuteToggled();
 
     void activeChanged(Qt::ApplicationState state);
@@ -503,7 +499,7 @@ private:
     static void dragEnterEvent(QDragEnterEvent* event);
 
     void maybeToggleMenuVisible(QMouseEvent* event) const;
-    void toggleTabletUI() const;
+    void toggleTabletUI(bool shouldOpen = false) const;
 
     MainWindow* _window;
     QElapsedTimer& _sessionRunTimer;
@@ -535,7 +531,6 @@ private:
     PhysicalEntitySimulationPointer _entitySimulation;
     PhysicsEnginePointer _physicsEngine;
 
-    EntityTreeRenderer _entityClipboardRenderer;
     EntityTreePointer _entityClipboard;
 
     mutable QMutex _viewMutex { QMutex::Recursive };

interface/src/LODManager.h

@@ -17,6 +17,7 @@
 #include <OctreeConstants.h>
 #include <PIDController.h>
 #include <SimpleMovingAverage.h>
+#include <render/Args.h>
 
 const float DEFAULT_DESKTOP_LOD_DOWN_FPS = 20.0;
 const float DEFAULT_HMD_LOD_DOWN_FPS = 20.0;
@@ -45,7 +46,6 @@ const float ADJUST_LOD_MAX_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE;
 // This controls how low the auto-adjust LOD will go. We want a minimum vision of ~20:500 or 0.04 of default
 const float ADJUST_LOD_MIN_SIZE_SCALE = DEFAULT_OCTREE_SIZE_SCALE * 0.04f;
 
-class RenderArgs;
 class AABox;
 
 class LODManager : public QObject, public Dependency {

interface/src/Menu.cpp

@@ -19,6 +19,7 @@
 #include <AudioClient.h>
 #include <CrashHelpers.h>
 #include <DependencyManager.h>
+#include <TabletScriptingInterface.h>
 #include <display-plugins/DisplayPlugin.h>
 #include <PathUtils.h>
 #include <SettingHandle.h>
@@ -37,6 +38,7 @@
 #include "MainWindow.h"
 #include "render/DrawStatus.h"
 #include "scripting/MenuScriptingInterface.h"
+#include "scripting/HMDScriptingInterface.h"
 #include "ui/DialogsManager.h"
 #include "ui/StandAloneJSConsole.h"
 #include "InterfaceLogging.h"
@@ -94,8 +96,13 @@ Menu::Menu() {
     addActionToQMenuAndActionHash(editMenu, redoAction);
 
     // Edit > Running Scripts
-    addActionToQMenuAndActionHash(editMenu, MenuOption::RunningScripts, Qt::CTRL | Qt::Key_J,
-        qApp, SLOT(toggleRunningScriptsWidget()));
+    auto action = addActionToQMenuAndActionHash(editMenu, MenuOption::RunningScripts, Qt::CTRL | Qt::Key_J);
+    connect(action, &QAction::triggered, [] {
+        static const QUrl widgetUrl("hifi/dialogs/RunningScripts.qml");
+        static const QUrl tabletUrl("../../hifi/dialogs/TabletRunningScripts.qml");
+        static const QString name("RunningScripts");
+        qApp->showDialog(widgetUrl, tabletUrl, name);
+    });
 
     // Edit > Open and Run Script from File... [advanced]
     addActionToQMenuAndActionHash(editMenu, MenuOption::LoadScript, Qt::CTRL | Qt::Key_O,
@@ -143,28 +150,13 @@ Menu::Menu() {
     addActionToQMenuAndActionHash(editMenu, MenuOption::ReloadContent, 0, qApp, SLOT(reloadResourceCaches()),
                                   QAction::NoRole, UNSPECIFIED_POSITION, "Advanced");
 
-
-    // Audio menu ----------------------------------
-    MenuWrapper* audioMenu = addMenu("Audio");
-    auto audioIO = DependencyManager::get<AudioClient>();
-
-    // Audio > Mute
-    addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::MuteAudio, Qt::CTRL | Qt::Key_M, false,
-        audioIO.data(), SLOT(toggleMute()));
-
-    // Audio > Show Level Meter
-    addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::AudioTools, 0, false);
-
-    addCheckableActionToQMenuAndActionHash(audioMenu, MenuOption::AudioNoiseReduction, 0, true,
-        audioIO.data(), SLOT(toggleAudioNoiseReduction()));
-
     // Avatar menu ----------------------------------
     MenuWrapper* avatarMenu = addMenu("Avatar");
     auto avatarManager = DependencyManager::get<AvatarManager>();
     auto avatar = avatarManager->getMyAvatar();
 
     // Avatar > Attachments...
-    auto action = addActionToQMenuAndActionHash(avatarMenu, MenuOption::Attachments);
+    action = addActionToQMenuAndActionHash(avatarMenu, MenuOption::Attachments);
     connect(action, &QAction::triggered, [] {
         qApp->showDialog(QString("hifi/dialogs/AttachmentsDialog.qml"),
             QString("../../hifi/tablet/TabletAttachmentsDialog.qml"), "AttachmentsDialog");
@@ -297,6 +289,14 @@ Menu::Menu() {
             QString("../../hifi/tablet/TabletGeneralPreferences.qml"), "GeneralPreferencesDialog");
     });
 
+    action = addActionToQMenuAndActionHash(settingsMenu, "Audio...");
+    connect(action, &QAction::triggered, [] {
+        static const QUrl widgetUrl("hifi/dialogs/Audio.qml");
+        static const QUrl tabletUrl("../../hifi/audio/Audio.qml");
+        static const QString name("AudioDialog");
+        qApp->showDialog(widgetUrl, tabletUrl, name);
+    });
+
     // Settings > Avatar...
     action = addActionToQMenuAndActionHash(settingsMenu, "Avatar...");
     connect(action, &QAction::triggered, [] {
@@ -311,6 +311,17 @@ Menu::Menu() {
             QString("../../hifi/tablet/TabletLodPreferences.qml"), "LodPreferencesDialog");
     });
 
+    action = addActionToQMenuAndActionHash(settingsMenu, "Controller Settings");
+    connect(action, &QAction::triggered, [] {
+            auto tablet = DependencyManager::get<TabletScriptingInterface>()->getTablet("com.highfidelity.interface.tablet.system");
+            auto hmd = DependencyManager::get<HMDScriptingInterface>();
+            tablet->loadQMLSource("ControllerSettings.qml");
+
+            if (!hmd->getShouldShowTablet()) {
+                hmd->toggleShouldShowTablet();
+            }
+        });
+
     // Settings > Control with Speech [advanced]
 #if defined(Q_OS_MAC) || defined(Q_OS_WIN)
     auto speechRecognizer = DependencyManager::get<SpeechRecognizer>();
@@ -619,10 +630,11 @@ Menu::Menu() {
 
     action = addActionToQMenuAndActionHash(audioDebugMenu, "Buffers...");
     connect(action, &QAction::triggered, [] {
-        qApp->showDialog(QString("hifi/dialogs/AudioPreferencesDialog.qml"),
-            QString("../../hifi/tablet/TabletAudioPreferences.qml"), "AudioPreferencesDialog");
+        qApp->showDialog(QString("hifi/dialogs/AudioBuffers.qml"),
+            QString("../../hifi/tablet/TabletAudioBuffers.qml"), "AudioBuffersDialog");
     });
 
+    auto audioIO = DependencyManager::get<AudioClient>();
     addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoServerAudio, 0, false,
         audioIO.data(), SLOT(toggleServerEcho()));
     addCheckableActionToQMenuAndActionHash(audioDebugMenu, MenuOption::EchoLocalAudio, 0, false,

interface/src/Menu.h

@@ -36,7 +36,6 @@ namespace MenuOption {
     const QString AssetMigration = "ATP Asset Migration";
     const QString AssetServer = "Asset Browser";
     const QString Attachments = "Attachments...";
-    const QString AudioNoiseReduction = "Noise Reduction";
     const QString AudioScope = "Show Scope";
     const QString AudioScopeFiftyFrames = "Fifty";
     const QString AudioScopeFiveFrames = "Five";
@@ -44,7 +43,6 @@ namespace MenuOption {
     const QString AudioScopePause = "Pause Scope";
     const QString AudioScopeTwentyFrames = "Twenty";
     const QString AudioStatsShowInjectedStreams = "Audio Stats Show Injected Streams";
-    const QString AudioTools = "Show Level Meter";
     const QString AutoMuteAudio = "Auto Mute Microphone";
     const QString AvatarReceiveStats = "Show Receive Stats";
     const QString AvatarBookmarks = "Avatar Bookmarks";
@@ -123,7 +121,6 @@ namespace MenuOption {
     const QString LogExtraTimings = "Log Extra Timing Details";
     const QString LowVelocityFilter = "Low Velocity Filter";
     const QString MeshVisible = "Draw Mesh";
-    const QString MuteAudio = "Mute Microphone";
     const QString MuteEnvironment = "Mute Environment";
     const QString MuteFaceTracking = "Mute Face Tracking";
     const QString NamesAboveHeads = "Names Above Heads";

interface/src/SecondaryCamera.cpp

@@ -0,0 +1,125 @@
+//
+//  SecondaryCamera.cpp
+//  interface/src
+//
+//  Created by Samuel Gateau, Howard Stearns, and Zach Fox on 2017-06-08.
+//  Copyright 2013 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "SecondaryCamera.h"
+#include <TextureCache.h>
+#include <gpu/Context.h>
+
+using RenderArgsPointer = std::shared_ptr<RenderArgs>;
+
+void MainRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred) {
+
+    task.addJob<RenderShadowTask>("RenderShadowTask", cullFunctor);
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor);
+    assert(items.canCast<RenderFetchCullSortTask::Output>());
+    if (!isDeferred) {
+        task.addJob<RenderForwardTask>("Forward", items);
+    } else {
+        task.addJob<RenderDeferredTask>("RenderDeferredTask", items);
+    }
+}
+
+void SecondaryCameraRenderTaskConfig::resetSize(int width, int height) { // FIXME: Add an arg here for "destinationFramebuffer"
+    bool wasEnabled = isEnabled();
+    setEnabled(false);
+    auto textureCache = DependencyManager::get<TextureCache>();
+    textureCache->resetSpectatorCameraFramebuffer(width, height); // FIXME: Call the correct reset function based on the "destinationFramebuffer" arg
+    setEnabled(wasEnabled);
+}
+
+void SecondaryCameraRenderTaskConfig::resetSizeSpectatorCamera(int width, int height) { // Carefully adjust the framebuffer / texture.
+    resetSize(width, height);
+}
+
+class BeginSecondaryCameraFrame {  // Changes renderContext for our framebuffer and and view.
+    glm::vec3 _position{};
+    glm::quat _orientation{};
+    float _vFoV{};
+    float _nearClipPlaneDistance{};
+    float _farClipPlaneDistance{};
+public:
+    using Config = BeginSecondaryCameraFrameConfig;
+    using JobModel = render::Job::ModelO<BeginSecondaryCameraFrame, RenderArgsPointer, Config>;
+    BeginSecondaryCameraFrame() {
+        _cachedArgsPointer = std::make_shared<RenderArgs>(_cachedArgs);
+    }
+
+    void configure(const Config& config) {
+        if (config.enabled || config.alwaysEnabled) {
+            _position = config.position;
+            _orientation = config.orientation;
+            _vFoV = config.vFoV;
+            _nearClipPlaneDistance = config.nearClipPlaneDistance;
+            _farClipPlaneDistance = config.farClipPlaneDistance;
+        }
+    }
+
+    void run(const render::RenderContextPointer& renderContext, RenderArgsPointer& cachedArgs) {
+        auto args = renderContext->args;
+        auto textureCache = DependencyManager::get<TextureCache>();
+        gpu::FramebufferPointer destFramebuffer;
+        destFramebuffer = textureCache->getSpectatorCameraFramebuffer(); // FIXME: Change the destination based on some unimplemented config var
+        if (destFramebuffer) {
+            _cachedArgsPointer->_blitFramebuffer = args->_blitFramebuffer;
+            _cachedArgsPointer->_viewport = args->_viewport;
+            _cachedArgsPointer->_displayMode = args->_displayMode;
+            _cachedArgsPointer->_renderMode = args->_renderMode;
+            args->_blitFramebuffer = destFramebuffer;
+            args->_viewport = glm::ivec4(0, 0, destFramebuffer->getWidth(), destFramebuffer->getHeight());
+            args->_displayMode = RenderArgs::MONO;
+            args->_renderMode = RenderArgs::RenderMode::SECONDARY_CAMERA_RENDER_MODE;
+
+            gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
+                batch.disableContextStereo();
+            });
+
+            auto srcViewFrustum = args->getViewFrustum();
+            srcViewFrustum.setPosition(_position);
+            srcViewFrustum.setOrientation(_orientation);
+            srcViewFrustum.setProjection(glm::perspective(glm::radians(_vFoV), ((float)args->_viewport.z / (float)args->_viewport.w), _nearClipPlaneDistance, _farClipPlaneDistance));
+            // Without calculating the bound planes, the secondary camera will use the same culling frustum as the main camera,
+            // which is not what we want here.
+            srcViewFrustum.calculate();
+            args->pushViewFrustum(srcViewFrustum);
+            cachedArgs = _cachedArgsPointer;
+        }
+    }
+
+protected:
+    RenderArgs _cachedArgs;
+    RenderArgsPointer _cachedArgsPointer;
+};
+
+class EndSecondaryCameraFrame {  // Restores renderContext.
+public:
+    using JobModel = render::Job::ModelI<EndSecondaryCameraFrame, RenderArgsPointer>;
+
+    void run(const render::RenderContextPointer& renderContext, const RenderArgsPointer& cachedArgs) {
+        auto args = renderContext->args;
+        args->_blitFramebuffer = cachedArgs->_blitFramebuffer;
+        args->_viewport = cachedArgs->_viewport;
+        args->popViewFrustum();
+        args->_displayMode = cachedArgs->_displayMode;
+        args->_renderMode = cachedArgs->_renderMode;
+
+        gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
+            batch.restoreContextStereo();
+        });
+    }
+};
+
+void SecondaryCameraRenderTask::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor) {
+    const auto cachedArg = task.addJob<BeginSecondaryCameraFrame>("BeginSecondaryCamera");
+    const auto items = task.addJob<RenderFetchCullSortTask>("FetchCullSort", cullFunctor);
+    assert(items.canCast<RenderFetchCullSortTask::Output>());
+    task.addJob<RenderDeferredTask>("RenderDeferredTask", items);
+    task.addJob<EndSecondaryCameraFrame>("EndSecondaryCamera", cachedArg);
+}

interface/src/SecondaryCamera.h

@@ -0,0 +1,70 @@
+//
+//  SecondaryCamera.h
+//  interface/src
+//
+//  Created by Samuel Gateau, Howard Stearns, and Zach Fox on 2017-06-08.
+//  Copyright 2013 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#pragma once
+#ifndef hifi_SecondaryCamera_h
+#define hifi_SecondaryCamera_h
+    
+#include <RenderShadowTask.h>
+#include <render/RenderFetchCullSortTask.h>
+#include <RenderDeferredTask.h>
+#include <RenderForwardTask.h>
+
+
+class MainRenderTask {
+public:
+    using JobModel = render::Task::Model<MainRenderTask>;
+
+    MainRenderTask() {}
+
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor, bool isDeferred = true);
+};
+
+class BeginSecondaryCameraFrameConfig : public render::Task::Config { // Exposes secondary camera parameters to JavaScript.
+    Q_OBJECT
+    Q_PROPERTY(glm::vec3 position MEMBER position NOTIFY dirty)  // of viewpoint to render from
+    Q_PROPERTY(glm::quat orientation MEMBER orientation NOTIFY dirty)  // of viewpoint to render from
+    Q_PROPERTY(float vFoV MEMBER vFoV NOTIFY dirty)  // Secondary camera's vertical field of view. In degrees.
+    Q_PROPERTY(float nearClipPlaneDistance MEMBER nearClipPlaneDistance NOTIFY dirty)  // Secondary camera's near clip plane distance. In meters.
+    Q_PROPERTY(float farClipPlaneDistance MEMBER farClipPlaneDistance NOTIFY dirty)  // Secondary camera's far clip plane distance. In meters.
+public:
+    glm::vec3 position{};
+    glm::quat orientation{};
+    float vFoV{ 45.0f };
+    float nearClipPlaneDistance{ 0.1f };
+    float farClipPlaneDistance{ 100.0f };
+    BeginSecondaryCameraFrameConfig() : render::Task::Config(false) {}
+signals:
+    void dirty();
+};
+
+class SecondaryCameraRenderTaskConfig : public render::Task::Config {
+    Q_OBJECT
+public:
+    SecondaryCameraRenderTaskConfig() : render::Task::Config(false) {}
+private:
+    void resetSize(int width, int height);
+signals:
+    void dirty();
+public slots:
+    void resetSizeSpectatorCamera(int width, int height);
+};
+
+class SecondaryCameraRenderTask {
+public:
+    using Config = SecondaryCameraRenderTaskConfig;
+    using JobModel = render::Task::Model<SecondaryCameraRenderTask, Config>;
+    SecondaryCameraRenderTask() {}
+    void configure(const Config& config) {}
+    void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs, render::CullFunctor cullFunctor);
+};
+
+#endif

interface/src/audio/AudioScope.h

@@ -19,7 +19,6 @@
 
 #include <DependencyManager.h>
 #include <gpu/Batch.h>
-#include <RenderArgs.h>
 
 
 class AudioScope : public QObject, public Dependency {

interface/src/avatar/MyAvatar.cpp

@@ -87,9 +87,10 @@ const float MyAvatar::ZOOM_MAX = 25.0f;
 const float MyAvatar::ZOOM_DEFAULT = 1.5f;
 
 // default values, used when avatar is missing joints... (avatar space)
-// static const glm::quat DEFAULT_AVATAR_MIDDLE_EYE_ROT { Quaternions::Y_180 };
+static const glm::quat DEFAULT_AVATAR_MIDDLE_EYE_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_MIDDLE_EYE_POS { 0.0f, 0.6f, 0.0f };
 static const glm::vec3 DEFAULT_AVATAR_HEAD_POS { 0.0f, 0.53f, 0.0f };
+static const glm::quat DEFAULT_AVATAR_HEAD_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_RIGHTARM_POS { -0.134824f, 0.396348f, -0.0515777f };
 static const glm::quat DEFAULT_AVATAR_RIGHTARM_ROT { -0.536241f, 0.536241f, -0.460918f, -0.460918f };
 static const glm::vec3 DEFAULT_AVATAR_LEFTARM_POS { 0.134795f, 0.396349f, -0.0515881f };
@@ -100,7 +101,9 @@ static const glm::vec3 DEFAULT_AVATAR_LEFTHAND_POS { 0.727588f, 0.39635f, -0.051
 static const glm::quat DEFAULT_AVATAR_LEFTHAND_ROT { -0.479181f, -0.52001f, 0.52254f, -0.476369f };
 static const glm::vec3 DEFAULT_AVATAR_NECK_POS { 0.0f, 0.445f, 0.025f };
 static const glm::vec3 DEFAULT_AVATAR_SPINE2_POS { 0.0f, 0.32f, 0.02f };
+static const glm::quat DEFAULT_AVATAR_SPINE2_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_HIPS_POS { 0.0f, 0.0f, 0.0f };
+static const glm::quat DEFAULT_AVATAR_HIPS_ROT { Quaternions::Y_180 };
 static const glm::vec3 DEFAULT_AVATAR_LEFTFOOT_POS { -0.08f, -0.96f, 0.029f};
 static const glm::quat DEFAULT_AVATAR_LEFTFOOT_ROT { -0.40167322754859924f, 0.9154590368270874f, -0.005437685176730156f, -0.023744143545627594f };
 static const glm::vec3 DEFAULT_AVATAR_RIGHTFOOT_POS { 0.08f, -0.96f, 0.029f };
@@ -1894,15 +1897,14 @@ void MyAvatar::preDisplaySide(RenderArgs* renderArgs) {
 
 const float RENDER_HEAD_CUTOFF_DISTANCE = 0.3f;
 
-bool MyAvatar::cameraInsideHead() const {
-    const glm::vec3 cameraPosition = qApp->getCamera().getPosition();
+bool MyAvatar::cameraInsideHead(const glm::vec3& cameraPosition) const {
     return glm::length(cameraPosition - getHeadPosition()) < (RENDER_HEAD_CUTOFF_DISTANCE * getUniformScale());
 }
 
 bool MyAvatar::shouldRenderHead(const RenderArgs* renderArgs) const {
     bool defaultMode = renderArgs->_renderMode == RenderArgs::DEFAULT_RENDER_MODE;
     bool firstPerson = qApp->getCamera().getMode() == CAMERA_MODE_FIRST_PERSON;
-    bool insideHead = cameraInsideHead();
+    bool insideHead = cameraInsideHead(renderArgs->getViewFrustum().getPosition());
     return !defaultMode || !firstPerson || !insideHead;
 }
 
@@ -2778,7 +2780,7 @@ void MyAvatar::FollowHelper::prePhysicsUpdate(MyAvatar& myAvatar, const glm::mat
                                               const glm::mat4& currentBodyMatrix, bool hasDriveInput) {
 
     if (myAvatar.getHMDLeanRecenterEnabled()) {
-        if (!isActive(Rotation) && shouldActivateRotation(myAvatar, desiredBodyMatrix, currentBodyMatrix)) {
+        if (!isActive(Rotation) && (shouldActivateRotation(myAvatar, desiredBodyMatrix, currentBodyMatrix) || hasDriveInput)) {
             activate(Rotation);
         }
         if (!isActive(Horizontal) && shouldActivateHorizontal(myAvatar, desiredBodyMatrix, currentBodyMatrix)) {
@@ -2980,7 +2982,7 @@ glm::mat4 MyAvatar::getCenterEyeCalibrationMat() const {
         auto centerEyeRot = Quaternions::Y_180;
         return createMatFromQuatAndPos(centerEyeRot, centerEyePos);
     } else {
-        return createMatFromQuatAndPos(DEFAULT_AVATAR_MIDDLE_EYE_POS, DEFAULT_AVATAR_MIDDLE_EYE_POS);
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_MIDDLE_EYE_ROT, DEFAULT_AVATAR_MIDDLE_EYE_POS);
     }
 }
 
@@ -2992,7 +2994,7 @@ glm::mat4 MyAvatar::getHeadCalibrationMat() const {
         auto headRot = getAbsoluteDefaultJointRotationInObjectFrame(headIndex);
         return createMatFromQuatAndPos(headRot, headPos);
     } else {
-        return createMatFromQuatAndPos(DEFAULT_AVATAR_HEAD_POS, DEFAULT_AVATAR_HEAD_POS);
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_HEAD_ROT, DEFAULT_AVATAR_HEAD_POS);
     }
 }
 
@@ -3004,7 +3006,7 @@ glm::mat4 MyAvatar::getSpine2CalibrationMat() const {
         auto spine2Rot = getAbsoluteDefaultJointRotationInObjectFrame(spine2Index);
         return createMatFromQuatAndPos(spine2Rot, spine2Pos);
     } else {
-        return createMatFromQuatAndPos(DEFAULT_AVATAR_SPINE2_POS, DEFAULT_AVATAR_SPINE2_POS);
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_SPINE2_ROT, DEFAULT_AVATAR_SPINE2_POS);
     }
 }
 
@@ -3016,7 +3018,7 @@ glm::mat4 MyAvatar::getHipsCalibrationMat() const {
         auto hipsRot = getAbsoluteDefaultJointRotationInObjectFrame(hipsIndex);
         return createMatFromQuatAndPos(hipsRot, hipsPos);
     } else {
-        return createMatFromQuatAndPos(DEFAULT_AVATAR_HIPS_POS, DEFAULT_AVATAR_HIPS_POS);
+        return createMatFromQuatAndPos(DEFAULT_AVATAR_HIPS_ROT, DEFAULT_AVATAR_HIPS_POS);
     }
 }
 

interface/src/avatar/MyAvatar.h

@@ -56,6 +56,7 @@ class MyAvatar : public Avatar {
      *
      * @namespace MyAvatar
      * @augments Avatar
+     * @property qmlPosition {Vec3} Used as a stopgap for position access by QML, as glm::vec3 is unavailable outside of scripts
      * @property shouldRenderLocally {bool} Set it to true if you would like to see MyAvatar in your local interface,
      *   and false if you would not like to see MyAvatar in your local interface.
      * @property motorVelocity {Vec3} Can be used to move the avatar with this velocity.
@@ -101,6 +102,10 @@ class MyAvatar : public Avatar {
      *   "scripts/system/controllers/toggleAdvancedMovementForHandControllers.js".
      */
 
+    // FIXME: `glm::vec3 position` is not accessible from QML, so this exposes position in a QML-native type
+    Q_PROPERTY(QVector3D qmlPosition READ getQmlPosition)
+    QVector3D getQmlPosition() { auto p = getPosition(); return QVector3D(p.x, p.y, p.z); }
+
     Q_PROPERTY(bool shouldRenderLocally READ getShouldRenderLocally WRITE setShouldRenderLocally)
     Q_PROPERTY(glm::vec3 motorVelocity READ getScriptedMotorVelocity WRITE setScriptedMotorVelocity)
     Q_PROPERTY(float motorTimescale READ getScriptedMotorTimescale WRITE setScriptedMotorTimescale)
@@ -620,7 +625,7 @@ private:
                         float scale = 1.0f, bool isSoft = false,
                         bool allowDuplicates = false, bool useSaved = true) override;
 
-    bool cameraInsideHead() const;
+    bool cameraInsideHead(const glm::vec3& cameraPosition) const;
 
     void updateEyeContactTarget(float deltaTime);
 

interface/src/scripting/Audio.cpp

@@ -0,0 +1,142 @@
+//
+//  Audio.cpp
+//  interface/src/scripting
+//
+//  Created by Zach Pomerantz on 28/5/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 "Audio.h"
+
+#include "Application.h"
+#include "AudioClient.h"
+#include "ui/AvatarInputs.h"
+
+using namespace scripting;
+
+QString Audio::AUDIO { "Audio" };
+QString Audio::DESKTOP { "Desktop" };
+QString Audio::HMD { "VR" };
+
+Setting::Handle<bool> enableNoiseReductionSetting { QStringList { Audio::AUDIO, "NoiseReduction" }, true };
+
+float Audio::loudnessToLevel(float loudness) {
+    const float LOG2 = log(2.0f);
+    const float METER_LOUDNESS_SCALE = 2.8f / 5.0f;
+    const float LOG2_LOUDNESS_FLOOR = 11.0f;
+
+    float level = 0.0f;
+
+    loudness += 1.0f;
+    float log2loudness = logf(loudness) / LOG2;
+
+    if (log2loudness <= LOG2_LOUDNESS_FLOOR) {
+        level = (log2loudness / LOG2_LOUDNESS_FLOOR) * METER_LOUDNESS_SCALE;
+    } else {
+        level = (log2loudness - (LOG2_LOUDNESS_FLOOR - 1.0f)) * METER_LOUDNESS_SCALE;
+    }
+
+    if (level > 1.0f) {
+        level = 1.0;
+    }
+
+    return level;
+}
+
+Audio::Audio() : _devices(_contextIsHMD) {
+    auto client = DependencyManager::get<AudioClient>().data();
+    connect(client, &AudioClient::muteToggled, this, &Audio::onMutedChanged);
+    connect(client, &AudioClient::inputLoudnessChanged, this, &Audio::onInputLoudnessChanged);
+    connect(this, &Audio::contextChanged, &_devices, &AudioDevices::onContextChanged);
+    connect(&_devices._inputs, &AudioDeviceList::deviceChanged, this, &Audio::onInputChanged);
+    enableNoiseReduction(enableNoiseReductionSetting.get());
+}
+
+void Audio::setMuted(bool isMuted) {
+    if (_isMuted != isMuted) {
+        auto client = DependencyManager::get<AudioClient>().data();
+        QMetaObject::invokeMethod(client, "toggleMute", Qt::BlockingQueuedConnection);
+
+        _isMuted = isMuted;
+        emit mutedChanged(_isMuted);
+    }
+}
+
+void Audio::onMutedChanged() {
+    auto client = DependencyManager::get<AudioClient>().data();
+    bool isMuted;
+    QMetaObject::invokeMethod(client, "isMuted", Qt::BlockingQueuedConnection, Q_RETURN_ARG(bool, isMuted));
+
+    if (_isMuted != isMuted) {
+        _isMuted = isMuted;
+        emit mutedChanged(_isMuted);
+    }
+}
+
+void Audio::enableNoiseReduction(bool enable) {
+    if (_enableNoiseReduction != enable) {
+        auto client = DependencyManager::get<AudioClient>().data();
+        QMetaObject::invokeMethod(client, "setNoiseReduction", Qt::BlockingQueuedConnection, Q_ARG(bool, enable));
+
+        enableNoiseReductionSetting.set(enable);
+        _enableNoiseReduction = enable;
+        emit noiseReductionChanged(enable);
+    }
+}
+
+void Audio::setInputVolume(float volume) {
+    // getInputVolume will not reflect changes synchronously, so clamp beforehand
+    volume = glm::clamp(volume, 0.0f, 1.0f);
+
+    if (_inputVolume != volume) {
+        auto client = DependencyManager::get<AudioClient>().data();
+        QMetaObject::invokeMethod(client, "setInputVolume", Qt::BlockingQueuedConnection, Q_ARG(float, volume));
+
+        _inputVolume = volume;
+        emit inputVolumeChanged(_inputVolume);
+    }
+}
+
+// different audio input devices may have different volumes
+void Audio::onInputChanged() {
+    auto client = DependencyManager::get<AudioClient>().data();
+    float volume;
+    QMetaObject::invokeMethod(client, "getInputVolume", Qt::BlockingQueuedConnection, Q_RETURN_ARG(float, volume));
+
+    if (_inputVolume != volume) {
+        _inputVolume = volume;
+        emit inputVolumeChanged(_inputVolume);
+    }
+}
+
+void Audio::onInputLoudnessChanged(float loudness) {
+    float level = loudnessToLevel(loudness);
+
+    if (_inputLevel != level) {
+        _inputLevel = level;
+        emit inputLevelChanged(_inputLevel);
+    }
+}
+
+QString Audio::getContext() const {
+     return _contextIsHMD ? Audio::HMD : Audio::DESKTOP;
+}
+
+void Audio::onContextChanged() {
+    bool isHMD = qApp->isHMDMode();
+    if (_contextIsHMD != isHMD) {
+        _contextIsHMD = isHMD;
+        emit contextChanged(getContext());
+    }
+}
+
+void Audio::setReverb(bool enable) {
+    DependencyManager::get<AudioClient>()->setReverb(enable);
+}
+
+void Audio::setReverbOptions(const AudioEffectOptions* options) {
+    DependencyManager::get<AudioClient>()->setReverbOptions(options);
+}

interface/src/scripting/Audio.h

@@ -0,0 +1,88 @@
+//
+//  Audio.h
+//  interface/src/scripting
+//
+//  Created by Zach Pomerantz on 28/5/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_scripting_Audio_h
+#define hifi_scripting_Audio_h
+
+#include "AudioScriptingInterface.h"
+#include "AudioDevices.h"
+#include "AudioEffectOptions.h"
+#include "SettingHandle.h"
+
+namespace scripting {
+
+class Audio : public AudioScriptingInterface {
+    Q_OBJECT
+    SINGLETON_DEPENDENCY
+
+    Q_PROPERTY(bool muted READ isMuted WRITE setMuted NOTIFY mutedChanged)
+    Q_PROPERTY(bool noiseReduction READ noiseReductionEnabled WRITE enableNoiseReduction NOTIFY noiseReductionChanged)
+    Q_PROPERTY(float inputVolume READ getInputVolume WRITE setInputVolume NOTIFY inputVolumeChanged)
+    Q_PROPERTY(float inputLevel READ getInputLevel NOTIFY inputLevelChanged)
+    Q_PROPERTY(QString context READ getContext NOTIFY contextChanged)
+    Q_PROPERTY(AudioDevices* devices READ getDevices NOTIFY nop)
+
+public:
+    static QString AUDIO;
+    static QString HMD;
+    static QString DESKTOP;
+
+    static float loudnessToLevel(float loudness);
+
+    virtual ~Audio() {}
+
+    bool isMuted() const { return _isMuted; }
+    bool noiseReductionEnabled() const { return _enableNoiseReduction; }
+    float getInputVolume() const { return _inputVolume; }
+    float getInputLevel() const { return _inputLevel; }
+    QString getContext() const;
+
+    void setMuted(bool muted);
+    void enableNoiseReduction(bool enable);
+    void showMicMeter(bool show);
+    void setInputVolume(float volume);
+
+    Q_INVOKABLE void setReverb(bool enable);
+    Q_INVOKABLE void setReverbOptions(const AudioEffectOptions* options);
+
+signals:
+    void nop();
+    void mutedChanged(bool isMuted);
+    void noiseReductionChanged(bool isEnabled);
+    void inputVolumeChanged(float volume);
+    void inputLevelChanged(float level);
+    void contextChanged(const QString& context);
+
+public slots:
+    void onMutedChanged();
+    void onContextChanged();
+    void onInputChanged();
+    void onInputLoudnessChanged(float loudness);
+
+protected:
+    // Audio must live on a separate thread from AudioClient to avoid deadlocks
+    Audio();
+
+private:
+
+    float _inputVolume { 1.0f };
+    float _inputLevel { 0.0f };
+    bool _isMuted { false };
+    bool _enableNoiseReduction;
+    bool _contextIsHMD { false };
+
+    AudioDevices* getDevices() { return &_devices; }
+    AudioDevices _devices;
+};
+
+};
+
+#endif // hifi_scripting_Audio_h

interface/src/scripting/AudioDeviceScriptingInterface.cpp

@@ -1,301 +0,0 @@
-//
-//  AudioDeviceScriptingInterface.cpp
-//  interface/src/scripting
-//
-//  Created by Brad Hefta-Gaub on 3/23/14.
-//  Copyright 2014 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 <AudioClient.h>
-#include <AudioClientLogging.h>
-
-#include "AudioDeviceScriptingInterface.h"
-#include "SettingsScriptingInterface.h"
-
-AudioDeviceScriptingInterface* AudioDeviceScriptingInterface::getInstance() {
-    static AudioDeviceScriptingInterface sharedInstance;
-    return &sharedInstance;
-}
-
-QStringList AudioDeviceScriptingInterface::inputAudioDevices() const {
-    return _inputAudioDevices;
-}
-
-QStringList AudioDeviceScriptingInterface::outputAudioDevices() const {
-    return _outputAudioDevices;
-}
-
-bool AudioDeviceScriptingInterface::muted()
-{
-    return getMuted();
-}
-
-AudioDeviceScriptingInterface::AudioDeviceScriptingInterface(): QAbstractListModel(nullptr) {
-    connect(DependencyManager::get<AudioClient>().data(), &AudioClient::muteToggled,
-            this, &AudioDeviceScriptingInterface::muteToggled);
-    connect(DependencyManager::get<AudioClient>().data(), &AudioClient::deviceChanged,
-        this, &AudioDeviceScriptingInterface::onDeviceChanged, Qt::QueuedConnection);
-    connect(DependencyManager::get<AudioClient>().data(), &AudioClient::currentInputDeviceChanged,
-        this, &AudioDeviceScriptingInterface::onCurrentInputDeviceChanged, Qt::QueuedConnection);
-    connect(DependencyManager::get<AudioClient>().data(), &AudioClient::currentOutputDeviceChanged,
-        this, &AudioDeviceScriptingInterface::onCurrentOutputDeviceChanged, Qt::QueuedConnection);
-    //fill up model
-    onDeviceChanged();
-    //set up previously saved device
-    SettingsScriptingInterface* settings = SettingsScriptingInterface::getInstance();
-    const QString inDevice = settings->getValue("audio_input_device", _currentInputDevice).toString();
-    if (inDevice != _currentInputDevice) {
-        qCDebug(audioclient) << __FUNCTION__ << "about to call setInputDeviceAsync() device: [" << inDevice << "] _currentInputDevice:" << _currentInputDevice;
-        setInputDeviceAsync(inDevice);
-    }
-
-    // If the audio_output_device setting is not available, use the _currentOutputDevice
-    auto outDevice = settings->getValue("audio_output_device", _currentOutputDevice).toString();
-    if (outDevice != _currentOutputDevice) {
-        qCDebug(audioclient) << __FUNCTION__ << "about to call setOutputDeviceAsync() outDevice: [" << outDevice << "] _currentOutputDevice:" << _currentOutputDevice;
-        setOutputDeviceAsync(outDevice);
-    }
-}
-
-bool AudioDeviceScriptingInterface::setInputDevice(const QString& deviceName) {
-    qCDebug(audioclient) << __FUNCTION__ << "deviceName:" << deviceName;
-
-    bool result;
-    QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "switchInputToAudioDevice",
-                              Qt::BlockingQueuedConnection,
-                              Q_RETURN_ARG(bool, result),
-                              Q_ARG(const QString&, deviceName));
-    return result;
-}
-
-bool AudioDeviceScriptingInterface::setOutputDevice(const QString& deviceName) {
-
-    qCDebug(audioclient) << __FUNCTION__ << "deviceName:" << deviceName;
-
-    bool result;
-    QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "switchOutputToAudioDevice",
-                              Qt::BlockingQueuedConnection,
-                              Q_RETURN_ARG(bool, result),
-                              Q_ARG(const QString&, deviceName));
-    return result;
-}
-
-bool AudioDeviceScriptingInterface::setDeviceFromMenu(const QString& deviceMenuName) {
-    QAudio::Mode mode;
-
-    if (deviceMenuName.indexOf("for Output") != -1) {
-        mode = QAudio::AudioOutput;
-    } else if (deviceMenuName.indexOf("for Input") != -1) {
-        mode = QAudio::AudioInput;
-    } else {
-        return false;
-    }
-
-    for (ScriptingAudioDeviceInfo di: _devices) {
-        if (mode == di.mode && deviceMenuName.contains(di.name)) {
-            if (mode == QAudio::AudioOutput) {
-                qCDebug(audioclient) << __FUNCTION__ << "about to call setOutputDeviceAsync() device: [" << di.name << "]";
-                setOutputDeviceAsync(di.name);
-            } else {
-                qCDebug(audioclient) << __FUNCTION__ << "about to call setInputDeviceAsync() device: [" << di.name << "]";
-                setInputDeviceAsync(di.name);
-            }
-            return true;
-        }
-    }
-
-    return false;
-}
-
-void AudioDeviceScriptingInterface::setInputDeviceAsync(const QString& deviceName) {
-    qCDebug(audioclient) << __FUNCTION__ << "deviceName:" << deviceName;
-
-    if (deviceName.isEmpty()) {
-        qCDebug(audioclient) << __FUNCTION__ << "attempt to set empty deviceName:" << deviceName << "... ignoring!";
-        return;
-    }
-
-    QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "switchInputToAudioDevice",
-                              Qt::QueuedConnection,
-                              Q_ARG(const QString&, deviceName));
-}
-
-void AudioDeviceScriptingInterface::setOutputDeviceAsync(const QString& deviceName) {
-    qCDebug(audioclient) << __FUNCTION__ << "deviceName:" << deviceName;
-
-    if (deviceName.isEmpty()) {
-        qCDebug(audioclient) << __FUNCTION__ << "attempt to set empty deviceName:" << deviceName << "... ignoring!";
-        return;
-    }
-
-    QMetaObject::invokeMethod(DependencyManager::get<AudioClient>().data(), "switchOutputToAudioDevice",
-                              Qt::QueuedConnection,
-                              Q_ARG(const QString&, deviceName));
-}
-
-QString AudioDeviceScriptingInterface::getInputDevice() {
-    return DependencyManager::get<AudioClient>()->getDeviceName(QAudio::AudioInput);
-}
-
-QString AudioDeviceScriptingInterface::getOutputDevice() {
-    return DependencyManager::get<AudioClient>()->getDeviceName(QAudio::AudioOutput);
-}
-
-QString AudioDeviceScriptingInterface::getDefaultInputDevice() {
-    return DependencyManager::get<AudioClient>()->getDefaultDeviceName(QAudio::AudioInput);
-}
-
-QString AudioDeviceScriptingInterface::getDefaultOutputDevice() {
-    return DependencyManager::get<AudioClient>()->getDefaultDeviceName(QAudio::AudioOutput);
-}
-
-QVector<QString> AudioDeviceScriptingInterface::getInputDevices() {
-    return DependencyManager::get<AudioClient>()->getDeviceNames(QAudio::AudioInput);
-}
-
-QVector<QString> AudioDeviceScriptingInterface::getOutputDevices() {
-    return DependencyManager::get<AudioClient>()->getDeviceNames(QAudio::AudioOutput);
-}
-
-float AudioDeviceScriptingInterface::getInputVolume() {
-    return DependencyManager::get<AudioClient>()->getInputVolume();
-}
-
-void AudioDeviceScriptingInterface::setInputVolume(float volume) {
-    DependencyManager::get<AudioClient>()->setInputVolume(volume);
-}
-
-void AudioDeviceScriptingInterface::setReverb(bool reverb) {
-    DependencyManager::get<AudioClient>()->setReverb(reverb);
-}
-
-void AudioDeviceScriptingInterface::setReverbOptions(const AudioEffectOptions* options) {
-    DependencyManager::get<AudioClient>()->setReverbOptions(options);
-}
-
-void AudioDeviceScriptingInterface::toggleMute() {
-    DependencyManager::get<AudioClient>()->toggleMute();
-}
-
-void AudioDeviceScriptingInterface::setMuted(bool muted)
-{
-    bool lMuted = getMuted();
-    if (lMuted == muted)
-        return;
-
-    toggleMute();
-    lMuted = getMuted();
-    emit mutedChanged(lMuted);
-}
-
-bool AudioDeviceScriptingInterface::getMuted() {
-    return DependencyManager::get<AudioClient>()->isMuted();
-}
-
-QVariant AudioDeviceScriptingInterface::data(const QModelIndex& index, int role) const {
-    //sanity
-    if (!index.isValid() || index.row() >= _devices.size())
-        return QVariant();
-
-
-    if (role == Qt::DisplayRole || role == DisplayNameRole) {
-        return _devices.at(index.row()).name;
-    } else if (role == SelectedRole) {
-        return _devices.at(index.row()).selected;
-    } else if (role == AudioModeRole) {
-        return (int)_devices.at(index.row()).mode;
-    }
-    return QVariant();
-}
-
-int AudioDeviceScriptingInterface::rowCount(const QModelIndex& parent) const {
-    Q_UNUSED(parent)
-    return _devices.size();
-}
-
-QHash<int, QByteArray> AudioDeviceScriptingInterface::roleNames() const {
-    QHash<int, QByteArray> roles;
-    roles.insert(DisplayNameRole, "devicename");
-    roles.insert(SelectedRole, "devicechecked");
-    roles.insert(AudioModeRole, "devicemode");
-    return roles;
-}
-
-void AudioDeviceScriptingInterface::onDeviceChanged()
-{
-    beginResetModel();
-    _outputAudioDevices.clear();
-    _devices.clear();
-    _currentOutputDevice = getOutputDevice();
-    for (QString name: getOutputDevices()) {
-        ScriptingAudioDeviceInfo di;
-        di.name = name;
-        di.selected = (name == _currentOutputDevice);
-        di.mode = QAudio::AudioOutput;
-        _devices.append(di);
-        _outputAudioDevices.append(name);
-    }
-    emit outputAudioDevicesChanged(_outputAudioDevices);
-
-    _inputAudioDevices.clear();
-    _currentInputDevice = getInputDevice();
-    for (QString name: getInputDevices()) {
-        ScriptingAudioDeviceInfo di;
-        di.name = name;
-        di.selected = (name == _currentInputDevice);
-        di.mode = QAudio::AudioInput;
-        _devices.append(di);
-        _inputAudioDevices.append(name);
-    }
-    emit inputAudioDevicesChanged(_inputAudioDevices);
-
-    endResetModel();
-    emit deviceChanged();
-}
-
-void AudioDeviceScriptingInterface::onCurrentInputDeviceChanged(const QString& name)
-{
-    currentDeviceUpdate(name, QAudio::AudioInput);
-    //we got a signal that device changed. Save it now
-    SettingsScriptingInterface* settings = SettingsScriptingInterface::getInstance();
-    settings->setValue("audio_input_device", name);
-    emit currentInputDeviceChanged(name);
-}
-
-void AudioDeviceScriptingInterface::onCurrentOutputDeviceChanged(const QString& name)
-{
-    currentDeviceUpdate(name, QAudio::AudioOutput);
-
-    // FIXME - this is kinda janky to set the setting on the result of a signal
-    //we got a signal that device changed. Save it now
-    SettingsScriptingInterface* settings = SettingsScriptingInterface::getInstance();
-    qCDebug(audioclient) << __FUNCTION__ << "about to call settings->setValue('audio_output_device', name); name:" << name;
-    settings->setValue("audio_output_device", name);
-    emit currentOutputDeviceChanged(name);
-}
-
-void AudioDeviceScriptingInterface::currentDeviceUpdate(const QString& name, QAudio::Mode mode)
-{
-    QVector<int> role;
-    role.append(SelectedRole);
-
-    for (int i = 0; i < _devices.size(); i++) {
-        ScriptingAudioDeviceInfo di = _devices.at(i);
-        if (di.mode != mode) {
-            continue;
-        }
-        if (di.selected && di.name != name ) {
-            di.selected = false;
-            _devices[i] = di;
-            emit dataChanged(index(i, 0), index(i, 0), role);
-        }
-        if (di.name == name) {
-            di.selected = true;
-            _devices[i] = di;
-            emit dataChanged(index(i, 0), index(i, 0), role);
-        }
-    }
-}

interface/src/scripting/AudioDeviceScriptingInterface.h

@@ -1,107 +0,0 @@
-//
-//  AudioDeviceScriptingInterface.h
-//  interface/src/scripting
-//
-//  Created by Brad Hefta-Gaub on 3/22/14.
-//  Copyright 2014 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_AudioDeviceScriptingInterface_h
-#define hifi_AudioDeviceScriptingInterface_h
-
-#include <QObject>
-#include <QString>
-#include <QVector>
-#include <QAbstractListModel>
-#include <QAudio>
-
-class AudioEffectOptions;
-
-struct ScriptingAudioDeviceInfo {
-    QString name;
-    bool selected;
-    QAudio::Mode mode;
-};
-
-class AudioDeviceScriptingInterface : public QAbstractListModel {
-    Q_OBJECT
-
-    Q_PROPERTY(QStringList inputAudioDevices READ inputAudioDevices NOTIFY inputAudioDevicesChanged)
-    Q_PROPERTY(QStringList outputAudioDevices READ outputAudioDevices NOTIFY outputAudioDevicesChanged)
-    Q_PROPERTY(bool muted READ muted WRITE setMuted NOTIFY mutedChanged)
-
-public:
-    static AudioDeviceScriptingInterface* getInstance();
-
-    QStringList inputAudioDevices() const;
-    QStringList outputAudioDevices() const;
-    bool muted();
-
-    QVariant data(const QModelIndex& index, int role = Qt::DisplayRole) const override;
-    int rowCount(const QModelIndex& parent = QModelIndex()) const override;
-    QHash<int, QByteArray> roleNames() const override;
-
-    enum Roles {
-        DisplayNameRole = Qt::UserRole,
-        SelectedRole,
-        AudioModeRole
-    };
-
-private slots:
-    void onDeviceChanged();
-    void onCurrentInputDeviceChanged(const QString& name);
-    void onCurrentOutputDeviceChanged(const QString& name);
-    void currentDeviceUpdate(const QString& name, QAudio::Mode mode);
-
-public slots:
-    bool setInputDevice(const QString& deviceName);
-    bool setOutputDevice(const QString& deviceName);
-    bool setDeviceFromMenu(const QString& deviceMenuName);
-
-    QString getInputDevice();
-    QString getOutputDevice();
-
-    QString getDefaultInputDevice();
-    QString getDefaultOutputDevice();
-
-    QVector<QString> getInputDevices();
-    QVector<QString> getOutputDevices();
-
-    float getInputVolume();
-    void setInputVolume(float volume);
-    void setReverb(bool reverb);
-    void setReverbOptions(const AudioEffectOptions* options);
-
-    bool getMuted();
-    void toggleMute();
-    
-    void setMuted(bool muted);
-
-    void setInputDeviceAsync(const QString& deviceName);
-    void setOutputDeviceAsync(const QString& deviceName);
-private:
-    AudioDeviceScriptingInterface();
-
-signals:
-    void muteToggled();
-    void deviceChanged();
-    void currentInputDeviceChanged(const QString& name);
-    void currentOutputDeviceChanged(const QString& name);
-    void mutedChanged(bool muted);
-    void inputAudioDevicesChanged(QStringList inputAudioDevices);
-    void outputAudioDevicesChanged(QStringList outputAudioDevices);
-
-private:
-    QVector<ScriptingAudioDeviceInfo> _devices;
-
-    QStringList _inputAudioDevices;
-    QStringList _outputAudioDevices;
-
-    QString _currentInputDevice;
-    QString _currentOutputDevice;
-};
-
-#endif // hifi_AudioDeviceScriptingInterface_h

interface/src/scripting/AudioDevices.cpp

@@ -0,0 +1,242 @@
+//
+//  AudioDevices.cpp
+//  interface/src/scripting
+//
+//  Created by Zach Pomerantz on 28/5/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 "AudioDevices.h"
+
+#include "Application.h"
+#include "AudioClient.h"
+#include "Audio.h"
+
+using namespace scripting;
+
+Setting::Handle<QString> inputDeviceDesktop { QStringList { Audio::AUDIO, Audio::DESKTOP, "INPUT" }};
+Setting::Handle<QString> outputDeviceDesktop { QStringList { Audio::AUDIO, Audio::DESKTOP, "OUTPUT" }};
+Setting::Handle<QString> inputDeviceHMD { QStringList { Audio::AUDIO, Audio::HMD, "INPUT" }};
+Setting::Handle<QString> outputDeviceHMD { QStringList { Audio::AUDIO, Audio::HMD, "OUTPUT" }};
+
+QHash<int, QByteArray> AudioDeviceList::_roles {
+    { Qt::DisplayRole, "display" },
+    { Qt::CheckStateRole, "selected" }
+};
+Qt::ItemFlags AudioDeviceList::_flags { Qt::ItemIsSelectable | Qt::ItemIsEnabled };
+
+QVariant AudioDeviceList::data(const QModelIndex& index, int role) const {
+    if (!index.isValid() || index.row() >= _devices.size()) {
+        return QVariant();
+    }
+
+    if (role == Qt::DisplayRole) {
+        return _devices.at(index.row()).display;
+    } else if (role == Qt::CheckStateRole) {
+        return _devices.at(index.row()).selected;
+    } else {
+        return QVariant();
+    }
+}
+
+bool AudioDeviceList::setData(const QModelIndex& index, const QVariant& value, int role) {
+    if (!index.isValid() || index.row() >= _devices.size()) {
+        return false;
+    }
+
+    bool success = false;
+
+    if (role == Qt::CheckStateRole) {
+        auto selected = value.toBool();
+        auto& device = _devices[index.row()];
+
+            // only allow switching to a new device, not deactivating an in-use device
+        if (selected
+            // skip if already selected
+            && selected != device.selected) {
+
+            auto client = DependencyManager::get<AudioClient>();
+            QMetaObject::invokeMethod(client.data(), "switchAudioDevice", Qt::BlockingQueuedConnection,
+                Q_RETURN_ARG(bool, success),
+                Q_ARG(QAudio::Mode, _mode),
+                Q_ARG(const QAudioDeviceInfo&, device.info));
+
+            if (success) {
+                device.selected = true;
+                emit deviceSelected(device.info);
+                emit deviceChanged(device.info);
+            }
+        }
+    }
+
+    emit dataChanged(createIndex(0, 0), createIndex(rowCount() - 1, 0));
+    return success;
+}
+
+void AudioDeviceList::resetDevice(bool contextIsHMD, const QString& device) {
+    bool success { false };
+
+    // try to set the last selected device
+    if (!device.isNull()) {
+        auto i = 0;
+        for (; i < rowCount(); ++i) {
+            if (device == _devices[i].info.deviceName()) {
+                break;
+            }
+        }
+        if (i < rowCount()) {
+            success = setData(createIndex(i, 0), true, Qt::CheckStateRole);
+        }
+
+        // the selection failed - reset it
+        if (!success) {
+            emit deviceSelected(QAudioDeviceInfo());
+        }
+    }
+
+    // try to set to the default device for this mode
+    if (!success) {
+        auto client = DependencyManager::get<AudioClient>().data();
+        if (contextIsHMD) {
+            QString deviceName;
+            if (_mode == QAudio::AudioInput) {
+                deviceName = qApp->getActiveDisplayPlugin()->getPreferredAudioInDevice();
+            } else { // if (_mode == QAudio::AudioOutput)
+                deviceName = qApp->getActiveDisplayPlugin()->getPreferredAudioOutDevice();
+            }
+            if (!deviceName.isNull()) {
+                QMetaObject::invokeMethod(client, "switchAudioDevice", Q_ARG(QAudio::Mode, _mode), Q_ARG(QString, deviceName));
+            }
+        } else {
+            // use the system default
+            QMetaObject::invokeMethod(client, "switchAudioDevice", Q_ARG(QAudio::Mode, _mode));
+        }
+    }
+}
+
+void AudioDeviceList::onDeviceChanged(const QAudioDeviceInfo& device) {
+    _selectedDevice = device;
+    QModelIndex index;
+
+    for (auto i = 0; i < _devices.size(); ++i) {
+        AudioDevice& device = _devices[i];
+
+        if (device.selected && device.info != _selectedDevice) {
+            device.selected = false;
+        } else if (device.info == _selectedDevice) {
+            device.selected = true;
+            index = createIndex(i, 0);
+        }
+    }
+
+    emit deviceChanged(_selectedDevice);
+    emit dataChanged(createIndex(0, 0), createIndex(rowCount() - 1, 0));
+}
+
+void AudioDeviceList::onDevicesChanged(const QList<QAudioDeviceInfo>& devices) {
+    beginResetModel();
+
+    _devices.clear();
+
+    foreach(const QAudioDeviceInfo& deviceInfo, devices) {
+        AudioDevice device;
+        device.info = deviceInfo;
+        device.display = device.info.deviceName()
+            .replace("High Definition", "HD")
+            .remove("Device")
+            .replace(" )", ")");
+        device.selected = (device.info == _selectedDevice);
+        _devices.push_back(device);
+    }
+
+    endResetModel();
+}
+
+AudioDevices::AudioDevices(bool& contextIsHMD) : _contextIsHMD(contextIsHMD) {
+    auto client = DependencyManager::get<AudioClient>();
+
+    connect(client.data(), &AudioClient::deviceChanged, this, &AudioDevices::onDeviceChanged, Qt::QueuedConnection);
+    connect(client.data(), &AudioClient::devicesChanged, this, &AudioDevices::onDevicesChanged, Qt::QueuedConnection);
+
+    // connections are made after client is initialized, so we must also fetch the devices
+    _inputs.onDeviceChanged(client->getActiveAudioDevice(QAudio::AudioInput));
+    _outputs.onDeviceChanged(client->getActiveAudioDevice(QAudio::AudioOutput));
+    _inputs.onDevicesChanged(client->getAudioDevices(QAudio::AudioInput));
+    _outputs.onDevicesChanged(client->getAudioDevices(QAudio::AudioOutput));
+
+    connect(&_inputs, &AudioDeviceList::deviceSelected, this, &AudioDevices::onInputDeviceSelected);
+    connect(&_outputs, &AudioDeviceList::deviceSelected, this, &AudioDevices::onOutputDeviceSelected);
+}
+
+void AudioDevices::onContextChanged(const QString& context) {
+    QString input;
+    QString output;
+    if (_contextIsHMD) {
+        input = inputDeviceHMD.get();
+        output = outputDeviceHMD.get();
+    } else {
+        input = inputDeviceDesktop.get();
+        output = outputDeviceDesktop.get();
+    }
+
+    _inputs.resetDevice(_contextIsHMD, input);
+    _outputs.resetDevice(_contextIsHMD, output);
+}
+
+void AudioDevices::onInputDeviceSelected(const QAudioDeviceInfo& device) {
+    QString deviceName;
+    if (!device.isNull()) {
+        deviceName = device.deviceName();
+    }
+
+    if (_contextIsHMD) {
+        inputDeviceHMD.set(deviceName);
+    } else {
+        inputDeviceDesktop.set(deviceName);
+    }
+}
+
+void AudioDevices::onOutputDeviceSelected(const QAudioDeviceInfo& device) {
+    QString deviceName;
+    if (!device.isNull()) {
+        deviceName = device.deviceName();
+    }
+
+    if (_contextIsHMD) {
+        outputDeviceHMD.set(deviceName);
+    } else {
+        outputDeviceDesktop.set(deviceName);
+    }
+}
+
+void AudioDevices::onDeviceChanged(QAudio::Mode mode, const QAudioDeviceInfo& device) {
+    if (mode == QAudio::AudioInput) {
+        _inputs.onDeviceChanged(device);
+    } else { // if (mode == QAudio::AudioOutput)
+        _outputs.onDeviceChanged(device);
+    }
+}
+
+void AudioDevices::onDevicesChanged(QAudio::Mode mode, const QList<QAudioDeviceInfo>& devices) {
+    static bool initialized { false };
+    auto initialize = [&]{
+        if (initialized) {
+            onContextChanged(QString());
+        } else {
+            initialized = true;
+        }
+    };
+
+    if (mode == QAudio::AudioInput) {
+        _inputs.onDevicesChanged(devices);
+        static std::once_flag inputFlag;
+        std::call_once(inputFlag, initialize);
+    } else { // if (mode == QAudio::AudioOutput)
+        _outputs.onDevicesChanged(devices);
+        static std::once_flag outputFlag;
+        std::call_once(outputFlag, initialize);
+    }
+}

interface/src/scripting/AudioDevices.h

@@ -0,0 +1,98 @@
+//
+//  AudioDevices.h
+//  interface/src/scripting
+//
+//  Created by Zach Pomerantz on 28/5/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_scripting_AudioDevices_h
+#define hifi_scripting_AudioDevices_h
+
+#include <QObject>
+#include <QAbstractListModel>
+#include <QAudioDeviceInfo>
+
+namespace scripting {
+
+class AudioDevice {
+public:
+    QAudioDeviceInfo info;
+    QString display;
+    bool selected { false };
+};
+
+class AudioDeviceList : public QAbstractListModel {
+    Q_OBJECT
+
+public:
+    AudioDeviceList(QAudio::Mode mode) : _mode(mode) {}
+
+    int rowCount(const QModelIndex& parent = QModelIndex()) const override { Q_UNUSED(parent); return _devices.size(); }
+    QHash<int, QByteArray> roleNames() const override { return _roles; }
+    Qt::ItemFlags flags(const QModelIndex& index) const override { return _flags; }
+
+    // get/set devices through a QML ListView
+    QVariant data(const QModelIndex& index, int role) const override;
+    bool setData(const QModelIndex& index, const QVariant &value, int role) override;
+
+    // reset device to the last selected device in this context, or the default
+    void resetDevice(bool contextIsHMD, const QString& device);
+
+signals:
+    void deviceSelected(const QAudioDeviceInfo& device);
+    void deviceChanged(const QAudioDeviceInfo& device);
+
+private slots:
+    void onDeviceChanged(const QAudioDeviceInfo& device);
+    void onDevicesChanged(const QList<QAudioDeviceInfo>& devices);
+
+private:
+    friend class AudioDevices;
+
+    static QHash<int, QByteArray> _roles;
+    static Qt::ItemFlags _flags;
+
+    QAudio::Mode _mode;
+    QAudioDeviceInfo _selectedDevice;
+    QList<AudioDevice> _devices;
+};
+
+class Audio;
+
+class AudioDevices : public QObject {
+    Q_OBJECT
+    Q_PROPERTY(AudioDeviceList* input READ getInputList NOTIFY nop)
+    Q_PROPERTY(AudioDeviceList* output READ getOutputList NOTIFY nop)
+
+public:
+    AudioDevices(bool& contextIsHMD);
+
+signals:
+    void nop();
+
+private slots:
+    void onContextChanged(const QString& context);
+    void onInputDeviceSelected(const QAudioDeviceInfo& device);
+    void onOutputDeviceSelected(const QAudioDeviceInfo& device);
+    void onDeviceChanged(QAudio::Mode mode, const QAudioDeviceInfo& device);
+    void onDevicesChanged(QAudio::Mode mode, const QList<QAudioDeviceInfo>& devices);
+
+private:
+    friend class Audio;
+
+    AudioDeviceList* getInputList() { return &_inputs; }
+    AudioDeviceList* getOutputList() { return &_outputs; }
+
+    AudioDeviceList _inputs { QAudio::AudioInput };
+    AudioDeviceList _outputs { QAudio::AudioOutput };
+
+    bool& _contextIsHMD;
+};
+
+};
+
+#endif // hifi_scripting_AudioDevices_h

interface/src/scripting/MenuScriptingInterface.cpp

@@ -152,9 +152,13 @@ void MenuScriptingInterface::closeInfoView(const QString& path) {
 }
 
 bool MenuScriptingInterface::isInfoViewVisible(const QString& path) {
+    if (QThread::currentThread() == qApp->thread()) {
+        return Menu::getInstance()->isInfoViewVisible(path);
+    }
+        
     bool result;
     QMetaObject::invokeMethod(Menu::getInstance(), "isInfoViewVisible", Qt::BlockingQueuedConnection,
-                              Q_RETURN_ARG(bool, result), Q_ARG(const QString&, path));
+        Q_RETURN_ARG(bool, result), Q_ARG(const QString&, path));
     return result;
 }
 

interface/src/scripting/WindowScriptingInterface.cpp

@@ -284,6 +284,11 @@ void WindowScriptingInterface::copyToClipboard(const QString& text) {
     QApplication::clipboard()->setText(text);
 }
 
+
+bool WindowScriptingInterface::setDisplayTexture(const QString& name) {
+    return  qApp->getActiveDisplayPlugin()->setDisplayTexture(name);   // Plugins that don't know how, answer false.
+}
+
 void WindowScriptingInterface::takeSnapshot(bool notify, bool includeAnimated, float aspectRatio) {
     qApp->takeSnapshot(notify, includeAnimated, aspectRatio);
 }

interface/src/scripting/WindowScriptingInterface.h

@@ -62,6 +62,7 @@ public slots:
     void displayAnnouncement(const QString& message);
     void shareSnapshot(const QString& path, const QUrl& href = QUrl(""));
     bool isPhysicsEnabled();
+    bool setDisplayTexture(const QString& name);
 
     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/AvatarInputs.cpp

@@ -18,9 +18,10 @@
 
 HIFI_QML_DEF(AvatarInputs)
 
-
 static AvatarInputs* INSTANCE{ nullptr };
 
+Setting::Handle<bool> showAudioToolsSetting { QStringList { "AvatarInputs", "showAudioTools" }, false };
+
 AvatarInputs* AvatarInputs::getInstance() {
     if (!INSTANCE) {
         AvatarInputs::registerType();
@@ -32,6 +33,7 @@ AvatarInputs* AvatarInputs::getInstance() {
 
 AvatarInputs::AvatarInputs(QQuickItem* parent) :  QQuickItem(parent) {
     INSTANCE = this;
+    _showAudioTools = showAudioToolsSetting.get();
 }
 
 #define AI_UPDATE(name, src) \
@@ -43,25 +45,6 @@ AvatarInputs::AvatarInputs(QQuickItem* parent) :  QQuickItem(parent) {
         } \
     }
 
-#define AI_UPDATE_WRITABLE(name, src) \
-    { \
-        auto val = src; \
-        if (_##name != val) { \
-            _##name = val; \
-            qDebug() << "AvatarInputs" << val; \
-            emit name##Changed(val); \
-        } \
-    }
-
-#define AI_UPDATE_FLOAT(name, src, epsilon) \
-    { \
-        float val = src; \
-        if (fabsf(_##name - val) >= epsilon) { \
-            _##name = val; \
-            emit name##Changed(); \
-        } \
-    }
-
 float AvatarInputs::loudnessToAudioLevel(float loudness) {
     const float AUDIO_METER_AVERAGING = 0.5;
     const float LOG2 = log(2.0f);
@@ -93,37 +76,15 @@ void AvatarInputs::update() {
     AI_UPDATE(cameraEnabled, !Menu::getInstance()->isOptionChecked(MenuOption::NoFaceTracking));
     AI_UPDATE(cameraMuted, Menu::getInstance()->isOptionChecked(MenuOption::MuteFaceTracking));
     AI_UPDATE(isHMD, qApp->isHMDMode());
-
-    AI_UPDATE_WRITABLE(showAudioTools, Menu::getInstance()->isOptionChecked(MenuOption::AudioTools));
-
-    auto audioIO = DependencyManager::get<AudioClient>();
-
-    const float audioLevel = loudnessToAudioLevel(DependencyManager::get<AudioClient>()->getLastInputLoudness());
-
-    AI_UPDATE_FLOAT(audioLevel, audioLevel, 0.01f);
-    AI_UPDATE(audioClipping, ((audioIO->getTimeSinceLastClip() > 0.0f) && (audioIO->getTimeSinceLastClip() < 1.0f)));
-    AI_UPDATE(audioMuted, audioIO->isMuted());
-
-    //// Make muted icon pulsate
-    //static const float PULSE_MIN = 0.4f;
-    //static const float PULSE_MAX = 1.0f;
-    //static const float PULSE_FREQUENCY = 1.0f; // in Hz
-    //qint64 now = usecTimestampNow();
-    //if (now - _iconPulseTimeReference > (qint64)USECS_PER_SECOND) {
-    //    // Prevents t from getting too big, which would diminish glm::cos precision
-    //    _iconPulseTimeReference = now - ((now - _iconPulseTimeReference) % USECS_PER_SECOND);
-    //}
-    //float t = (float)(now - _iconPulseTimeReference) / (float)USECS_PER_SECOND;
-    //float pulseFactor = (glm::cos(t * PULSE_FREQUENCY * 2.0f * PI) + 1.0f) / 2.0f;
-    //iconColor = PULSE_MIN + (PULSE_MAX - PULSE_MIN) * pulseFactor;
 }
 
 void AvatarInputs::setShowAudioTools(bool showAudioTools) {
     if (_showAudioTools == showAudioTools)
         return;
 
-    Menu::getInstance()->setIsOptionChecked(MenuOption::AudioTools, showAudioTools);
-    update();
+    _showAudioTools = showAudioTools;
+    showAudioToolsSetting.set(_showAudioTools);
+    emit showAudioToolsChanged(_showAudioTools);
 }
 
 void AvatarInputs::toggleCameraMute() {
@@ -133,10 +94,6 @@ void AvatarInputs::toggleCameraMute() {
     }
 }
 
-void AvatarInputs::toggleAudioMute() {
-    DependencyManager::get<AudioClient>()->toggleMute();
-}
-
 void AvatarInputs::resetSensors() {
     qApp->resetSensors();
 }

interface/src/ui/AvatarInputs.h

@@ -25,9 +25,6 @@ class AvatarInputs : public QQuickItem {
 
     AI_PROPERTY(bool, cameraEnabled, false)
     AI_PROPERTY(bool, cameraMuted, false)
-    AI_PROPERTY(bool, audioMuted, false)
-    AI_PROPERTY(bool, audioClipping, false)
-    AI_PROPERTY(float, audioLevel, 0)
     AI_PROPERTY(bool, isHMD, false)
 
     Q_PROPERTY(bool showAudioTools READ showAudioTools WRITE setShowAudioTools NOTIFY showAudioToolsChanged)
@@ -45,16 +42,12 @@ public slots:
 signals:
     void cameraEnabledChanged();
     void cameraMutedChanged();
-    void audioMutedChanged();
-    void audioClippingChanged();
-    void audioLevelChanged();
     void isHMDChanged();
-    void showAudioToolsChanged(bool showAudioTools);
+    void showAudioToolsChanged(bool show);
 
 protected:
     Q_INVOKABLE void resetSensors();
     Q_INVOKABLE void toggleCameraMute();
-    Q_INVOKABLE void toggleAudioMute();
 
 private: 
     float _trailingAudioLoudness{ 0 };

interface/src/ui/PreferencesDialog.cpp

@@ -227,17 +227,17 @@ void setupPreferences() {
         preferences->addPreference(preference);
     }
 
-    static const QString AUDIO("Audio");
+    static const QString AUDIO_BUFFERS("Audio Buffers");
     {
         auto getter = []()->bool { return !DependencyManager::get<AudioClient>()->getReceivedAudioStream().dynamicJitterBufferEnabled(); };
         auto setter = [](bool value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setDynamicJitterBufferEnabled(!value); };
-        auto preference = new CheckPreference(AUDIO, "Disable dynamic jitter buffer", getter, setter);
+        auto preference = new CheckPreference(AUDIO_BUFFERS, "Disable dynamic jitter buffer", getter, setter);
         preferences->addPreference(preference);
     }
     {
         auto getter = []()->float { return DependencyManager::get<AudioClient>()->getReceivedAudioStream().getStaticJitterBufferFrames(); };
         auto setter = [](float value) { DependencyManager::get<AudioClient>()->getReceivedAudioStream().setStaticJitterBufferFrames(value); };
-        auto preference = new SpinnerPreference(AUDIO, "Static jitter buffer frames", getter, setter);
+        auto preference = new SpinnerPreference(AUDIO_BUFFERS, "Static jitter buffer frames", getter, setter);
         preference->setMin(0);
         preference->setMax(2000);
         preference->setStep(1);
@@ -246,13 +246,13 @@ void setupPreferences() {
     {
         auto getter = []()->bool { return !DependencyManager::get<AudioClient>()->getOutputStarveDetectionEnabled(); };
         auto setter = [](bool value) { DependencyManager::get<AudioClient>()->setOutputStarveDetectionEnabled(!value); };
-        auto preference = new CheckPreference(AUDIO, "Disable output starve detection", getter, setter);
+        auto preference = new CheckPreference(AUDIO_BUFFERS, "Disable output starve detection", getter, setter);
         preferences->addPreference(preference);
     }
     {
         auto getter = []()->float { return DependencyManager::get<AudioClient>()->getOutputBufferSize(); };
         auto setter = [](float value) { DependencyManager::get<AudioClient>()->setOutputBufferSize(value); };
-        auto preference = new SpinnerPreference(AUDIO, "Output buffer initial frames", getter, setter);
+        auto preference = new SpinnerPreference(AUDIO_BUFFERS, "Output buffer initial frames", getter, setter);
         preference->setMin(AudioClient::MIN_BUFFER_FRAMES);
         preference->setMax(AudioClient::MAX_BUFFER_FRAMES);
         preference->setStep(1);
@@ -262,13 +262,13 @@ void setupPreferences() {
     {
         auto getter = []()->bool { return DependencyManager::get<AudioClient>()->isSimulatingJitter(); };
         auto setter = [](bool value) { return DependencyManager::get<AudioClient>()->setIsSimulatingJitter(value); };
-        auto preference = new CheckPreference(AUDIO, "Packet jitter simulator", getter, setter);
+        auto preference = new CheckPreference(AUDIO_BUFFERS, "Packet jitter simulator", getter, setter);
         preferences->addPreference(preference);
     }
     {
         auto getter = []()->float { return DependencyManager::get<AudioClient>()->getGateThreshold(); };
         auto setter = [](float value) { return DependencyManager::get<AudioClient>()->setGateThreshold(value); };
-        auto preference = new SpinnerPreference(AUDIO, "Packet throttle threshold", getter, setter);
+        auto preference = new SpinnerPreference(AUDIO_BUFFERS, "Packet throttle threshold", getter, setter);
         preference->setMin(1);
         preference->setMax(200);
         preference->setStep(1);

interface/src/ui/Stats.cpp

@@ -16,6 +16,7 @@
 #include <glm/gtx/quaternion.hpp>
 #include <glm/gtx/vector_angle.hpp>
 
+#include <render/Args.h>
 #include <avatar/AvatarManager.h>
 #include <Application.h>
 #include <AudioClient.h>
@@ -33,6 +34,7 @@
 #include "SequenceNumberStats.h"
 #include "StatTracker.h"
 
+
 HIFI_QML_DEF(Stats)
 
 using namespace std;
@@ -454,7 +456,7 @@ void Stats::updateStats(bool force) {
     }
 }
 
-void Stats::setRenderDetails(const RenderDetails& details) {
+void Stats::setRenderDetails(const render::RenderDetails& details) {
     STAT_UPDATE(triangles, details._trianglesRendered);
     STAT_UPDATE(materialSwitches, details._materialSwitches);
     if (_expanded) {

interface/src/ui/Stats.h

@@ -9,10 +9,11 @@
 #ifndef hifi_Stats_h
 #define hifi_Stats_h
 
+#include <QtGui/QVector3D>
+
 #include <OffscreenQmlElement.h>
-#include <RenderArgs.h>
-#include <QVector3D>
 #include <AudioIOStats.h>
+#include <render/Args.h>
 
 #define STATS_PROPERTY(type, name, initialValue) \
     Q_PROPERTY(type name READ name NOTIFY name##Changed) \
@@ -138,7 +139,7 @@ public:
 
     Stats(QQuickItem* parent = nullptr);
     bool includeTimingRecord(const QString& name);
-    void setRenderDetails(const RenderDetails& details);
+    void setRenderDetails(const render::RenderDetails& details);
     const QString& monospaceFont() {
         return _monospaceFont;
     }

interface/src/ui/overlays/Image3DOverlay.cpp

@@ -112,7 +112,7 @@ void Image3DOverlay::render(RenderArgs* args) {
         _geometryId
     );
 
-    batch->setResourceTexture(0, args->_whiteTexture); // restore default white color after me
+    batch->setResourceTexture(0, nullptr); // restore default white color after me
 }
 
 const render::ShapeKey Image3DOverlay::getShapeKey() {

interface/src/ui/overlays/LocalModelsOverlay.cpp

@@ -1,50 +0,0 @@
-//
-//  LocalModelsOverlay.cpp
-//  interface/src/ui/overlays
-//
-//  Created by Ryan Huffman on 07/08/14.
-//  Copyright 2014 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 "LocalModelsOverlay.h"
-
-#include <EntityTreeRenderer.h>
-#include <gpu/Batch.h>
-
-
-QString const LocalModelsOverlay::TYPE = "localmodels";
-
-LocalModelsOverlay::LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer) :
-    Volume3DOverlay(),
-    _entityTreeRenderer(entityTreeRenderer) {
-}
-
-LocalModelsOverlay::LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay) :
-    Volume3DOverlay(localModelsOverlay),
-    _entityTreeRenderer(localModelsOverlay->_entityTreeRenderer)
-{
-}
-
-void LocalModelsOverlay::update(float deltatime) {
-    _entityTreeRenderer->update();
-}
-
-void LocalModelsOverlay::render(RenderArgs* args) {
-    if (_visible) {
-        auto batch = args ->_batch;
-
-        Transform transform = Transform();
-        transform.setTranslation(args->getViewFrustum().getPosition() + getPosition());
-        batch->setViewTransform(transform);
-        _entityTreeRenderer->render(args);
-        transform.setTranslation(args->getViewFrustum().getPosition());
-        batch->setViewTransform(transform);
-    }
-}
-
-LocalModelsOverlay* LocalModelsOverlay::createClone() const {
-    return new LocalModelsOverlay(this);
-}

interface/src/ui/overlays/LocalModelsOverlay.h

@@ -1,37 +0,0 @@
-//
-//  LocalModelsOverlay.h
-//  interface/src/ui/overlays
-//
-//  Created by Ryan Huffman on 07/08/14.
-//  Copyright 2014 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_LocalModelsOverlay_h
-#define hifi_LocalModelsOverlay_h
-
-#include "Volume3DOverlay.h"
-
-class EntityTreeRenderer;
-
-class LocalModelsOverlay : public Volume3DOverlay {
-    Q_OBJECT
-public:
-    static QString const TYPE;
-    virtual QString getType() const override { return TYPE; }
-
-    LocalModelsOverlay(EntityTreeRenderer* entityTreeRenderer);
-    LocalModelsOverlay(const LocalModelsOverlay* localModelsOverlay);
-
-    virtual void update(float deltatime) override;
-    virtual void render(RenderArgs* args) override;
-
-    virtual LocalModelsOverlay* createClone() const override;
-
-private:
-    EntityTreeRenderer* _entityTreeRenderer;
-};
-
-#endif // hifi_LocalModelsOverlay_h

interface/src/ui/overlays/Overlays.cpp

@@ -26,7 +26,6 @@
 #include "Shape3DOverlay.h"
 #include "ImageOverlay.h"
 #include "Line3DOverlay.h"
-#include "LocalModelsOverlay.h"
 #include "ModelOverlay.h"
 #include "Rectangle3DOverlay.h"
 #include "Sphere3DOverlay.h"
@@ -171,8 +170,6 @@ OverlayID Overlays::addOverlay(const QString& type, const QVariant& properties)
         thisOverlay = std::make_shared<Line3DOverlay>();
     } else if (type == Grid3DOverlay::TYPE) {
         thisOverlay = std::make_shared<Grid3DOverlay>();
-    } else if (type == LocalModelsOverlay::TYPE) {
-        thisOverlay = std::make_shared<LocalModelsOverlay>(qApp->getEntityClipboardRenderer());
     } else if (type == ModelOverlay::TYPE) {
         thisOverlay = std::make_shared<ModelOverlay>();
     } else if (type == Web3DOverlay::TYPE) {

interface/src/ui/overlays/OverlaysPayload.cpp

@@ -21,7 +21,6 @@
 #include "Cube3DOverlay.h"
 #include "ImageOverlay.h"
 #include "Line3DOverlay.h"
-#include "LocalModelsOverlay.h"
 #include "ModelOverlay.h"
 #include "Overlays.h"
 #include "Rectangle3DOverlay.h"

interface/src/ui/overlays/Web3DOverlay.cpp

@@ -47,11 +47,12 @@
 #include "LODManager.h"
 #include "ui/OctreeStatsProvider.h"
 #include "ui/DomainConnectionModel.h"
-#include "scripting/AudioDeviceScriptingInterface.h"
 #include "ui/AvatarInputs.h"
 #include "avatar/AvatarManager.h"
 #include "scripting/GlobalServicesScriptingInterface.h"
+#include <plugins/InputConfiguration.h>
 #include "ui/Snapshot.h"
+#include "SoundCache.h"
 
 static const float DPI = 30.47f;
 static const float INCHES_TO_METERS = 1.0f / 39.3701f;
@@ -182,9 +183,11 @@ void Web3DOverlay::loadSourceURL() {
         if (_webSurface->getRootItem() && _webSurface->getRootItem()->objectName() == "tabletRoot") {
             auto tabletScriptingInterface = DependencyManager::get<TabletScriptingInterface>();
             auto flags = tabletScriptingInterface->getFlags();
+
             _webSurface->getSurfaceContext()->setContextProperty("offscreenFlags", flags);
             _webSurface->getSurfaceContext()->setContextProperty("AddressManager", DependencyManager::get<AddressManager>().data());
             _webSurface->getSurfaceContext()->setContextProperty("Account", AccountScriptingInterface::getInstance());
+            _webSurface->getSurfaceContext()->setContextProperty("Audio", DependencyManager::get<AudioScriptingInterface>().data());
             _webSurface->getSurfaceContext()->setContextProperty("AudioStats", DependencyManager::get<AudioClient>()->getStats().data());
             _webSurface->getSurfaceContext()->setContextProperty("HMD", DependencyManager::get<HMDScriptingInterface>().data());
             _webSurface->getSurfaceContext()->setContextProperty("fileDialogHelper", new FileDialogHelper());
@@ -195,11 +198,12 @@ void Web3DOverlay::loadSourceURL() {
             _webSurface->getSurfaceContext()->setContextProperty("LODManager", DependencyManager::get<LODManager>().data());
             _webSurface->getSurfaceContext()->setContextProperty("OctreeStats", DependencyManager::get<OctreeStatsProvider>().data());
             _webSurface->getSurfaceContext()->setContextProperty("DCModel", DependencyManager::get<DomainConnectionModel>().data());
-            _webSurface->getSurfaceContext()->setContextProperty("AudioDevice", AudioDeviceScriptingInterface::getInstance());
             _webSurface->getSurfaceContext()->setContextProperty("AvatarInputs", AvatarInputs::getInstance());
             _webSurface->getSurfaceContext()->setContextProperty("GlobalServices", GlobalServicesScriptingInterface::getInstance());
             _webSurface->getSurfaceContext()->setContextProperty("AvatarList", DependencyManager::get<AvatarManager>().data());
             _webSurface->getSurfaceContext()->setContextProperty("DialogsManager", DialogsManagerScriptingInterface::getInstance());
+            _webSurface->getSurfaceContext()->setContextProperty("InputConfiguration", DependencyManager::get<InputConfiguration>().data());
+            _webSurface->getSurfaceContext()->setContextProperty("SoundCache", DependencyManager::get<SoundCache>().data());
 
             _webSurface->getSurfaceContext()->setContextProperty("pathToFonts", "../../");
             tabletScriptingInterface->setQmlTabletRoot("com.highfidelity.interface.tablet.system", _webSurface->getRootItem(), _webSurface.data());
@@ -319,7 +323,7 @@ void Web3DOverlay::render(RenderArgs* args) {
         geometryCache->bindOpaqueWebBrowserProgram(batch, _isAA);
     }
     geometryCache->renderQuad(batch, halfSize * -1.0f, halfSize, vec2(0), vec2(1), color, _geometryId);
-    batch.setResourceTexture(0, args->_whiteTexture); // restore default white color after me
+    batch.setResourceTexture(0, nullptr); // restore default white color after me
 }
 
 const render::ShapeKey Web3DOverlay::getShapeKey() {
@@ -441,17 +445,27 @@ void Web3DOverlay::handlePointerEventAsTouch(const PointerEvent& event) {
     touchEvent->setTouchPoints(touchPoints);
     touchEvent->setTouchPointStates(touchPointState);
 
+    // Send mouse events to the Web surface so that HTML dialog elements work with mouse press and hover.
+    // FIXME: Scroll bar dragging is a bit unstable in the tablet (content can jump up and down at times).
+    // This may be improved in Qt 5.8. Release notes: "Cleaned up touch and mouse event delivery".
+    //
+    // In Qt 5.9 mouse events must be sent before touch events to make sure some QtQuick components will
+    // receive mouse events
+#if QT_VERSION >= QT_VERSION_CHECK(5, 9, 0)
+    if (!(this->_pressed && event.getType() == PointerEvent::Move)) {
+        QMouseEvent* mouseEvent = new QMouseEvent(mouseType, windowPoint, windowPoint, windowPoint, button, buttons, Qt::NoModifier);
+        QCoreApplication::postEvent(_webSurface->getWindow(), mouseEvent);
+    }
+#endif
     QCoreApplication::postEvent(_webSurface->getWindow(), touchEvent);
 
-    if (this->_pressed && event.getType() == PointerEvent::Move) {	
+#if QT_VERSION < QT_VERSION_CHECK(5, 9, 0)
+    if (this->_pressed && event.getType() == PointerEvent::Move) {
         return;
     }
-    // Send mouse events to the Web surface so that HTML dialog elements work with mouse press and hover.
-    // FIXME: Scroll bar dragging is a bit unstable in the tablet (content can jump up and down at times). 
-    // This may be improved in Qt 5.8. Release notes: "Cleaned up touch and mouse event delivery".
-
     QMouseEvent* mouseEvent = new QMouseEvent(mouseType, windowPoint, windowPoint, windowPoint, button, buttons, Qt::NoModifier);
     QCoreApplication::postEvent(_webSurface->getWindow(), mouseEvent);
+#endif
 }
 
 void Web3DOverlay::handlePointerEventAsMouse(const PointerEvent& event) {

libraries/animation/CMakeLists.txt

@@ -1,5 +1,7 @@
 set(TARGET_NAME animation)
 setup_hifi_library(Network Script)
 link_hifi_libraries(shared model fbx)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(gpu)
 
 target_nsight()

libraries/animation/src/Rig.cpp

@@ -1164,9 +1164,32 @@ void Rig::updateFromHandAndFeetParameters(const HandAndFeetParameters& params, f
         bool bodySensorTrackingEnabled = params.isLeftFootEnabled || params.isRightFootEnabled;
 
         const float RELAX_DURATION = 0.6f;
+        const float CONTROL_DURATION = 0.4f;
+        const bool TO_CONTROLLED = true;
+        const bool FROM_CONTROLLED = false;
+        const bool LEFT_HAND = true;
+        const bool RIGHT_HAND = false;
 
         if (params.isLeftEnabled) {
+            if (!_isLeftHandControlled) {
+                _leftHandControlTimeRemaining = CONTROL_DURATION;
+                _isLeftHandControlled = true;
+            }
+
             glm::vec3 handPosition = params.leftPosition;
+            glm::quat handRotation = params.leftOrientation;
+
+            if (_leftHandControlTimeRemaining > 0.0f) {
+                // Move hand from non-controlled position to controlled position.
+                _leftHandControlTimeRemaining = std::max(_leftHandControlTimeRemaining - dt, 0.0f);
+                AnimPose handPose(Vectors::ONE, handRotation, handPosition);
+                if (transitionHandPose(_leftHandControlTimeRemaining, CONTROL_DURATION, handPose, LEFT_HAND, TO_CONTROLLED, 
+                        handPose)) {
+                    handPosition = handPose.trans();
+                    handRotation = handPose.rot();
+                }
+            }
+
             if (!bodySensorTrackingEnabled) {
                 // prevent the hand IK targets from intersecting the body capsule
                 glm::vec3 displacement;
@@ -1176,27 +1199,22 @@ void Rig::updateFromHandAndFeetParameters(const HandAndFeetParameters& params, f
             }
 
             _animVars.set("leftHandPosition", handPosition);
-            _animVars.set("leftHandRotation", params.leftOrientation);
+            _animVars.set("leftHandRotation", handRotation);
             _animVars.set("leftHandType", (int)IKTarget::Type::RotationAndPosition);
 
-            _isLeftHandControlled = true;
-            _lastLeftHandControlledPose = AnimPose(glm::vec3(1.0f), params.leftOrientation, handPosition);
+            _lastLeftHandControlledPose = AnimPose(Vectors::ONE, handRotation, handPosition);
         } else {
             if (_isLeftHandControlled) {
-                _leftHandRelaxDuration = RELAX_DURATION;
+                _leftHandRelaxTimeRemaining = RELAX_DURATION;
                 _isLeftHandControlled = false;
             }
 
-            if (_leftHandRelaxDuration > 0) {
+            if (_leftHandRelaxTimeRemaining > 0.0f) {
                 // Move hand from controlled position to non-controlled position.
-                _leftHandRelaxDuration = std::max(_leftHandRelaxDuration - dt, 0.0f);
-                auto ikNode = getAnimInverseKinematicsNode();
-                if (ikNode) {
-                    float alpha = 1.0f - _leftHandRelaxDuration / RELAX_DURATION;
-                    const AnimPose geometryToRigTransform(_geometryToRigTransform);
-                    AnimPose uncontrolledHandPose = geometryToRigTransform * ikNode->getUncontrolledLeftHandPose();
-                    AnimPose handPose;
-                    ::blend(1, &_lastLeftHandControlledPose, &uncontrolledHandPose, alpha, &handPose);
+                _leftHandRelaxTimeRemaining = std::max(_leftHandRelaxTimeRemaining - dt, 0.0f);
+                AnimPose handPose;
+                if (transitionHandPose(_leftHandRelaxTimeRemaining, RELAX_DURATION, _lastLeftHandControlledPose, LEFT_HAND, 
+                        FROM_CONTROLLED, handPose)) {
                     _animVars.set("leftHandPosition", handPose.trans());
                     _animVars.set("leftHandRotation", handPose.rot());
                     _animVars.set("leftHandType", (int)IKTarget::Type::RotationAndPosition);
@@ -1209,7 +1227,25 @@ void Rig::updateFromHandAndFeetParameters(const HandAndFeetParameters& params, f
         }
 
         if (params.isRightEnabled) {
+            if (!_isRightHandControlled) {
+                _rightHandControlTimeRemaining = CONTROL_DURATION;
+                _isRightHandControlled = true;
+            }
+
             glm::vec3 handPosition = params.rightPosition;
+            glm::quat handRotation = params.rightOrientation;
+
+            if (_rightHandControlTimeRemaining > 0.0f) {
+                // Move hand from non-controlled position to controlled position.
+                _rightHandControlTimeRemaining = std::max(_rightHandControlTimeRemaining - dt, 0.0f);
+                AnimPose handPose(Vectors::ONE, handRotation, handPosition);
+                if (transitionHandPose(_rightHandControlTimeRemaining, CONTROL_DURATION, handPose, RIGHT_HAND, TO_CONTROLLED, 
+                        handPose)) {
+                    handPosition = handPose.trans();
+                    handRotation = handPose.rot();
+                }
+            }
+
             if (!bodySensorTrackingEnabled) {
                 // prevent the hand IK targets from intersecting the body capsule
                 glm::vec3 displacement;
@@ -1219,27 +1255,22 @@ void Rig::updateFromHandAndFeetParameters(const HandAndFeetParameters& params, f
             }
 
             _animVars.set("rightHandPosition", handPosition);
-            _animVars.set("rightHandRotation", params.rightOrientation);
+            _animVars.set("rightHandRotation", handRotation);
             _animVars.set("rightHandType", (int)IKTarget::Type::RotationAndPosition);
 
-            _isRightHandControlled = true;
-            _lastRightHandControlledPose = AnimPose(glm::vec3(1.0f), params.rightOrientation, handPosition);
+            _lastRightHandControlledPose = AnimPose(Vectors::ONE, handRotation, handPosition);
         } else {
             if (_isRightHandControlled) {
-                _rightHandRelaxDuration = RELAX_DURATION;
+                _rightHandRelaxTimeRemaining = RELAX_DURATION;
                 _isRightHandControlled = false;
             }
 
-            if (_rightHandRelaxDuration > 0) {
+            if (_rightHandRelaxTimeRemaining > 0.0f) {
                 // Move hand from controlled position to non-controlled position.
-                _rightHandRelaxDuration = std::max(_rightHandRelaxDuration - dt, 0.0f);
-                auto ikNode = getAnimInverseKinematicsNode();
-                if (ikNode) {
-                    float alpha = 1.0f - _rightHandRelaxDuration / RELAX_DURATION;
-                    const AnimPose geometryToRigTransform(_geometryToRigTransform);
-                    AnimPose uncontrolledHandPose = geometryToRigTransform * ikNode->getUncontrolledRightHandPose();
-                    AnimPose handPose;
-                    ::blend(1, &_lastRightHandControlledPose, &uncontrolledHandPose, alpha, &handPose);
+                _rightHandRelaxTimeRemaining = std::max(_rightHandRelaxTimeRemaining - dt, 0.0f);
+                AnimPose handPose;
+                if (transitionHandPose(_rightHandRelaxTimeRemaining, RELAX_DURATION, _lastRightHandControlledPose, RIGHT_HAND, 
+                        FROM_CONTROLLED, handPose)) {
                     _animVars.set("rightHandPosition", handPose.trans());
                     _animVars.set("rightHandRotation", handPose.rot());
                     _animVars.set("rightHandType", (int)IKTarget::Type::RotationAndPosition);
@@ -1545,3 +1576,25 @@ void Rig::computeAvatarBoundingCapsule(
     glm::vec3 rigCenter = (geometryToRig * (0.5f * (totalExtents.maximum + totalExtents.minimum)));
     localOffsetOut = rigCenter - (geometryToRig * rootPosition);
 }
+
+bool Rig::transitionHandPose(float deltaTime, float totalDuration, AnimPose& controlledHandPose, bool isLeftHand,
+                             bool isToControlled, AnimPose& returnHandPose) {
+    auto ikNode = getAnimInverseKinematicsNode();
+    if (ikNode) {
+        float alpha = 1.0f - deltaTime / totalDuration;
+        const AnimPose geometryToRigTransform(_geometryToRigTransform);
+        AnimPose uncontrolledHandPose;
+        if (isLeftHand) {
+            uncontrolledHandPose = geometryToRigTransform * ikNode->getUncontrolledLeftHandPose();
+        } else {
+            uncontrolledHandPose = geometryToRigTransform * ikNode->getUncontrolledRightHandPose();
+        }
+        if (isToControlled) {
+            ::blend(1, &uncontrolledHandPose, &controlledHandPose, alpha, &returnHandPose);
+        } else {
+            ::blend(1, &controlledHandPose, &uncontrolledHandPose, alpha, &returnHandPose);
+        }
+        return true;
+    }
+    return false;
+}

libraries/animation/src/Rig.h

@@ -352,10 +352,15 @@ private:
     int _nextStateHandlerId { 0 };
     QMutex _stateMutex;
 
+    bool transitionHandPose(float deltaTime, float totalDuration, AnimPose& controlledHandPose, bool isLeftHand, 
+        bool isToControlled, AnimPose& returnHandPose);
+
     bool _isLeftHandControlled { false };
     bool _isRightHandControlled { false };
-    float _leftHandRelaxDuration { 0.0f };
-    float _rightHandRelaxDuration { 0.0f };
+    float _leftHandControlTimeRemaining { 0.0f };
+    float _rightHandControlTimeRemaining { 0.0f };
+    float _leftHandRelaxTimeRemaining { 0.0f };
+    float _rightHandRelaxTimeRemaining { 0.0f };
     AnimPose _lastLeftHandControlledPose;
     AnimPose _lastRightHandControlledPose;
 };

libraries/audio-client/CMakeLists.txt

@@ -1,6 +1,8 @@
 set(TARGET_NAME audio-client)
 setup_hifi_library(Network Multimedia)
 link_hifi_libraries(audio plugins)
+include_hifi_library_headers(shared)
+include_hifi_library_headers(networking)
 
 # append audio includes to our list of includes to bubble
 target_include_directories(${TARGET_NAME} PUBLIC "${HIFI_LIBRARY_DIR}/audio/src")

libraries/audio-client/src/AudioClient.cpp

@@ -79,6 +79,49 @@ using Mutex = std::mutex;
 using Lock = std::unique_lock<Mutex>;
 static Mutex _deviceMutex;
 
+// thread-safe
+QList<QAudioDeviceInfo> getAvailableDevices(QAudio::Mode mode) {
+    // NOTE: availableDevices() clobbers the Qt internal device list
+    Lock lock(_deviceMutex);
+    return QAudioDeviceInfo::availableDevices(mode);
+}
+
+// now called from a background thread, to keep blocking operations off the audio thread
+void AudioClient::checkDevices() {
+    auto inputDevices = getAvailableDevices(QAudio::AudioInput);
+    auto outputDevices = getAvailableDevices(QAudio::AudioOutput);
+
+    if (inputDevices != _inputDevices) {
+        _inputDevices.swap(inputDevices);
+        emit devicesChanged(QAudio::AudioInput, _inputDevices);
+    }
+
+    if (outputDevices != _outputDevices) {
+        _outputDevices.swap(outputDevices);
+        emit devicesChanged(QAudio::AudioOutput, _outputDevices);
+    }
+}
+
+QAudioDeviceInfo AudioClient::getActiveAudioDevice(QAudio::Mode mode) const {
+    Lock lock(_deviceMutex);
+
+    if (mode == QAudio::AudioInput) {
+        return _inputDeviceInfo;
+    } else { // if (mode == QAudio::AudioOutput)
+        return _outputDeviceInfo;
+    }
+}
+
+QList<QAudioDeviceInfo> AudioClient::getAudioDevices(QAudio::Mode mode) const {
+    Lock lock(_deviceMutex);
+
+    if (mode == QAudio::AudioInput) {
+        return _inputDevices;
+    } else { // if (mode == QAudio::AudioOutput)
+        return _outputDevices;
+    }
+}
+
 static void channelUpmix(int16_t* source, int16_t* dest, int numSamples, int numExtraChannels) {
     for (int i = 0; i < numSamples/2; i++) {
 
@@ -173,8 +216,9 @@ AudioClient::AudioClient() :
 
     connect(&_receivedAudioStream, &InboundAudioStream::mismatchedAudioCodec, this, &AudioClient::handleMismatchAudioFormat);
 
-    _inputDevices = getDeviceNames(QAudio::AudioInput);
-    _outputDevices = getDeviceNames(QAudio::AudioOutput);
+    // 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
@@ -241,13 +285,6 @@ void AudioClient::audioMixerKilled() {
     emit disconnected();
 }
 
-// thread-safe
-QList<QAudioDeviceInfo> getAvailableDevices(QAudio::Mode mode) {
-    // NOTE: availableDevices() clobbers the Qt internal device list
-    Lock lock(_deviceMutex);
-    return QAudioDeviceInfo::availableDevices(mode);
-}
-
 QAudioDeviceInfo getNamedAudioDeviceForMode(QAudio::Mode mode, const QString& deviceName) {
     QAudioDeviceInfo result;
     foreach(QAudioDeviceInfo audioDevice, getAvailableDevices(mode)) {
@@ -261,7 +298,7 @@ QAudioDeviceInfo getNamedAudioDeviceForMode(QAudio::Mode mode, const QString& de
 }
 
 #ifdef Q_OS_WIN
-QString friendlyNameForAudioDevice(IMMDevice* pEndpoint) {
+QString getWinDeviceName(IMMDevice* pEndpoint) {
     QString deviceName;
     IPropertyStore* pPropertyStore;
     pEndpoint->OpenPropertyStore(STGM_READ, &pPropertyStore);
@@ -282,7 +319,7 @@ QString friendlyNameForAudioDevice(IMMDevice* pEndpoint) {
     return deviceName;
 }
 
-QString AudioClient::friendlyNameForAudioDevice(wchar_t* guid) {
+QString AudioClient::getWinDeviceName(wchar_t* guid) {
     QString deviceName;
     HRESULT hr = S_OK;
     CoInitialize(nullptr);
@@ -294,7 +331,7 @@ QString AudioClient::friendlyNameForAudioDevice(wchar_t* guid) {
         printf("Audio Error: device not found\n");
         deviceName = QString("NONE");
     } else {
-        deviceName = ::friendlyNameForAudioDevice(pEndpoint);
+        deviceName = ::getWinDeviceName(pEndpoint);
     }
     pMMDeviceEnumerator->Release();
     pMMDeviceEnumerator = nullptr;
@@ -377,7 +414,7 @@ QAudioDeviceInfo defaultAudioDeviceForMode(QAudio::Mode mode) {
             printf("Audio Error: device not found\n");
             deviceName = QString("NONE");
         } else {
-            deviceName = friendlyNameForAudioDevice(pEndpoint);
+            deviceName = getWinDeviceName(pEndpoint);
         }
         pMMDeviceEnumerator->Release();
         pMMDeviceEnumerator = NULL;
@@ -395,6 +432,11 @@ QAudioDeviceInfo defaultAudioDeviceForMode(QAudio::Mode mode) {
     return (mode == QAudio::AudioInput) ? QAudioDeviceInfo::defaultInputDevice() : QAudioDeviceInfo::defaultOutputDevice();
 }
 
+bool AudioClient::getNamedAudioDeviceForModeExists(QAudio::Mode mode, const QString& deviceName) {
+    return (getNamedAudioDeviceForMode(mode, deviceName).deviceName() == deviceName);
+}
+
+
 // attempt to use the native sample rate and channel count
 bool nativeFormatForAudioDevice(const QAudioDeviceInfo& audioDevice,
                                 QAudioFormat& audioFormat) {
@@ -742,29 +784,22 @@ void AudioClient::selectAudioFormat(const QString& selectedCodecName) {
 
 }
    
+bool AudioClient::switchAudioDevice(QAudio::Mode mode, const QAudioDeviceInfo& deviceInfo) {
+    auto device = deviceInfo;
 
-QString AudioClient::getDefaultDeviceName(QAudio::Mode mode) {
-    QAudioDeviceInfo deviceInfo = defaultAudioDeviceForMode(mode);
-    return deviceInfo.deviceName();
-}
-
-QVector<QString> AudioClient::getDeviceNames(QAudio::Mode mode) {
-    QVector<QString> deviceNames;
-    const QList<QAudioDeviceInfo> &availableDevice = getAvailableDevices(mode);
-    foreach(const QAudioDeviceInfo &audioDevice, availableDevice) {
-        deviceNames << audioDevice.deviceName().trimmed();
+    if (device.isNull()) {
+        device = defaultAudioDeviceForMode(mode);
+    }
+
+    if (mode == QAudio::AudioInput) {
+        return switchInputToAudioDevice(device);
+    } else { // if (mode == QAudio::AudioOutput)
+        return switchOutputToAudioDevice(device);
     }
-    return deviceNames;
 }
 
-bool AudioClient::switchInputToAudioDevice(const QString& inputDeviceName) {
-    qCDebug(audioclient) << "switchInputToAudioDevice [" << inputDeviceName << "] [" << getNamedAudioDeviceForMode(QAudio::AudioInput, inputDeviceName).deviceName() << "]";
-    return switchInputToAudioDevice(getNamedAudioDeviceForMode(QAudio::AudioInput, inputDeviceName));
-}
-
-bool AudioClient::switchOutputToAudioDevice(const QString& outputDeviceName) {
-    qCDebug(audioclient) << "switchOutputToAudioDevice [" << outputDeviceName << "] [" << getNamedAudioDeviceForMode(QAudio::AudioOutput, outputDeviceName).deviceName() << "]";
-    return switchOutputToAudioDevice(getNamedAudioDeviceForMode(QAudio::AudioOutput, outputDeviceName));
+bool AudioClient::switchAudioDevice(QAudio::Mode mode, const QString& deviceName) {
+    return switchAudioDevice(mode, getNamedAudioDeviceForMode(mode, deviceName));
 }
 
 void AudioClient::configureReverb() {
@@ -988,6 +1023,8 @@ void AudioClient::handleAudioInput(QByteArray& audioBuffer) {
         emit inputReceived(audioBuffer);
     }
 
+    emit inputLoudnessChanged(_lastInputLoudness);
+
     // state machine to detect gate opening and closing
     bool audioGateOpen = (_lastInputLoudness != 0.0f);
     bool openedInLastBlock = !_audioGateOpen && audioGateOpen;  // the gate just opened
@@ -1308,8 +1345,7 @@ void AudioClient::setIsStereoInput(bool isStereoInput) {
         }
 
         // change in channel count for desired input format, restart the input device
-        qCDebug(audioclient) << __FUNCTION__ << "about to call switchInputToAudioDevice:" << _inputAudioDeviceName;
-        switchInputToAudioDevice(_inputAudioDeviceName);
+        switchInputToAudioDevice(_inputDeviceInfo);
     }
 }
 
@@ -1348,6 +1384,9 @@ bool AudioClient::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceIn
     qCDebug(audioclient) << __FUNCTION__ << "inputDeviceInfo: [" << inputDeviceInfo.deviceName() << "]";
     bool supportedFormat = false;
 
+    // NOTE: device start() uses the Qt internal device list
+    Lock lock(_deviceMutex);
+
     // cleanup any previously initialized device
     if (_audioInput) {
         // The call to stop() causes _inputDevice to be destructed.
@@ -1360,7 +1399,7 @@ bool AudioClient::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceIn
         _audioInput = NULL;
         _numInputCallbackBytes = 0;
 
-        _inputAudioDeviceName = "";
+        _inputDeviceInfo = QAudioDeviceInfo();
     }
 
     if (_inputToNetworkResampler) {
@@ -1375,8 +1414,8 @@ bool AudioClient::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceIn
 
     if (!inputDeviceInfo.isNull()) {
         qCDebug(audioclient) << "The audio input device " << inputDeviceInfo.deviceName() << "is available.";
-        _inputAudioDeviceName = inputDeviceInfo.deviceName().trimmed();
-        emit currentInputDeviceChanged(_inputAudioDeviceName);
+        _inputDeviceInfo = inputDeviceInfo;
+        emit deviceChanged(QAudio::AudioInput, inputDeviceInfo);
 
         if (adjustedFormatForAudioDevice(inputDeviceInfo, _desiredInputFormat, _inputFormat)) {
             qCDebug(audioclient) << "The format to be used for audio input is" << _inputFormat;
@@ -1411,10 +1450,7 @@ bool AudioClient::switchInputToAudioDevice(const QAudioDeviceInfo& inputDeviceIn
                 int numFrameSamples = calculateNumberOfFrameSamples(_numInputCallbackBytes);
                 _inputRingBuffer.resizeForFrameSize(numFrameSamples);
 
-                // NOTE: device start() uses the Qt internal device list
-                Lock lock(_deviceMutex);
                 _inputDevice = _audioInput->start();
-                lock.unlock();
 
                 if (_inputDevice) {
                     connect(_inputDevice, SIGNAL(readyRead()), this, SLOT(handleMicAudioInput()));
@@ -1464,6 +1500,9 @@ bool AudioClient::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDevice
 
     bool supportedFormat = false;
 
+    // NOTE: device start() uses the Qt internal device list
+    Lock lock(_deviceMutex);
+
     Lock localAudioLock(_localAudioMutex);
     _localSamplesAvailable.exchange(0, std::memory_order_release);
 
@@ -1489,6 +1528,8 @@ bool AudioClient::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDevice
 
         delete[] _localOutputMixBuffer;
         _localOutputMixBuffer = NULL;
+
+        _outputDeviceInfo = QAudioDeviceInfo();
     }
 
     if (_networkToOutputResampler) {
@@ -1502,8 +1543,8 @@ bool AudioClient::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDevice
 
     if (!outputDeviceInfo.isNull()) {
         qCDebug(audioclient) << "The audio output device " << outputDeviceInfo.deviceName() << "is available.";
-        _outputAudioDeviceName = outputDeviceInfo.deviceName().trimmed();
-        emit currentOutputDeviceChanged(_outputAudioDeviceName);
+        _outputDeviceInfo = outputDeviceInfo;
+        emit deviceChanged(QAudio::AudioOutput, outputDeviceInfo);
 
         if (adjustedFormatForAudioDevice(outputDeviceInfo, _desiredOutputFormat, _outputFormat)) {
             qCDebug(audioclient) << "The format to be used for audio output is" << _outputFormat;
@@ -1578,10 +1619,7 @@ bool AudioClient::switchOutputToAudioDevice(const QAudioDeviceInfo& outputDevice
 
             _audioOutputIODevice.start();
 
-            // NOTE: device start() uses the Qt internal device list
-            Lock lock(_deviceMutex);
             _audioOutput->start(&_audioOutputIODevice);
-            lock.unlock();
 
             // setup a loopback audio output device
             _loopbackAudioOutput = new QAudioOutput(outputDeviceInfo, _outputFormat, this);
@@ -1781,19 +1819,6 @@ qint64 AudioClient::AudioOutputIODevice::readData(char * data, qint64 maxSize) {
     return bytesWritten;
 }
 
-// now called from a background thread, to keep blocking operations off the audio thread
-void AudioClient::checkDevices() {
-    QVector<QString> inputDevices = getDeviceNames(QAudio::AudioInput);
-    QVector<QString> outputDevices = getDeviceNames(QAudio::AudioOutput);
-
-    if (inputDevices != _inputDevices || outputDevices != _outputDevices) {
-        _inputDevices = inputDevices;
-        _outputDevices = outputDevices;
-
-        emit deviceChanged();
-    }
-}
-
 void AudioClient::loadSettings() {
     _receivedAudioStream.setDynamicJitterBufferEnabled(dynamicJitterBufferEnabled.get());
     _receivedAudioStream.setStaticJitterBufferFrames(staticJitterBufferFrames.get());

libraries/audio-client/src/AudioClient.h

@@ -123,8 +123,6 @@ public:
     float getTimeSinceLastClip() const { return _timeSinceLastClip; }
     float getAudioAverageInputLoudness() const { return _lastInputLoudness; }
 
-    bool isMuted() { return _muted; }
-
     const AudioIOStats& getStats() const { return _stats; }
 
     int getOutputBufferSize() { return _outputBufferSizeFrames.get(); }
@@ -147,10 +145,15 @@ public:
 
     bool outputLocalInjector(AudioInjector* injector) override;
 
+    QAudioDeviceInfo getActiveAudioDevice(QAudio::Mode mode) const;
+    QList<QAudioDeviceInfo> getAudioDevices(QAudio::Mode mode) const;
+
     static const float CALLBACK_ACCELERATOR_RATIO;
 
+    bool getNamedAudioDeviceForModeExists(QAudio::Mode mode, const QString& deviceName);
+
 #ifdef Q_OS_WIN
-    static QString friendlyNameForAudioDevice(wchar_t* guid);
+    static QString getWinDeviceName(wchar_t* guid);
 #endif
 
 public slots:
@@ -170,11 +173,14 @@ public slots:
     void handleRecordedAudioInput(const QByteArray& audio);
     void reset();
     void audioMixerKilled();
+
     void toggleMute();
+    bool isMuted() { return _muted; }
+
 
     virtual void setIsStereoInput(bool stereo) override;
 
-    void toggleAudioNoiseReduction() { _isNoiseGateEnabled = !_isNoiseGateEnabled; }
+    void setNoiseReduction(bool isNoiseGateEnabled) { _isNoiseGateEnabled = isNoiseGateEnabled; }
 
     void toggleLocalEcho() { _shouldEchoLocally = !_shouldEchoLocally; }
     void toggleServerEcho() { _shouldEchoToServer = !_shouldEchoToServer; }
@@ -186,12 +192,9 @@ public slots:
 
     bool shouldLoopbackInjectors() override { return _shouldEchoToServer; }
 
-    bool switchInputToAudioDevice(const QString& inputDeviceName);
-    bool switchOutputToAudioDevice(const QString& outputDeviceName);
-    QString getDeviceName(QAudio::Mode mode) const { return (mode == QAudio::AudioInput) ?
-                                                            _inputAudioDeviceName : _outputAudioDeviceName; }
-    QString getDefaultDeviceName(QAudio::Mode mode);
-    QVector<QString> getDeviceNames(QAudio::Mode mode);
+    // calling with a null QAudioDevice will use the system default
+    bool switchAudioDevice(QAudio::Mode mode, const QAudioDeviceInfo& deviceInfo = QAudioDeviceInfo());
+    bool switchAudioDevice(QAudio::Mode mode, const QString& deviceName);
 
     float getInputVolume() const { return (_audioInput) ? (float)_audioInput->volume() : 0.0f; }
     void setInputVolume(float volume) { if (_audioInput) _audioInput->setVolume(volume); }
@@ -207,13 +210,16 @@ signals:
     bool muteToggled();
     void mutedByMixer();
     void inputReceived(const QByteArray& inputSamples);
+    void inputLoudnessChanged(float loudness);
     void outputBytesToNetwork(int numBytes);
     void inputBytesFromNetwork(int numBytes);
     void noiseGateOpened();
     void noiseGateClosed();
 
     void changeDevice(const QAudioDeviceInfo& outputDeviceInfo);
-    void deviceChanged();
+
+    void deviceChanged(QAudio::Mode mode, const QAudioDeviceInfo& device);
+    void devicesChanged(QAudio::Mode mode, const QList<QAudioDeviceInfo>& devices);
 
     void receivedFirstPacket();
     void disconnected();
@@ -222,9 +228,6 @@ signals:
 
     void muteEnvironmentRequested(glm::vec3 position, float radius);
 
-    void currentOutputDeviceChanged(const QString& name);
-    void currentInputDeviceChanged(const QString& name);
-
 protected:
     AudioClient();
     ~AudioClient();
@@ -291,9 +294,6 @@ private:
     MixedProcessedAudioStream _receivedAudioStream;
     bool _isStereoInput;
 
-    QString _inputAudioDeviceName;
-    QString _outputAudioDeviceName;
-
     quint64 _outputStarveDetectionStartTimeMsec;
     int _outputStarveDetectionCount;
 
@@ -369,8 +369,11 @@ private:
     glm::vec3 avatarBoundingBoxCorner;
     glm::vec3 avatarBoundingBoxScale;
 
-    QVector<QString> _inputDevices;
-    QVector<QString> _outputDevices;
+    QAudioDeviceInfo _inputDeviceInfo;
+    QAudioDeviceInfo _outputDeviceInfo;
+
+    QList<QAudioDeviceInfo> _inputDevices;
+    QList<QAudioDeviceInfo> _outputDevices;
 
     bool _hasReceivedFirstPacket { false };
 

libraries/audio/src/InboundAudioStream.cpp

@@ -127,6 +127,7 @@ int InboundAudioStream::parseData(ReceivedMessage& message) {
     // parse the info after the seq number and before the audio data (the stream properties)
     int prePropertyPosition = message.getPosition();
     int propertyBytes = parseStreamProperties(message.getType(), message.readWithoutCopy(message.getBytesLeftToRead()), networkFrames);
+
     message.seek(prePropertyPosition + propertyBytes);
 
     // handle this packet based on its arrival status.
@@ -147,7 +148,8 @@ int InboundAudioStream::parseData(ReceivedMessage& message) {
         }
         case SequenceNumberStats::OnTime: {
             // Packet is on time; parse its data to the ringbuffer
-            if (message.getType() == PacketType::SilentAudioFrame) {
+            if (message.getType() == PacketType::SilentAudioFrame
+                || message.getType() == PacketType::ReplicatedSilentAudioFrame) {
                 // If we recieved a SilentAudioFrame from our sender, we might want to drop
                 // some of the samples in order to catch up to our desired jitter buffer size.
                 writeDroppableSilentFrames(networkFrames);
@@ -168,7 +170,10 @@ int InboundAudioStream::parseData(ReceivedMessage& message) {
 
                     // inform others of the mismatch
                     auto sendingNode = DependencyManager::get<NodeList>()->nodeWithUUID(message.getSourceID());
-                    emit mismatchedAudioCodec(sendingNode, _selectedCodecName, codecInPacket);
+                    if (sendingNode) {
+                        emit mismatchedAudioCodec(sendingNode, _selectedCodecName, codecInPacket);
+                    }
+
                 }
             }
             break;

libraries/avatars-renderer/CMakeLists.txt

@@ -2,5 +2,17 @@ set(TARGET_NAME avatars-renderer)
 AUTOSCRIBE_SHADER_LIB(gpu model render render-utils)
 setup_hifi_library(Widgets Network Script)
 link_hifi_libraries(shared gpu model animation model-networking script-engine render image render-utils)
+include_hifi_library_headers(avatars)
+include_hifi_library_headers(networking)
+include_hifi_library_headers(fbx)
+include_hifi_library_headers(recording)
+include_hifi_library_headers(trackers)
+include_hifi_library_headers(ktx)
+include_hifi_library_headers(procedural)
+include_hifi_library_headers(physics)
+include_hifi_library_headers(entities-renderer)
+include_hifi_library_headers(audio)
+include_hifi_library_headers(entities)
+include_hifi_library_headers(octree)
 
 target_bullet()

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

@@ -288,6 +288,13 @@ void Avatar::updateAvatarEntities() {
                 properties.setScript(noScript);
             }
 
+            // When grabbing avatar entities, they are parented to the joint moving them, then when un-grabbed
+            // they go back to the default parent (null uuid).  When un-gripped, others saw the entity disappear.
+            // The thinking here is the local position was noticed as changing, but not the parentID (since it is now
+            // back to the default), and the entity flew off somewhere.  Marking all changed definitely fixes this,
+            // and seems safe (per Seth).
+            properties.markAllChanged();
+
             // try to build the entity
             EntityItemPointer entity = entityTree->findEntityByEntityItemID(EntityItemID(entityID));
             bool success = true;
@@ -1067,15 +1074,15 @@ void Avatar::setModelURLFinished(bool success) {
         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 ||
             _skeletonModel->getResourceDownloadAttempts() > MAX_SKELETON_DOWNLOAD_ATTEMPTS) {
-            qCWarning(avatars_renderer) << "Using default after failing to load Avatar model: " << _skeletonModelURL 
+            qCWarning(avatars_renderer) << "Using default after failing to load Avatar model: " << _skeletonModelURL
                                     << "after" << _skeletonModel->getResourceDownloadAttempts() << "attempts.";
             // call _skeletonModel.setURL, but leave our copy of _skeletonModelURL alone.  This is so that
             // we don't redo this every time we receive an identity packet from the avatar with the bad url.
             QMetaObject::invokeMethod(_skeletonModel.get(), "setURL",
                 Qt::QueuedConnection, Q_ARG(QUrl, AvatarData::defaultFullAvatarModelUrl()));
         } else {
-            qCWarning(avatars_renderer) << "Avatar model: " << _skeletonModelURL 
-                    << "failed to load... attempts:" << _skeletonModel->getResourceDownloadAttempts() 
+            qCWarning(avatars_renderer) << "Avatar model: " << _skeletonModelURL
+                    << "failed to load... attempts:" << _skeletonModel->getResourceDownloadAttempts()
                     << "out of:" << MAX_SKELETON_DOWNLOAD_ATTEMPTS;
         }
     }