Merge branch 'master' into feature/pole-vector

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) {
-                    manageIdentityData(node);
+                    if (node->getType() == NodeType::Agent && !node->isUpstream()) {
+                        manageIdentityData(node);
+                    }
+
                     ++_sumListeners;
                 });
             }, &lockWait, &nodeTransform, &functor);
@@ -226,7 +331,13 @@ void AvatarMixer::manageIdentityData(const SharedNodePointer& node) {
         }
     }
     if (sendIdentity) {
-        sendIdentityPacket(nodeData, node); // Tell node whose name changed about its new session display name or avatar.
+
+        // since this packet includes a change to either the skeleton model URL or the display name
+        // it needs a new sequence number
+        nodeData->getAvatar().pushIdentitySequenceNumber();
+
+        // tell node whose name changed about its new session display name or avatar.
+        sendIdentityPacket(nodeData, node);
     }
 }
 
@@ -310,13 +421,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
@@ -429,12 +565,11 @@ 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;
             bool skeletonModelUrlChanged = false;
-            avatar.processAvatarIdentity(identity, identityChanged, displayNameChanged, skeletonModelUrlChanged);
+            avatar.processAvatarIdentity(message->getMessage(), identityChanged, displayNameChanged, skeletonModelUrlChanged);
+
             if (identityChanged) {
                 QMutexLocker nodeDataLocker(&nodeData->getMutex());
                 nodeData->flagIdentityChange();
@@ -451,11 +586,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) {
@@ -707,7 +844,6 @@ void AvatarMixer::run() {
     connect(&domainHandler, &DomainHandler::settingsReceiveFail, this, &AvatarMixer::domainSettingsRequestFailed);
 
     ThreadedAssignment::commonInit(AVATAR_MIXER_LOGGING_NAME, NodeType::AvatarMixer);
-
 }
 
 AvatarMixerClientData* AvatarMixer::getOrCreateClientData(SharedNodePointer node) {
@@ -726,7 +862,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());
@@ -803,12 +939,13 @@ void AvatarMixer::parseDomainServerSettings(const QJsonObject& domainSettings) {
     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";
+    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 {

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();
@@ -66,6 +68,8 @@ private:
     QStringList _avatarWhitelist { };
     QString _replacementAvatar { REPLACEMENT_AVATAR_DEFAULT };
 
+    void optionallyReplicatePacket(ReceivedMessage& message, const Node& node);
+
     p_high_resolution_clock::time_point _lastFrameTimestamp;
 
     // FIXME - new throttling - use these values somehow

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);

cmake/modules/FindFBX.cmake

@@ -29,6 +29,7 @@ string(REGEX REPLACE "^[0-9]+\\.([0-9]+).*$" "\\1" FBX_VERSION_MINOR  "${FBX_VER
 string(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" FBX_VERSION_PATCH "${FBX_VERSION}")
 
 set(FBX_MAC_LOCATIONS "/Applications/Autodesk/FBX\ SDK/${FBX_VERSION}")
+set(FBX_LINUX_LOCATIONS "/usr/local/lib/gcc4/x64/debug/")
 
 if (WIN32)
   string(REGEX REPLACE "\\\\" "/" WIN_PROGRAM_FILES_X64_DIRECTORY $ENV{ProgramW6432})
@@ -36,7 +37,7 @@ endif()
 
 set(FBX_WIN_LOCATIONS "${WIN_PROGRAM_FILES_X64_DIRECTORY}/Autodesk/FBX/FBX SDK/${FBX_VERSION}")
 
-set(FBX_SEARCH_LOCATIONS $ENV{FBX_ROOT} ${FBX_ROOT} ${FBX_MAC_LOCATIONS} ${FBX_WIN_LOCATIONS})
+set(FBX_SEARCH_LOCATIONS $ENV{FBX_ROOT} ${FBX_ROOT} ${FBX_MAC_LOCATIONS} ${FBX_WIN_LOCATIONS} ${FBX_LINUX_LOCATIONS})
 
 function(_fbx_append_debugs _endvar _library)
   if (${_library} AND ${_library}_DEBUG)
@@ -94,6 +95,8 @@ elseif (APPLE)
   find_library(SYSTEM_CONFIGURATION NAMES SystemConfiguration)
   _fbx_find_library(FBX_LIBRARY libfbxsdk.a release)
   _fbx_find_library(FBX_LIBRARY_DEBUG libfbxsdk.a debug)
+else ()
+  _fbx_find_library(FBX_LIBRARY libfbxsdk.a release)
 endif()
 
 include(FindPackageHandleStandardArgs)

domain-server/resources/describe-settings.json

@@ -1335,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/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 + "' " +
@@ -1411,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) {
@@ -1440,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
@@ -1468,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 {

domain-server/src/DomainGatekeeper.cpp

@@ -435,8 +435,29 @@ SharedNodePointer DomainGatekeeper::processAgentConnectRequest(const NodeConnect
         return SharedNodePointer();
     }
 
+    QUuid hintNodeID;
+
+    // in case this is a node that's failing to connect
+    // double check we don't have the same node whose sockets match exactly already in the list
+    limitedNodeList->eachNodeBreakable([&](const SharedNodePointer& node){
+        if (node->getPublicSocket() == nodeConnection.publicSockAddr && node->getLocalSocket() == nodeConnection.localSockAddr) {
+            // we have a node that already has these exact sockets - this can occur if a node
+            // is failing to connect to the domain
+
+            // we'll re-use the existing node ID
+            // as long as the user hasn't changed their username (by logging in or logging out)
+            auto existingNodeData = static_cast<DomainServerNodeData*>(node->getLinkedData());
+
+            if (existingNodeData->getUsername() == username) {
+                hintNodeID = node->getUUID();
+                return false;
+            }
+        }
+        return true;
+    });
+
     // add the connecting node (or re-use the matched one from eachNodeBreakable above)
-    SharedNodePointer newNode = addVerifiedNodeFromConnectRequest(nodeConnection);
+    SharedNodePointer newNode = addVerifiedNodeFromConnectRequest(nodeConnection, hintNodeID);
 
     // set the edit rights for this user
     newNode->setPermissions(userPerms);
@@ -464,12 +485,11 @@ SharedNodePointer DomainGatekeeper::processAgentConnectRequest(const NodeConnect
     return newNode;
 }
 
-SharedNodePointer DomainGatekeeper::addVerifiedNodeFromConnectRequest(const NodeConnectionData& nodeConnection) {
+SharedNodePointer DomainGatekeeper::addVerifiedNodeFromConnectRequest(const NodeConnectionData& nodeConnection,
+                                                                      QUuid nodeID) {
     HifiSockAddr discoveredSocket = nodeConnection.senderSockAddr;
     SharedNetworkPeer connectedPeer = _icePeers.value(nodeConnection.connectUUID);
 
-    QUuid nodeID;
-
     if (connectedPeer) {
         //  this user negotiated a connection with us via ICE, so re-use their ICE client ID
         nodeID = nodeConnection.connectUUID;
@@ -479,8 +499,10 @@ SharedNodePointer DomainGatekeeper::addVerifiedNodeFromConnectRequest(const Node
             discoveredSocket = *connectedPeer->getActiveSocket();
         }
     } else {
-        // we got a connectUUID we didn't recognize, randomly generate a new one
-        nodeID = QUuid::createUuid();
+        // we got a connectUUID we didn't recognize, either use the hinted node ID or randomly generate a new one
+        if (nodeID.isNull()) {
+            nodeID = QUuid::createUuid();
+        }
     }
 
     auto limitedNodeList = DependencyManager::get<LimitedNodeList>();

domain-server/src/DomainGatekeeper.h

@@ -76,7 +76,8 @@ private:
     SharedNodePointer processAgentConnectRequest(const NodeConnectionData& nodeConnection,
                                                  const QString& username,
                                                  const QByteArray& usernameSignature);
-    SharedNodePointer addVerifiedNodeFromConnectRequest(const NodeConnectionData& nodeConnection);
+    SharedNodePointer addVerifiedNodeFromConnectRequest(const NodeConnectionData& nodeConnection,
+                                                        QUuid nodeID = QUuid());
     
     bool verifyUserSignature(const QString& username, const QByteArray& usernameSignature,
                              const HifiSockAddr& senderSockAddr);

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);
 }
@@ -2215,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/qml/controls-uit/CheckBox.qml

@@ -22,8 +22,8 @@ Original.CheckBox {
     readonly property bool isLightColorScheme: colorScheme == hifi.colorSchemes.light
     property bool isRedCheck: false
     property int boxSize: 14
+    property int boxRadius: 3
     property bool wrap: true;
-    readonly property int boxRadius: 3
     readonly property int checkSize: Math.max(boxSize - 8, 10)
     readonly property int checkRadius: 2
     activeFocusOnPress: true

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/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/styles-uit/HifiConstants.qml

@@ -333,6 +333,7 @@ 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/src/Application.cpp

@@ -109,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>
@@ -214,7 +215,7 @@ static QTimer pingTimer;
 
 static const int MAX_CONCURRENT_RESOURCE_DOWNLOADS = 16;
 
-// For processing on QThreadPool, we target a number of threads after reserving some 
+// For processing on QThreadPool, we target a number of threads after reserving some
 // based on how many are being consumed by the application and the display plugin.  However,
 // we will never drop below the 'min' value
 static const int MIN_PROCESSING_THREAD_POOL_SIZE = 1;
@@ -442,6 +443,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;
 
@@ -511,6 +540,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>();
@@ -859,6 +889,20 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     }
     ResourceCache::setRequestLimit(concurrentDownloads);
 
+    // perhaps override the avatar url.  Since we will test later for validity
+    // we don't need to do so here.
+    QString avatarURL = getCmdOption(argc, constArgv, "--avatarURL");
+    _avatarOverrideUrl = QUrl::fromUserInput(avatarURL);
+
+    // If someone specifies both --avatarURL and --replaceAvatarURL,
+    // the replaceAvatarURL wins.  So only set the _overrideUrl if this
+    // does have a non-empty string.
+    QString replaceURL = getCmdOption(argc, constArgv, "--replaceAvatarURL");
+    if (!replaceURL.isEmpty()) {
+        _avatarOverrideUrl = QUrl::fromUserInput(replaceURL);
+        _saveAvatarOverrideUrl = true;
+    }
+
     _glWidget = new GLCanvas();
     getApplicationCompositor().setRenderingWidget(_glWidget);
     _window->setCentralWidget(_glWidget);
@@ -1248,7 +1292,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     // Add periodic checks to send user activity data
     static int CHECK_NEARBY_AVATARS_INTERVAL_MS = 10000;
     static int NEARBY_AVATAR_RADIUS_METERS = 10;
-    
+
     // setup the stats interval depending on if the 1s faster hearbeat was requested
     static const QString FAST_STATS_ARG = "--fast-heartbeat";
     static int SEND_STATS_INTERVAL_MS = arguments().indexOf(FAST_STATS_ARG) != -1 ? 1000 : 10000;
@@ -1398,10 +1442,10 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
 
         _autoSwitchDisplayModeSupportedHMDPlugin = nullptr;
         foreach(DisplayPluginPointer displayPlugin, PluginManager::getInstance()->getDisplayPlugins()) {
-            if (displayPlugin->isHmd() && 
+            if (displayPlugin->isHmd() &&
                 displayPlugin->getSupportsAutoSwitch()) {
                 _autoSwitchDisplayModeSupportedHMDPlugin = displayPlugin;
-                _autoSwitchDisplayModeSupportedHMDPluginName = 
+                _autoSwitchDisplayModeSupportedHMDPluginName =
                     _autoSwitchDisplayModeSupportedHMDPlugin->getName();
                 _previousHMDWornStatus =
                     _autoSwitchDisplayModeSupportedHMDPlugin->isDisplayVisible();
@@ -1653,7 +1697,7 @@ void Application::onAboutToQuit() {
     }
 
     getActiveDisplayPlugin()->deactivate();
-    if (_autoSwitchDisplayModeSupportedHMDPlugin 
+    if (_autoSwitchDisplayModeSupportedHMDPlugin
         && _autoSwitchDisplayModeSupportedHMDPlugin->isSessionActive()) {
         _autoSwitchDisplayModeSupportedHMDPlugin->endSession();
     }
@@ -1722,8 +1766,8 @@ 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.  
+    // 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();
 
@@ -1997,6 +2041,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());
@@ -2479,8 +2524,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 <<
@@ -2523,14 +2571,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.";
@@ -2568,7 +2611,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) {
@@ -5217,7 +5262,7 @@ void Application::clearDomainOctreeDetails() {
     skyStage->setBackgroundMode(model::SunSkyStage::SKY_DEFAULT);
 
     _recentlyClearedDomain = true;
-    
+
     DependencyManager::get<AnimationCache>()->clearUnusedResources();
     DependencyManager::get<ModelCache>()->clearUnusedResources();
     DependencyManager::get<SoundCache>()->clearUnusedResources();
@@ -5281,6 +5326,10 @@ 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.
+        // Override the avatar url (but not model name) here too.
+        if (_avatarOverrideUrl.isValid()) {
+            getMyAvatar()->useFullAvatarURL(_avatarOverrideUrl);
+        }
         static const QUrl empty{};
         if (getMyAvatar()->getFullAvatarURLFromPreferences() != getMyAvatar()->cannonicalSkeletonModelURL(empty)) {
             getMyAvatar()->resetFullAvatarURL();
@@ -7035,3 +7084,8 @@ QUuid Application::getTabletFrameID() const {
     auto HMD = DependencyManager::get<HMDScriptingInterface>();
     return HMD->getCurrentTabletFrameID();
 }
+
+void Application::setAvatarOverrideUrl(const QUrl& url, bool save) {
+    _avatarOverrideUrl = url;
+    _saveAvatarOverrideUrl = save;
+}

interface/src/Application.h

@@ -102,9 +102,9 @@ class Application;
 #endif
 #define qApp (static_cast<Application*>(QCoreApplication::instance()))
 
-class Application : public QApplication, 
-                    public AbstractViewStateInterface, 
-                    public AbstractScriptingServicesInterface, 
+class Application : public QApplication,
+                    public AbstractViewStateInterface,
+                    public AbstractScriptingServicesInterface,
                     public AbstractUriHandler,
                     public PluginContainer {
     Q_OBJECT
@@ -294,6 +294,10 @@ public:
     OverlayID getTabletHomeButtonID() const;
     QUuid getTabletFrameID() const; // may be an entity or an overlay
 
+    void setAvatarOverrideUrl(const QUrl& url, bool save);
+    QUrl getAvatarOverrideUrl() { return _avatarOverrideUrl; }
+    bool getSaveAvatarOverrideUrl() { return _saveAvatarOverrideUrl; }
+
 signals:
     void svoImportRequested(const QString& url);
 
@@ -675,11 +679,14 @@ private:
     FileScriptingInterface* _fileDownload;
     AudioInjector* _snapshotSoundInjector { nullptr };
     SharedSoundPointer _snapshotSound;
-	
+
     DisplayPluginPointer _autoSwitchDisplayModeSupportedHMDPlugin;
     QString _autoSwitchDisplayModeSupportedHMDPluginName;
     bool _previousHMDWornStatus;
     void startHMDStandBySession();
     void endHMDSession();
+
+    QUrl _avatarOverrideUrl;
+    bool _saveAvatarOverrideUrl { false };
 };
 #endif // hifi_Application_h

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"
@@ -309,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>();

interface/src/avatar/MyAvatar.cpp

@@ -929,10 +929,15 @@ void MyAvatar::saveData() {
 
     settings.setValue("scale", _targetScale);
 
-    settings.setValue("fullAvatarURL",
+    // only save the fullAvatarURL if it has not been overwritten on command line
+    // (so the overrideURL is not valid), or it was overridden _and_ we specified
+    // --replaceAvatarURL (so _saveAvatarOverrideUrl is true)
+    if (qApp->getSaveAvatarOverrideUrl() || !qApp->getAvatarOverrideUrl().isValid() ) {
+        settings.setValue("fullAvatarURL",
                       _fullAvatarURLFromPreferences == AvatarData::defaultFullAvatarModelUrl() ?
                       "" :
                       _fullAvatarURLFromPreferences.toString());
+    }
 
     settings.setValue("fullAvatarModelName", _fullAvatarModelName);
 
@@ -2430,7 +2435,7 @@ bool MyAvatar::requiresSafeLanding(const glm::vec3& positionIn, glm::vec3& bette
         // Our head may be embedded, but our center is out and there's room below. See corresponding comment above.
         return false; // nothing below
     }
- 
+
     // See if we have room between entities above and below, but that we are not contained.
     // First check if the surface above us is the bottom of something, and the surface below us it the top of something.
     // I.e., we are in a clearing between two objects.
@@ -3150,6 +3155,6 @@ void MyAvatar::updateHoldActions(const AnimPose& prePhysicsPose, const AnimPose&
     }
 }
 
-const MyHead* MyAvatar::getMyHead() const { 
-    return static_cast<const MyHead*>(getHead()); 
+const MyHead* MyAvatar::getMyHead() const {
+    return static_cast<const MyHead*>(getHead());
 }

interface/src/ui/overlays/Web3DOverlay.cpp

@@ -50,6 +50,7 @@
 #include "ui/AvatarInputs.h"
 #include "avatar/AvatarManager.h"
 #include "scripting/GlobalServicesScriptingInterface.h"
+#include <plugins/InputConfiguration.h>
 #include "ui/Snapshot.h"
 #include "SoundCache.h"
 
@@ -182,6 +183,7 @@ 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());
@@ -200,6 +202,7 @@ void Web3DOverlay::loadSourceURL() {
             _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", "../../");

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/src/AvatarData.cpp

@@ -1473,27 +1473,6 @@ QStringList AvatarData::getJointNames() const {
     return _jointNames;
 }
 
-void AvatarData::parseAvatarIdentityPacket(const QByteArray& data, Identity& identityOut) {
-    QDataStream packetStream(data);
-
-    packetStream >> identityOut.uuid
-                 >> identityOut.skeletonModelURL
-                 >> identityOut.attachmentData
-                 >> identityOut.displayName
-                 >> identityOut.sessionDisplayName
-                 >> identityOut.avatarEntityData
-                 >> identityOut.sequenceId;
-
-#ifdef WANT_DEBUG
-    qCDebug(avatars) << __FUNCTION__
-        << "identityOut.uuid:" << identityOut.uuid
-        << "identityOut.skeletonModelURL:" << identityOut.skeletonModelURL
-        << "identityOut.displayName:" << identityOut.displayName
-        << "identityOut.sessionDisplayName:" << identityOut.sessionDisplayName;
-#endif
-
-}
-
 glm::quat AvatarData::getOrientationOutbound() const {
     return (getLocalOrientation());
 }
@@ -1504,47 +1483,82 @@ QUrl AvatarData::cannonicalSkeletonModelURL(const QUrl& emptyURL) const {
     return _skeletonModelURL.scheme() == "file" ? emptyURL : _skeletonModelURL;
 }
 
-void AvatarData::processAvatarIdentity(const Identity& identity, bool& identityChanged, bool& displayNameChanged, bool& skeletonModelUrlChanged) {
+void AvatarData::processAvatarIdentity(const QByteArray& identityData, bool& identityChanged,
+                                       bool& displayNameChanged, bool& skeletonModelUrlChanged) {
 
-    if (identity.sequenceId < _identitySequenceId) {
-        qCDebug(avatars) << "Ignoring older identity packet for avatar" << getSessionUUID()
-            << "_identitySequenceId (" << _identitySequenceId << ") is greater than" << identity.sequenceId;
-        return;
+    QDataStream packetStream(identityData);
+
+    QUuid avatarSessionID;
+
+    // peek the sequence number, this will tell us if we should be processing this identity packet at all
+    udt::SequenceNumber::Type incomingSequenceNumberType;
+    packetStream >> avatarSessionID >> incomingSequenceNumberType;
+    udt::SequenceNumber incomingSequenceNumber(incomingSequenceNumberType);
+
+    if (!_hasProcessedFirstIdentity) {
+        _identitySequenceNumber = incomingSequenceNumber - 1;
+        _hasProcessedFirstIdentity = true;
+        qCDebug(avatars) << "Processing first identity packet for" << avatarSessionID << "-"
+            << (udt::SequenceNumber::Type) incomingSequenceNumber;
     }
-    // otherwise, set the identitySequenceId to match the incoming identity
-    _identitySequenceId = identity.sequenceId;
 
-    if (_firstSkeletonCheck || (identity.skeletonModelURL != cannonicalSkeletonModelURL(emptyURL))) {
-        setSkeletonModelURL(identity.skeletonModelURL);
-        identityChanged = true;
-        skeletonModelUrlChanged = true;
-        if (_firstSkeletonCheck) {
+    if (incomingSequenceNumber > _identitySequenceNumber) {
+        Identity identity;
+
+        packetStream >> identity.skeletonModelURL
+            >> identity.attachmentData
+            >> identity.displayName
+            >> identity.sessionDisplayName
+            >> identity.avatarEntityData;
+
+        // set the store identity sequence number to match the incoming identity
+        _identitySequenceNumber = incomingSequenceNumber;
+
+        if (_firstSkeletonCheck || (identity.skeletonModelURL != cannonicalSkeletonModelURL(emptyURL))) {
+            setSkeletonModelURL(identity.skeletonModelURL);
+            identityChanged = true;
+            skeletonModelUrlChanged = true;
+            if (_firstSkeletonCheck) {
+                displayNameChanged = true;
+            }
+            _firstSkeletonCheck = false;
+        }
+
+        if (identity.displayName != _displayName) {
+            _displayName = identity.displayName;
+            identityChanged = true;
             displayNameChanged = true;
         }
-        _firstSkeletonCheck = false;
-    }
+        maybeUpdateSessionDisplayNameFromTransport(identity.sessionDisplayName);
 
-    if (identity.displayName != _displayName) {
-        _displayName = identity.displayName;
-        identityChanged = true;
-        displayNameChanged = true;
-    }
-    maybeUpdateSessionDisplayNameFromTransport(identity.sessionDisplayName);
+        if (identity.attachmentData != _attachmentData) {
+            setAttachmentData(identity.attachmentData);
+            identityChanged = true;
+        }
 
-    if (identity.attachmentData != _attachmentData) {
-        setAttachmentData(identity.attachmentData);
-        identityChanged = true;
-    }
+        bool avatarEntityDataChanged = false;
+        _avatarEntitiesLock.withReadLock([&] {
+            avatarEntityDataChanged = (identity.avatarEntityData != _avatarEntityData);
+        });
+        
+        if (avatarEntityDataChanged) {
+            setAvatarEntityData(identity.avatarEntityData);
+            identityChanged = true;
+        }
 
-    bool avatarEntityDataChanged = false;
-    _avatarEntitiesLock.withReadLock([&] {
-        avatarEntityDataChanged = (identity.avatarEntityData != _avatarEntityData);
-    });
-    if (avatarEntityDataChanged) {
-        setAvatarEntityData(identity.avatarEntityData);
-        identityChanged = true;
-    }
+#ifdef WANT_DEBUG
+        qCDebug(avatars) << __FUNCTION__
+            << "identity.uuid:" << identity.uuid
+            << "identity.skeletonModelURL:" << identity.skeletonModelURL
+            << "identity.displayName:" << identity.displayName
+            << "identity.sessionDisplayName:" << identity.sessionDisplayName;
+    } else {
 
+        qCDebug(avatars) << "Refusing to process identity for" << uuidStringWithoutCurlyBraces(avatarSessionID) << "since"
+            << (udt::SequenceNumber::Type) _identitySequenceNumber
+            << "is >=" << (udt::SequenceNumber::Type) incomingSequenceNumber;
+#endif
+    }
 }
 
 QByteArray AvatarData::identityByteArray() const {
@@ -1552,14 +1566,17 @@ QByteArray AvatarData::identityByteArray() const {
     QDataStream identityStream(&identityData, QIODevice::Append);
     const QUrl& urlToSend = cannonicalSkeletonModelURL(emptyURL); // depends on _skeletonModelURL
 
+    // when mixers send identity packets to agents, they simply forward along the last incoming sequence number they received
+    // whereas agents send a fresh outgoing sequence number when identity data has changed
+
     _avatarEntitiesLock.withReadLock([&] {
         identityStream << getSessionUUID()
-                       << urlToSend
-                       << _attachmentData
-                       << _displayName
-                       << getSessionDisplayNameForTransport() // depends on _sessionDisplayName
-                       << _avatarEntityData
-                       << _identitySequenceId;
+            << (udt::SequenceNumber::Type) _identitySequenceNumber
+            << urlToSend
+            << _attachmentData
+            << _displayName
+            << getSessionDisplayNameForTransport() // depends on _sessionDisplayName
+            << _avatarEntityData;
     });
 
     return identityData;
@@ -1735,6 +1752,12 @@ void AvatarData::sendAvatarDataPacket() {
 
 void AvatarData::sendIdentityPacket() {
     auto nodeList = DependencyManager::get<NodeList>();
+
+    if (_identityDataChanged) {
+        // if the identity data has changed, push the sequence number forwards
+        ++_identitySequenceNumber;
+    }
+
     QByteArray identityData = identityByteArray();
 
     auto packetList = NLPacketList::create(PacketType::AvatarIdentity, QByteArray(), true, true);
@@ -1745,7 +1768,7 @@ void AvatarData::sendIdentityPacket() {
         },
         [&](const SharedNodePointer& node) {
             nodeList->sendPacketList(std::move(packetList), *node);
-        });
+    });
 
     _avatarEntityDataLocallyEdited = false;
     _identityDataChanged = false;

libraries/avatars/src/AvatarData.h

@@ -52,15 +52,16 @@ typedef unsigned long long quint64;
 #include <JointData.h>
 #include <NLPacket.h>
 #include <Node.h>
-#include <RegisteredMetaTypes.h>
-#include <SimpleMovingAverage.h>
-#include <SpatiallyNestable.h>
 #include <NumericalConstants.h>
 #include <Packed.h>
-#include <ThreadSafeValueCache.h>
+#include <RegisteredMetaTypes.h>
 #include <SharedUtil.h>
-#include <shared/RateCounter.h>
+#include <SimpleMovingAverage.h>
+#include <SpatiallyNestable.h>
+#include <ThreadSafeValueCache.h>
 #include <ViewFrustum.h>
+#include <shared/RateCounter.h>
+#include <udt/SequenceNumber.h>
 
 #include "AABox.h"
 #include "HeadData.h"
@@ -526,19 +527,17 @@ public:
     const HeadData* getHeadData() const { return _headData; }
 
     struct Identity {
-        QUuid uuid;
         QUrl skeletonModelURL;
         QVector<AttachmentData> attachmentData;
         QString displayName;
         QString sessionDisplayName;
         AvatarEntityMap avatarEntityData;
-        quint64 sequenceId;
     };
 
-    static void parseAvatarIdentityPacket(const QByteArray& data, Identity& identityOut);
-
+    // identityChanged returns true if identity has changed, false otherwise.
     // identityChanged returns true if identity has changed, false otherwise. Similarly for displayNameChanged and skeletonModelUrlChange.
-    void processAvatarIdentity(const Identity& identity, bool& identityChanged, bool& displayNameChanged, bool& skeletonModelUrlChanged);
+    void processAvatarIdentity(const QByteArray& identityData, bool& identityChanged,
+                               bool& displayNameChanged, bool& skeletonModelUrlChanged);
 
     QByteArray identityByteArray() const;
 
@@ -624,10 +623,9 @@ public:
     static float _avatarSortCoefficientAge;
 
     bool getIdentityDataChanged() const { return _identityDataChanged; } // has the identity data changed since the last time sendIdentityPacket() was called
-    void markIdentityDataChanged() {
-        _identityDataChanged = true;
-        _identitySequenceId++;
-    }
+    void markIdentityDataChanged() { _identityDataChanged = true; }
+
+    void pushIdentitySequenceNumber() { ++_identitySequenceNumber; };
 
     float getDensity() const { return _density; }
 
@@ -785,7 +783,8 @@ protected:
     float _audioAverageLoudness { 0.0f };
 
     bool _identityDataChanged { false };
-    quint64 _identitySequenceId { 0 };
+    udt::SequenceNumber _identitySequenceNumber { 0 };
+    bool _hasProcessedFirstIdentity { false };
     float _density;
 
 private:

libraries/avatars/src/AvatarHashMap.cpp

@@ -126,8 +126,14 @@ AvatarSharedPointer AvatarHashMap::parseAvatarData(QSharedPointer<ReceivedMessag
 }
 
 void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<ReceivedMessage> message, SharedNodePointer sendingNode) {
-    AvatarData::Identity identity;
-    AvatarData::parseAvatarIdentityPacket(message->getMessage(), identity);
+
+    // peek the avatar UUID from the incoming packet
+    QUuid identityUUID = QUuid::fromRfc4122(message->peek(NUM_BYTES_RFC4122_UUID));
+
+    if (identityUUID.isNull()) {
+        qCDebug(avatars) << "Refusing to process identity packet for null avatar ID";
+        return;
+    }
 
     // make sure this isn't for an ignored avatar
     auto nodeList = DependencyManager::get<NodeList>();
@@ -136,21 +142,22 @@ void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<ReceivedMessage>
     {
         QReadLocker locker(&_hashLock);
         auto me = _avatarHash.find(EMPTY);
-        if ((me != _avatarHash.end()) && (identity.uuid == me.value()->getSessionUUID())) {
+        if ((me != _avatarHash.end()) && (identityUUID == me.value()->getSessionUUID())) {
             // We add MyAvatar to _avatarHash with an empty UUID. Code relies on this. In order to correctly handle an
             // identity packet for ourself (such as when we are assigned a sessionDisplayName by the mixer upon joining),
             // we make things match here.
-            identity.uuid = EMPTY;
+            identityUUID = EMPTY;
         }
     }
-    if (!nodeList->isIgnoringNode(identity.uuid) || nodeList->getRequestsDomainListData()) {
+    
+    if (!nodeList->isIgnoringNode(identityUUID) || nodeList->getRequestsDomainListData()) {
         // mesh URL for a UUID, find avatar in our list
-        auto avatar = newOrExistingAvatar(identity.uuid, sendingNode);
+        auto avatar = newOrExistingAvatar(identityUUID, sendingNode);
         bool identityChanged = false;
         bool displayNameChanged = false;
         bool skeletonModelUrlChanged = false;
         // In this case, the "sendingNode" is the Avatar Mixer.
-        avatar->processAvatarIdentity(identity, identityChanged, displayNameChanged, skeletonModelUrlChanged);
+        avatar->processAvatarIdentity(message->getMessage(), identityChanged, displayNameChanged, skeletonModelUrlChanged);
     }
 }
 

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

@@ -20,6 +20,8 @@
 
 #include <QThreadPool>
 
+#include <Gzip.h>
+
 #include "ModelNetworkingLogging.h"
 #include <Trace.h>
 #include <StatTracker.h>
@@ -171,7 +173,9 @@ void GeometryReader::run() {
 
         QString urlname = _url.path().toLower();
         if (!urlname.isEmpty() && !_url.path().isEmpty() &&
-            (_url.path().toLower().endsWith(".fbx") || _url.path().toLower().endsWith(".obj"))) {
+			(_url.path().toLower().endsWith(".fbx") || 
+			_url.path().toLower().endsWith(".obj") || 
+			_url.path().toLower().endsWith(".obj.gz"))) {
             FBXGeometry::Pointer fbxGeometry;
 
             if (_url.path().toLower().endsWith(".fbx")) {
@@ -181,7 +185,15 @@ void GeometryReader::run() {
                 }
             } else if (_url.path().toLower().endsWith(".obj")) {
                 fbxGeometry.reset(OBJReader().readOBJ(_data, _mapping, _combineParts, _url));
-            } else {
+			} else if (_url.path().toLower().endsWith(".obj.gz")) {
+				QByteArray uncompressedData;
+				if (gunzip(_data, uncompressedData)){
+					fbxGeometry.reset(OBJReader().readOBJ(uncompressedData, _mapping, _combineParts, _url));
+				} else {
+					throw QString("failed to decompress .obj.gz" );
+				}
+
+			} else {
                 throw QString("unsupported format");
             }
 

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

@@ -821,6 +821,7 @@ void NetworkTexture::refresh() {
         TextureCache::requestCompleted(_self);
     }
 
+    _ktxResourceState = PENDING_INITIAL_LOAD;
     Resource::refresh();
 }
 

libraries/networking/src/LimitedNodeList.cpp

@@ -446,7 +446,8 @@ qint64 LimitedNodeList::sendPacketList(std::unique_ptr<NLPacketList> packetList,
 
         return _nodeSocket.writePacketList(std::move(packetList), *activeSocket);
     } else {
-        qCDebug(networking) << "LimitedNodeList::sendPacketList called without active socket for node. Not sending.";
+        qCDebug(networking) << "LimitedNodeList::sendPacketList called without active socket for node "
+                            << destinationNode.getUUID() << ". Not sending.";
         return ERROR_SENDING_PACKET_BYTES;
     }
 }
@@ -454,7 +455,8 @@ qint64 LimitedNodeList::sendPacketList(std::unique_ptr<NLPacketList> packetList,
 qint64 LimitedNodeList::sendPacket(std::unique_ptr<NLPacket> packet, const Node& destinationNode,
                                    const HifiSockAddr& overridenSockAddr) {
     if (overridenSockAddr.isNull() && !destinationNode.getActiveSocket()) {
-        qCDebug(networking) << "LimitedNodeList::sendPacket called without active socket for node. Not sending.";
+        qCDebug(networking) << "LimitedNodeList::sendPacket called without active socket for node"
+                            << destinationNode.getUUID() << ". Not sending.";
         return ERROR_SENDING_PACKET_BYTES;
     }
 
@@ -568,8 +570,8 @@ void LimitedNodeList::handleNodeKill(const SharedNodePointer& node) {
 
 SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
                                                    const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
-                                                   const NodePermissions& permissions,
-                                                   const QUuid& connectionSecret) {
+                                                   bool isReplicated, bool isUpstream,
+                                                   const QUuid& connectionSecret, const NodePermissions& permissions) {
     QReadLocker readLocker(&_nodeMutex);
     NodeHash::const_iterator it = _nodeHash.find(uuid);
 
@@ -580,11 +582,20 @@ SharedNodePointer LimitedNodeList::addOrUpdateNode(const QUuid& uuid, NodeType_t
         matchingNode->setLocalSocket(localSocket);
         matchingNode->setPermissions(permissions);
         matchingNode->setConnectionSecret(connectionSecret);
+        matchingNode->setIsReplicated(isReplicated);
+        matchingNode->setIsUpstream(isUpstream);
 
         return matchingNode;
     } else {
         // we didn't have this node, so add them
-        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket, permissions, connectionSecret);
+        Node* newNode = new Node(uuid, nodeType, publicSocket, localSocket);
+        newNode->setIsReplicated(isReplicated);
+        newNode->setIsUpstream(isUpstream);
+        newNode->setConnectionSecret(connectionSecret);
+        newNode->setPermissions(permissions);
+
+        // move the newly constructed node to the LNL thread
+        newNode->moveToThread(thread());
 
         if (nodeType == NodeType::AudioMixer) {
             LimitedNodeList::flagTimeForConnectionStep(LimitedNodeList::AddedAudioMixer);
@@ -742,7 +753,8 @@ void LimitedNodeList::removeSilentNodes() {
         SharedNodePointer node = it->second;
         node->getMutex().lock();
 
-        if ((usecTimestampNow() - node->getLastHeardMicrostamp()) > (NODE_SILENCE_THRESHOLD_MSECS * USECS_PER_MSEC)) {
+        if (!node->isForcedNeverSilent()
+            && (usecTimestampNow() - node->getLastHeardMicrostamp()) > (NODE_SILENCE_THRESHOLD_MSECS * USECS_PER_MSEC)) {
             // call the NodeHash erase to get rid of this node
             it = _nodeHash.unsafe_erase(it);
 

libraries/networking/src/LimitedNodeList.h

@@ -145,8 +145,9 @@ public:
 
     SharedNodePointer addOrUpdateNode(const QUuid& uuid, NodeType_t nodeType,
                                       const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
-                                      const NodePermissions& permissions = DEFAULT_AGENT_PERMISSIONS,
-                                      const QUuid& connectionSecret = QUuid());
+                                      bool isReplicated = false, bool isUpstream = false,
+                                      const QUuid& connectionSecret = QUuid(),
+                                      const NodePermissions& permissions = DEFAULT_AGENT_PERMISSIONS);
 
     static bool parseSTUNResponse(udt::BasePacket* packet, QHostAddress& newPublicAddress, uint16_t& newPublicPort);
     bool hasCompletedInitialSTUN() const { return _hasCompletedInitialSTUN; }
@@ -257,6 +258,16 @@ public:
         return SharedNodePointer();
     }
 
+    // This is unsafe because it does not take a lock
+    // Must only be called when you know that a read lock on the node mutex is held
+    // and will be held for the duration of your iteration
+    template<typename NodeLambda>
+    void unsafeEachNode(NodeLambda functor) {
+        for (NodeHash::const_iterator it = _nodeHash.cbegin(); it != _nodeHash.cend(); ++it) {
+            functor(it->second);
+        }
+    }
+
     void putLocalPortIntoSharedMemory(const QString key, QObject* parent, quint16 localPort);
     bool getLocalServerPortFromSharedMemory(const QString key, quint16& localPort);
 
@@ -386,6 +397,7 @@ protected:
         }
     }
 
+
 private slots:
     void flagTimeForConnectionStep(ConnectionStep connectionStep, quint64 timestamp);
     void possiblyTimeoutSTUNAddressLookup();

libraries/networking/src/NLPacket.h

@@ -42,6 +42,7 @@ public:
     
     static std::unique_ptr<NLPacket> fromReceivedPacket(std::unique_ptr<char[]> data, qint64 size,
                                                         const HifiSockAddr& senderSockAddr);
+
     static std::unique_ptr<NLPacket> fromBase(std::unique_ptr<Packet> packet);
     
     // Provided for convenience, try to limit use

libraries/networking/src/NLPacketList.h

@@ -23,6 +23,8 @@ public:
     
     PacketVersion getVersion() const { return _packetVersion; }
     const QUuid& getSourceID() const { return _sourceID; }
+
+    qint64 getMaxSegmentSize() const override { return NLPacket::maxPayloadSize(_packetType, _isOrdered); }
     
 private:
     NLPacketList(PacketType packetType, QByteArray extendedHeader = QByteArray(), bool isReliable = false,

libraries/networking/src/NetworkPeer.h

@@ -76,6 +76,14 @@ public:
     float getOutboundBandwidth() const; // in kbps
     float getInboundBandwidth() const; // in kbps
 
+    // Typically the LimitedNodeList removes nodes after they are "silent"
+    // meaning that we have not received any packets (including simple keepalive pings) from them for a set interval.
+    // The _isForcedNeverSilent flag tells the LimitedNodeList that a Node should never be killed by removeSilentNodes()
+    // even if its the timestamp of when it was last heard from has never been updated.
+
+    bool isForcedNeverSilent() const { return _isForcedNeverSilent; }
+    void setIsForcedNeverSilent(bool isForcedNeverSilent) { _isForcedNeverSilent = isForcedNeverSilent; }
+
     friend QDataStream& operator<<(QDataStream& out, const NetworkPeer& peer);
     friend QDataStream& operator>>(QDataStream& in, NetworkPeer& peer);
 public slots:
@@ -103,6 +111,8 @@ protected:
     QTimer* _pingTimer = NULL;
 
     int _connectionAttempts;
+
+    bool _isForcedNeverSilent { false };
 };
 
 QDebug operator<<(QDebug debug, const NetworkPeer &peer);

libraries/networking/src/Node.cpp

@@ -42,6 +42,8 @@ void NodeType::init() {
     TypeNameHash.insert(NodeType::MessagesMixer, "Messages Mixer");
     TypeNameHash.insert(NodeType::AssetServer, "Asset Server");
     TypeNameHash.insert(NodeType::EntityScriptServer, "Entity Script Server");
+    TypeNameHash.insert(NodeType::DownstreamAudioMixer, "Downstream Audio Mixer");
+    TypeNameHash.insert(NodeType::DownstreamAvatarMixer, "Downstream Avatar Mixer");
     TypeNameHash.insert(NodeType::Unassigned, "Unassigned");
 }
 
@@ -50,17 +52,34 @@ const QString& NodeType::getNodeTypeName(NodeType_t nodeType) {
     return matchedTypeName != TypeNameHash.end() ? matchedTypeName.value() : UNKNOWN_NodeType_t_NAME;
 }
 
+bool NodeType::isDownstream(NodeType_t nodeType) {
+    return nodeType ==  NodeType::DownstreamAudioMixer || nodeType == NodeType::DownstreamAvatarMixer;
+}
+
+NodeType_t NodeType::downstreamType(NodeType_t primaryType) {
+    switch (primaryType) {
+        case AudioMixer:
+            return DownstreamAudioMixer;
+        case AvatarMixer:
+            return DownstreamAvatarMixer;
+        default:
+            return Unassigned;
+    }
+}
+
+NodeType_t NodeType::fromString(QString type) {
+    return TypeNameHash.key(type, NodeType::Unassigned);
+}
+
+
 Node::Node(const QUuid& uuid, NodeType_t type, const HifiSockAddr& publicSocket,
-           const HifiSockAddr& localSocket, const NodePermissions& permissions, const QUuid& connectionSecret,
-           QObject* parent) :
+           const HifiSockAddr& localSocket, QObject* parent) :
     NetworkPeer(uuid, publicSocket, localSocket, parent),
     _type(type),
-    _connectionSecret(connectionSecret),
     _pingMs(-1),  // "Uninitialized"
     _clockSkewUsec(0),
     _mutex(),
-    _clockSkewMovingPercentile(30, 0.8f),   // moving 80th percentile of 30 samples
-    _permissions(permissions)
+    _clockSkewMovingPercentile(30, 0.8f)   // moving 80th percentile of 30 samples
 {
     // Update socket's object name
     setType(_type);
@@ -135,6 +154,7 @@ QDataStream& operator<<(QDataStream& out, const Node& node) {
     out << node._publicSocket;
     out << node._localSocket;
     out << node._permissions;
+    out << node._isReplicated;
     return out;
 }
 
@@ -144,6 +164,7 @@ QDataStream& operator>>(QDataStream& in, Node& node) {
     in >> node._publicSocket;
     in >> node._localSocket;
     in >> node._permissions;
+    in >> node._isReplicated;
     return in;
 }
 

libraries/networking/src/Node.h

@@ -37,9 +37,9 @@
 class Node : public NetworkPeer {
     Q_OBJECT
 public:
+
     Node(const QUuid& uuid, NodeType_t type,
          const HifiSockAddr& publicSocket, const HifiSockAddr& localSocket,
-         const NodePermissions& permissions, const QUuid& connectionSecret = QUuid(),
          QObject* parent = nullptr);
 
     bool operator==(const Node& otherNode) const { return _uuid == otherNode._uuid; }
@@ -48,6 +48,12 @@ public:
     char getType() const { return _type; }
     void setType(char type);
 
+    bool isReplicated() const { return _isReplicated; }
+    void setIsReplicated(bool isReplicated) { _isReplicated = isReplicated; }
+
+    bool isUpstream() const { return _isUpstream; }
+    void setIsUpstream(bool isUpstream) { _isUpstream = isUpstream; }
+
     const QUuid& getConnectionSecret() const { return _connectionSecret; }
     void setConnectionSecret(const QUuid& connectionSecret) { _connectionSecret = connectionSecret; }
 
@@ -89,13 +95,16 @@ private:
 
     QUuid _connectionSecret;
     std::unique_ptr<NodeData> _linkedData;
+    bool _isReplicated { false };
     int _pingMs;
     qint64 _clockSkewUsec;
     QMutex _mutex;
     MovingPercentile _clockSkewMovingPercentile;
     NodePermissions _permissions;
+    bool _isUpstream { false };
     tbb::concurrent_unordered_set<QUuid, UUIDHasher> _ignoredNodeIDSet;
     mutable QReadWriteLock _ignoredNodeIDSetLock;
+    std::vector<QString> _replicatedUsernames { };
 
     std::atomic_bool _ignoreRadiusEnabled;
 };

libraries/networking/src/NodeList.cpp

@@ -654,8 +654,9 @@ void NodeList::parseNodeFromPacketStream(QDataStream& packetStream) {
     QUuid nodeUUID, connectionUUID;
     HifiSockAddr nodePublicSocket, nodeLocalSocket;
     NodePermissions permissions;
+    bool isReplicated;
 
-    packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket >> permissions;
+    packetStream >> nodeType >> nodeUUID >> nodePublicSocket >> nodeLocalSocket >> permissions >> isReplicated;
 
     // if the public socket address is 0 then it's reachable at the same IP
     // as the domain server
@@ -666,7 +667,12 @@ void NodeList::parseNodeFromPacketStream(QDataStream& packetStream) {
     packetStream >> connectionUUID;
 
     SharedNodePointer node = addOrUpdateNode(nodeUUID, nodeType, nodePublicSocket,
-                                             nodeLocalSocket, permissions, connectionUUID);
+                                             nodeLocalSocket, isReplicated, false, connectionUUID, permissions);
+
+    // nodes that are downstream of our own type are kept alive when we hear about them from the domain server
+    if (node->getType() == NodeType::downstreamType(_ownerType)) {
+        node->setLastHeardMicrostamp(usecTimestampNow());
+    }
 }
 
 void NodeList::sendAssignment(Assignment& assignment) {
@@ -711,14 +717,20 @@ void NodeList::pingPunchForInactiveNode(const SharedNodePointer& node) {
 }
 
 void NodeList::startNodeHolePunch(const SharedNodePointer& node) {
-    // connect to the correct signal on this node so we know when to ping it
-    connect(node.data(), &Node::pingTimerTimeout, this, &NodeList::handleNodePingTimeout);
 
-    // start the ping timer for this node
-    node->startPingTimer();
+    // we don't hole punch to downstream servers, since it is assumed that we have a direct line to them
+    // we also don't hole punch to relayed upstream nodes, since we do not communicate directly with them
 
-    // ping this node immediately
-    pingPunchForInactiveNode(node);
+    if (!NodeType::isDownstream(node->getType()) && !node->isUpstream()) {
+        // connect to the correct signal on this node so we know when to ping it
+        connect(node.data(), &Node::pingTimerTimeout, this, &NodeList::handleNodePingTimeout);
+
+        // start the ping timer for this node
+        node->startPingTimer();
+
+        // ping this node immediately
+        pingPunchForInactiveNode(node);
+    }
 }
 
 void NodeList::handleNodePingTimeout() {
@@ -761,8 +773,11 @@ void NodeList::stopKeepalivePingTimer() {
 }
 
 void NodeList::sendKeepAlivePings() {
+    // send keep-alive ping packets to nodes of types we care about that are not relayed to us from an upstream node
+
     eachMatchingNode([this](const SharedNodePointer& node)->bool {
-        return _nodeTypesOfInterest.contains(node->getType());
+        auto type = node->getType();
+        return !node->isUpstream() && _nodeTypesOfInterest.contains(type) && !NodeType::isDownstream(type);
     }, [&](const SharedNodePointer& node) {
         sendPacket(constructPingPacket(), *node);
     });
@@ -1120,4 +1135,4 @@ void NodeList::setRequestsDomainListData(bool isRequesting) {
 
 void NodeList::startThread() {
     moveToNewNamedThread(this, "NodeList Thread", QThread::TimeCriticalPriority);
-}
+}

libraries/networking/src/NodeType.h

@@ -25,10 +25,17 @@ namespace NodeType {
     const NodeType_t AssetServer = 'A';
     const NodeType_t MessagesMixer = 'm';
     const NodeType_t EntityScriptServer = 'S';
+    const NodeType_t DownstreamAudioMixer = 'a';
+    const NodeType_t DownstreamAvatarMixer = 'w';
     const NodeType_t Unassigned = 1;
 
     void init();
+
     const QString& getNodeTypeName(NodeType_t nodeType);
+    bool isDownstream(NodeType_t nodeType);
+    NodeType_t downstreamType(NodeType_t primaryType);
+
+    NodeType_t fromString(QString type);
 }
 
 typedef QSet<NodeType_t> NodeSet;

libraries/networking/src/ReceivedMessage.cpp

@@ -42,6 +42,20 @@ ReceivedMessage::ReceivedMessage(NLPacket& packet)
 {
 }
 
+ReceivedMessage::ReceivedMessage(QByteArray byteArray, PacketType packetType, PacketVersion packetVersion,
+                const HifiSockAddr& senderSockAddr, QUuid sourceID) :
+    _data(byteArray),
+    _headData(_data.mid(0, HEAD_DATA_SIZE)),
+    _numPackets(1),
+    _sourceID(sourceID),
+    _packetType(packetType),
+    _packetVersion(packetVersion),
+    _senderSockAddr(senderSockAddr),
+    _isComplete(true)
+{
+
+}
+
 void ReceivedMessage::setFailed() {
     _failed = true;
     _isComplete = true;

libraries/networking/src/ReceivedMessage.h

@@ -24,6 +24,8 @@ class ReceivedMessage : public QObject {
 public:
     ReceivedMessage(const NLPacketList& packetList);
     ReceivedMessage(NLPacket& packet);
+    ReceivedMessage(QByteArray byteArray, PacketType packetType, PacketVersion packetVersion,
+                    const HifiSockAddr& senderSockAddr, QUuid sourceID = QUuid());
 
     QByteArray getMessage() const { return _data; }
     const char* getRawMessage() const { return _data.constData(); }

libraries/networking/src/ThreadedAssignment.cpp

@@ -10,6 +10,7 @@
 //
 
 #include <QtCore/QCoreApplication>
+#include <QtCore/QJsonArray>
 #include <QtCore/QJsonObject>
 #include <QtCore/QThread>
 #include <QtCore/QTimer>

libraries/networking/src/ThreadedAssignment.h

@@ -18,6 +18,8 @@
 
 #include "Assignment.h"
 
+using DownstreamNodeFoundCallback = std::function<void(Node& downstreamNode)>;
+
 class ThreadedAssignment : public Assignment {
     Q_OBJECT
 public:
@@ -40,6 +42,7 @@ signals:
 
 protected:
     void commonInit(const QString& targetName, NodeType_t nodeType);
+
     bool _isFinished;
     QTimer _domainServerTimer;
     QTimer _statsTimer;

libraries/networking/src/udt/PacketHeaders.cpp

@@ -39,7 +39,19 @@ const QSet<PacketType> NON_SOURCED_PACKETS = QSet<PacketType>()
     << PacketType::ICEServerPeerInformation << PacketType::ICEServerQuery << PacketType::ICEServerHeartbeat
     << PacketType::ICEServerHeartbeatACK << PacketType::ICEPing << PacketType::ICEPingReply
     << PacketType::ICEServerHeartbeatDenied << PacketType::AssignmentClientStatus << PacketType::StopNode
-    << PacketType::DomainServerRemovedNode << PacketType::UsernameFromIDReply << PacketType::OctreeFileReplacement;
+    << PacketType::DomainServerRemovedNode << PacketType::UsernameFromIDReply << PacketType::OctreeFileReplacement
+    << PacketType::ReplicatedMicrophoneAudioNoEcho << PacketType::ReplicatedMicrophoneAudioWithEcho
+    << PacketType::ReplicatedInjectAudio << PacketType::ReplicatedSilentAudioFrame
+    << PacketType::ReplicatedAvatarIdentity << PacketType::ReplicatedKillAvatar << PacketType::ReplicatedBulkAvatarData;
+
+const QHash<PacketType, PacketType> REPLICATED_PACKET_MAPPING {
+    { PacketType::MicrophoneAudioNoEcho, PacketType::ReplicatedMicrophoneAudioNoEcho },
+    { PacketType::MicrophoneAudioWithEcho, PacketType::ReplicatedMicrophoneAudioWithEcho },
+    { PacketType::InjectAudio, PacketType::ReplicatedInjectAudio },
+    { PacketType::SilentAudioFrame, PacketType::ReplicatedSilentAudioFrame },
+    { PacketType::AvatarIdentity, PacketType::ReplicatedAvatarIdentity },
+    { PacketType::KillAvatar, PacketType::ReplicatedKillAvatar },
+};
 
 PacketVersion versionForPacketType(PacketType packetType) {
     switch (packetType) {
@@ -56,7 +68,7 @@ PacketVersion versionForPacketType(PacketType packetType) {
         case PacketType::AvatarData:
         case PacketType::BulkAvatarData:
         case PacketType::KillAvatar:
-            return static_cast<PacketVersion>(AvatarMixerPacketVersion::MannequinDefaultAvatar);
+            return static_cast<PacketVersion>(AvatarMixerPacketVersion::AvatarIdentitySequenceFront);
         case PacketType::MessagesData:
             return static_cast<PacketVersion>(MessageDataVersion::TextOrBinaryData);
         case PacketType::ICEServerHeartbeat:
@@ -119,7 +131,7 @@ static void ensureProtocolVersionsSignature() {
     std::call_once(once, [&] {
         QByteArray buffer;
         QDataStream stream(&buffer, QIODevice::WriteOnly);
-        uint8_t numberOfProtocols = static_cast<uint8_t>(PacketType::LAST_PACKET_TYPE) + 1;
+        uint8_t numberOfProtocols = static_cast<uint8_t>(PacketType::NUM_PACKET_TYPE);
         stream << numberOfProtocols;
         for (uint8_t packetType = 0; packetType < numberOfProtocols; packetType++) {
             uint8_t packetTypeVersion = static_cast<uint8_t>(versionForPacketType(static_cast<PacketType>(packetType)));

libraries/networking/src/udt/PacketHeaders.h

@@ -115,12 +115,21 @@ public:
         AdjustAvatarSorting,
         OctreeFileReplacement,
         CollisionEventChanges,
-        LAST_PACKET_TYPE = CollisionEventChanges
+        ReplicatedMicrophoneAudioNoEcho,
+        ReplicatedMicrophoneAudioWithEcho,
+        ReplicatedInjectAudio,
+        ReplicatedSilentAudioFrame,
+        ReplicatedAvatarIdentity,
+        ReplicatedKillAvatar,
+        ReplicatedBulkAvatarData,
+        NUM_PACKET_TYPE
     };
 };
 
 using PacketType = PacketTypeEnum::Value;
 
+extern const QHash<PacketType, PacketType> REPLICATED_PACKET_MAPPING;
+
 const int NUM_BYTES_MD5_HASH = 16;
 
 typedef char PacketVersion;
@@ -237,7 +246,8 @@ enum class AvatarMixerPacketVersion : PacketVersion {
     StickAndBallDefaultAvatar,
     IdentityPacketsIncludeUpdateTime,
     AvatarIdentitySequenceId,
-    MannequinDefaultAvatar
+    MannequinDefaultAvatar,
+    AvatarIdentitySequenceFront
 };
 
 enum class DomainConnectRequestVersion : PacketVersion {

libraries/networking/src/udt/PacketList.cpp

@@ -36,8 +36,8 @@ std::unique_ptr<PacketList> PacketList::fromReceivedPackets(std::list<std::uniqu
 
 PacketList::PacketList(PacketType packetType, QByteArray extendedHeader, bool isReliable, bool isOrdered) :
     _packetType(packetType),
-    _isReliable(isReliable),
     _isOrdered(isOrdered),
+    _isReliable(isReliable),
     _extendedHeader(extendedHeader)
 {
     Q_ASSERT_X(!(!_isReliable && _isOrdered), "PacketList", "Unreliable ordered PacketLists are not currently supported");
@@ -46,8 +46,8 @@ PacketList::PacketList(PacketType packetType, QByteArray extendedHeader, bool is
 PacketList::PacketList(PacketList&& other) :
     _packetType(other._packetType),
     _packets(std::move(other._packets)),
-    _isReliable(other._isReliable),
     _isOrdered(other._isOrdered),
+    _isReliable(other._isReliable),
     _extendedHeader(std::move(other._extendedHeader))
 {
 }

libraries/networking/src/udt/PacketList.h

@@ -49,6 +49,8 @@ public:
     void startSegment();
     void endSegment();
 
+    virtual qint64 getMaxSegmentSize() const { return Packet::maxPayloadSize(_isOrdered); }
+
     HifiSockAddr getSenderSockAddr() const;
     
     void closeCurrentPacket(bool shouldSendEmpty = false);
@@ -74,6 +76,8 @@ protected:
     
     PacketType _packetType;
     std::list<std::unique_ptr<Packet>> _packets;
+
+    bool _isOrdered = false;
     
 private:
     friend class ::LimitedNodeList;
@@ -93,7 +97,6 @@ private:
     
     Packet::MessageNumber _messageNumber;
     bool _isReliable = false;
-    bool _isOrdered = false;
     
     std::unique_ptr<Packet> _currentPacket;
     

libraries/networking/src/udt/SequenceNumber.h

@@ -35,8 +35,8 @@ public:
     explicit SequenceNumber(char* value) { _value = (*reinterpret_cast<int32_t*>(value)) & MAX; }
     explicit SequenceNumber(Type value) { _value = (value <= MAX) ? ((value >= 0) ? value : 0) : MAX; }
     explicit SequenceNumber(UType value) { _value = (value <= MAX) ? value : MAX; }
-    explicit operator Type() { return _value; }
-    explicit operator UType() { return static_cast<UType>(_value); }
+    explicit operator Type() const { return _value; }
+    explicit operator UType() const { return static_cast<UType>(_value); }
     
     inline SequenceNumber& operator++() {
         _value = (_value + 1) % (MAX + 1);

libraries/plugins/src/plugins/InputConfiguration.cpp

@@ -0,0 +1,143 @@
+//
+//  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
+//
+
+
+#include "InputConfiguration.h"
+
+#include <QThread>
+
+#include "DisplayPlugin.h"
+#include "InputPlugin.h"
+#include "PluginManager.h"
+
+InputConfiguration::InputConfiguration() {
+}
+
+QStringList InputConfiguration::inputPlugins() {
+    if (QThread::currentThread() != thread()) {
+        QStringList result;
+        QMetaObject::invokeMethod(this, "inputPlugins", Qt::BlockingQueuedConnection,
+                                  Q_RETURN_ARG(QStringList, result));
+        return result;
+    }
+
+    QStringList inputPlugins;
+    for (auto plugin : PluginManager::getInstance()->getInputPlugins()) {
+        QString pluginName = plugin->getName();
+        if (pluginName == QString("OpenVR")) {
+            inputPlugins << QString("Vive");
+        } else {
+            inputPlugins << pluginName;
+        }
+    }
+    return inputPlugins;
+}
+
+
+QStringList InputConfiguration::activeInputPlugins() {
+    if (QThread::currentThread() != thread()) {
+        QStringList result;
+        QMetaObject::invokeMethod(this, "activeInputPlugins", Qt::BlockingQueuedConnection,
+                                   Q_RETURN_ARG(QStringList, result));
+        return result;
+    }
+
+    QStringList activePlugins;
+    for (auto plugin : PluginManager::getInstance()->getInputPlugins()) {
+        if (plugin->configurable()) {
+            QString pluginName = plugin->getName();
+            if (pluginName == QString("OpenVR")) {
+                activePlugins << QString("Vive");
+            } else {
+                activePlugins << pluginName;
+            }
+        }
+    }
+    return activePlugins;
+}
+
+QString InputConfiguration::configurationLayout(QString pluginName) {
+    if (QThread::currentThread() != thread()) {
+        QString result;
+        QMetaObject::invokeMethod(this, "configurationLayout", Qt::BlockingQueuedConnection,
+                                  Q_RETURN_ARG(QString, result),
+                                  Q_ARG(QString, pluginName));
+        return result;
+    }
+
+    QString sourcePath;
+    for (auto plugin : PluginManager::getInstance()->getInputPlugins()) {
+        if (plugin->getName() == pluginName) {
+            return plugin->configurationLayout();
+        }
+    }
+    return sourcePath;
+}
+
+void InputConfiguration::setConfigurationSettings(QJsonObject configurationSettings, QString pluginName) {
+    if (QThread::currentThread() != thread()) {
+        QMetaObject::invokeMethod(this, "setConfigurationSettings", Qt::BlockingQueuedConnection,
+                                  Q_ARG(QJsonObject, configurationSettings),
+                                  Q_ARG(QString, pluginName));
+        return;
+    }
+
+    for (auto plugin : PluginManager::getInstance()->getInputPlugins()) {
+        if (plugin->getName() == pluginName) {
+            plugin->setConfigurationSettings(configurationSettings);
+        }
+    }
+}
+
+QJsonObject InputConfiguration::configurationSettings(QString pluginName) {
+    if (QThread::currentThread() != thread()) {
+        QJsonObject result;
+        QMetaObject::invokeMethod(this, "configurationSettings", Qt::BlockingQueuedConnection,
+                                  Q_RETURN_ARG(QJsonObject, result),
+                                  Q_ARG(QString, pluginName));
+        return result;
+    }
+
+    for (auto plugin : PluginManager::getInstance()->getInputPlugins()) {
+        if (plugin->getName() == pluginName) {
+            return plugin->configurationSettings();
+        }
+    }
+    return QJsonObject();
+}
+
+void InputConfiguration::calibratePlugin(QString pluginName) {
+    if (QThread::currentThread() != thread()) {
+        QMetaObject::invokeMethod(this, "calibratePlugin", Qt::BlockingQueuedConnection);
+        return;
+    }
+
+    for (auto plugin : PluginManager::getInstance()->getInputPlugins()) {
+        if (plugin->getName() == pluginName) {
+            plugin->calibrate();
+        }
+    }
+}
+
+
+bool InputConfiguration::uncalibratePlugin(QString pluginName) {
+    if (QThread::currentThread() != thread()) {
+        bool result;
+        QMetaObject::invokeMethod(this, "uncalibratePlugin", Qt::BlockingQueuedConnection,
+                                  Q_ARG(bool, result));
+        return result;
+    }
+
+    for (auto plugin : PluginManager::getInstance()->getInputPlugins()) {
+        if (plugin->getName() == pluginName) {
+            return plugin->uncalibrate();
+        }
+    }
+    
+    return false;
+}

libraries/plugins/src/plugins/InputConfiguration.h

@@ -0,0 +1,37 @@
+//
+//  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
+//
+
+#ifndef hifi_InputConfiguration_h
+#define hifi_InputConfiguration_h
+
+#include <mutex>
+
+#include <QObject>
+#include <QString>
+#include <QStringList>
+#include <QJsonObject>
+#include <DependencyManager.h>
+
+class InputConfiguration : public QObject, public Dependency {
+    Q_OBJECT
+public:
+    InputConfiguration();
+
+    Q_INVOKABLE QStringList inputPlugins();
+    Q_INVOKABLE QStringList activeInputPlugins();
+    Q_INVOKABLE QString configurationLayout(QString pluginName);
+    Q_INVOKABLE void setConfigurationSettings(QJsonObject configurationSettings, QString pluginName);
+    Q_INVOKABLE void calibratePlugin(QString pluginName);
+    Q_INVOKABLE QJsonObject configurationSettings(QString pluginName);
+    Q_INVOKABLE bool uncalibratePlugin(QString pluginName);
+
+signals:
+    void calibrationStatus(const QJsonObject& status);
+};
+
+#endif

libraries/plugins/src/plugins/InputPlugin.h

@@ -11,6 +11,7 @@
 #pragma once
 
 #include "Plugin.h"
+#include <QJsonObject>
 
 namespace controller {
     struct InputCalibrationData;
@@ -24,7 +25,12 @@ public:
     // Some input plugins are comprised of multiple subdevices (SDL2, for instance).
     // If an input plugin is only a single device, it will only return it's primary name.
     virtual QStringList getSubdeviceNames() { return { getName() }; };
+    virtual void setConfigurationSettings(const QJsonObject configurationSettings) { }
+    virtual QJsonObject configurationSettings() { return QJsonObject(); } 
+    virtual QString configurationLayout() { return QString(); }
+    virtual void calibrate() {}
+    virtual bool uncalibrate() { return false; } 
+    virtual bool configurable() { return false; }
     virtual bool isHandController() const { return false; }
     virtual bool isHeadController() const { return false; }
 };
-

plugins/hifiCodec/CMakeLists.txt

@@ -8,7 +8,7 @@
 
 set(TARGET_NAME hifiCodec)
 setup_hifi_client_server_plugin()
-link_hifi_libraries(audio plugins)
+link_hifi_libraries(audio plugins input-plugins display-plugins)
 add_dependency_external_projects(hifiAudioCodec)
 target_include_directories(${TARGET_NAME} PRIVATE ${HIFIAUDIOCODEC_INCLUDE_DIRS})
 target_link_libraries(${TARGET_NAME} ${HIFIAUDIOCODEC_LIBRARIES})

plugins/hifiKinect/CMakeLists.txt

@@ -11,7 +11,7 @@ if (WIN32)
     if (KINECT_FOUND) 
         set(TARGET_NAME hifiKinect)
         setup_hifi_plugin(Script Qml Widgets)
-        link_hifi_libraries(shared controllers ui plugins input-plugins)
+        link_hifi_libraries(shared controllers ui plugins input-plugins display-plugins)
     
         # need to setup appropriate externals...
         target_kinect()

plugins/hifiNeuron/CMakeLists.txt

@@ -10,7 +10,7 @@ if (APPLE OR WIN32)
     
     set(TARGET_NAME hifiNeuron)
     setup_hifi_plugin(Script Qml Widgets)
-    link_hifi_libraries(shared controllers ui plugins input-plugins)
+    link_hifi_libraries(shared controllers ui plugins input-plugins display-plugins)
     target_neuron()
 
 endif()

plugins/hifiSdl2/CMakeLists.txt

@@ -8,5 +8,5 @@
 
 set(TARGET_NAME hifiSdl2)
 setup_hifi_plugin(Script Qml Widgets)
-link_hifi_libraries(shared controllers ui plugins input-plugins script-engine)
+link_hifi_libraries(shared controllers ui plugins input-plugins script-engine display-plugins)
 target_sdl2()

plugins/hifiSixense/CMakeLists.txt

@@ -9,6 +9,6 @@
 if (NOT ANDROID)
   set(TARGET_NAME hifiSixense)
   setup_hifi_plugin(Script Qml Widgets)
-  link_hifi_libraries(shared controllers ui plugins ui-plugins input-plugins)
+  link_hifi_libraries(shared controllers ui plugins ui-plugins input-plugins display-plugins)
   target_sixense()
 endif ()

plugins/openvr/src/ViveControllerManager.cpp

@@ -30,7 +30,7 @@
 #include <glm/gtc/quaternion.hpp>
 
 #include <controllers/UserInputMapper.h>
-
+#include <Plugins/InputConfiguration.h>
 #include <controllers/StandardControls.h>
 
 
@@ -39,7 +39,7 @@ extern PoseData _nextSimPoseData;
 vr::IVRSystem* acquireOpenVrSystem();
 void releaseOpenVrSystem();
 
-
+static const QString OPENVR_LAYOUT = QString("OpenVrConfiguration.qml");
 static const char* CONTROLLER_MODEL_STRING = "vr_controller_05_wireless_b";
 const quint64 CALIBRATION_TIMELAPSE = 1 * USECS_PER_SECOND;
 
@@ -47,18 +47,23 @@ static const char* MENU_PARENT = "Avatar";
 static const char* MENU_NAME = "Vive Controllers";
 static const char* MENU_PATH = "Avatar" ">" "Vive Controllers";
 static const char* RENDER_CONTROLLERS = "Render Hand Controllers";
+
+static const int MIN_HEAD = 1;
 static const int MIN_PUCK_COUNT = 2;
 static const int MIN_FEET_AND_HIPS = 3;
 static const int MIN_FEET_HIPS_CHEST = 4;
-static const int MIN_FEET_HIPS_HEAD = 4;
 static const int MIN_FEET_HIPS_SHOULDERS = 5;
-static const int MIN_FEET_HIPS_CHEST_HEAD = 5;
+static const int MIN_FEET_HIPS_CHEST_SHOULDERS = 6;
+
 static const int FIRST_FOOT = 0;
 static const int SECOND_FOOT = 1;
 static const int HIP = 2;
 static const int CHEST = 3;
+
 static float HEAD_PUCK_Y_OFFSET = -0.0254f;
 static float HEAD_PUCK_Z_OFFSET = -0.152f;
+static float HAND_PUCK_Y_OFFSET = -0.0508f;
+static float HAND_PUCK_Z_OFFSET = 0.0254f;
 
 const char* ViveControllerManager::NAME { "OpenVR" };
 
@@ -84,7 +89,7 @@ static bool sortPucksXPosition(PuckPosePair firstPuck, PuckPosePair secondPuck)
     return (firstPuck.second.translation.x < secondPuck.second.translation.x);
 }
 
-static bool determineFeetOrdering(const controller::Pose& poseA, const controller::Pose& poseB, glm::vec3 axis, glm::vec3 axisOrigin) {
+static bool determineLimbOrdering(const controller::Pose& poseA, const controller::Pose& poseB, glm::vec3 axis, glm::vec3 axisOrigin) {
     glm::vec3 poseAPosition = poseA.getTranslation();
     glm::vec3 poseBPosition = poseB.getTranslation();
 
@@ -116,10 +121,42 @@ static QString deviceTrackingResultToString(vr::ETrackingResult trackingResult)
     return result;
 }
 
+void ViveControllerManager::calibrate() {
+    if (isSupported()) {
+        _inputDevice->calibrateNextFrame();
+    }
+}
+
+bool ViveControllerManager::uncalibrate() {
+    if (isSupported()) {
+        _inputDevice->uncalibrate();
+        return true;
+    }
+    return false;
+}
+
 bool ViveControllerManager::isSupported() const {
     return openVrSupported();
 }
 
+void ViveControllerManager::setConfigurationSettings(const QJsonObject configurationSettings) {
+    if (isSupported()) {
+        _inputDevice->configureCalibrationSettings(configurationSettings);
+    }
+}
+
+QJsonObject ViveControllerManager::configurationSettings() {
+    if (isSupported()) {
+        return _inputDevice->configurationSettings();
+    }
+
+    return QJsonObject();
+}
+
+QString ViveControllerManager::configurationLayout() {
+    return OPENVR_LAYOUT;
+}
+
 bool ViveControllerManager::activate() {
     InputPlugin::activate();
 
@@ -207,17 +244,11 @@ void ViveControllerManager::pluginUpdate(float deltaTime, const controller::Inpu
 
 ViveControllerManager::InputDevice::InputDevice(vr::IVRSystem*& system) : controller::InputDevice("Vive"), _system(system) {
 
-    _configStringMap[Config::Auto] =  QString("Auto");
-    _configStringMap[Config::Feet] =  QString("Feet");
-    _configStringMap[Config::FeetAndHips] =  QString("FeetAndHips");
-    _configStringMap[Config::FeetHipsAndChest] =  QString("FeetHipsAndChest");
+    _configStringMap[Config::None] = QString("None");
+    _configStringMap[Config::Feet] = QString("Feet");
+    _configStringMap[Config::FeetAndHips] = QString("FeetAndHips");
+    _configStringMap[Config::FeetHipsAndChest] = QString("FeetHipsAndChest");
     _configStringMap[Config::FeetHipsAndShoulders] = QString("FeetHipsAndShoulders");
-    _configStringMap[Config::FeetHipsChestAndHead] = QString("FeetHipsChestAndHead");
-    _configStringMap[Config::FeetHipsAndHead] = QString("FeetHipsAndHead");
-
-    if (openVrSupported()) {
-        createPreferences();
-    }
 }
 
 void ViveControllerManager::InputDevice::update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) {
@@ -265,6 +296,14 @@ void ViveControllerManager::InputDevice::update(float deltaTime, const controlle
     }
     _trackedControllers = numTrackedControllers;
 
+    calibrateFromHandController(inputCalibrationData);
+    calibrateFromUI(inputCalibrationData);
+
+    updateCalibratedLimbs();
+    _lastSimPoseData = _nextSimPoseData;
+}
+
+void ViveControllerManager::InputDevice::calibrateFromHandController(const controller::InputCalibrationData& inputCalibrationData) {
     if (checkForCalibrationEvent()) {
         quint64 currentTime = usecTimestampNow();
         if (!_timeTilCalibrationSet) {
@@ -280,9 +319,82 @@ void ViveControllerManager::InputDevice::update(float deltaTime, const controlle
         _triggersPressedHandled = false;
         _timeTilCalibrationSet = false;
     }
+}
 
-    updateCalibratedLimbs();
-    _lastSimPoseData = _nextSimPoseData;
+void ViveControllerManager::InputDevice::calibrateFromUI(const controller::InputCalibrationData& inputCalibrationData) {
+    if (_calibrate) {
+        uncalibrate();
+        calibrate(inputCalibrationData);
+        _calibrate = false;
+    }
+}
+
+void ViveControllerManager::InputDevice::configureCalibrationSettings(const QJsonObject configurationSettings) {
+    Locker locker(_lock);
+    if (!configurationSettings.empty()) {
+        auto iter = configurationSettings.begin();
+        auto end = configurationSettings.end();
+        while (iter != end) {
+            if (iter.key() == "bodyConfiguration") {
+                setConfigFromString(iter.value().toString());
+            } else if (iter.key() == "headConfiguration") {
+                QJsonObject headObject = iter.value().toObject();
+                bool overrideHead = headObject["override"].toBool();
+                if (overrideHead) {
+                    _headConfig = HeadConfig::Puck;
+                    HEAD_PUCK_Y_OFFSET = headObject["Y"].toDouble();
+                    HEAD_PUCK_Z_OFFSET = headObject["Z"].toDouble();
+                } else {
+                    _headConfig = HeadConfig::HMD;
+                }
+            } else if (iter.key() == "handConfiguration") {
+                QJsonObject handsObject = iter.value().toObject();
+                bool overrideHands = handsObject["override"].toBool();
+                if (overrideHands) {
+                    _handConfig = HandConfig::Pucks;
+                    HAND_PUCK_Y_OFFSET = handsObject["Y"].toDouble();
+                    HAND_PUCK_Z_OFFSET = handsObject["Z"].toDouble();
+                } else {
+                    _handConfig = HandConfig::HandController;
+                }
+            }
+            iter++;
+        }
+    }
+}
+
+void ViveControllerManager::InputDevice::calibrateNextFrame() {
+    Locker locker(_lock);
+    _calibrate = true;
+}
+
+QJsonObject ViveControllerManager::InputDevice::configurationSettings() {
+    Locker locker(_lock);
+    QJsonObject configurationSettings;
+    configurationSettings["trackerConfiguration"] = configToString(_preferedConfig);
+    configurationSettings["HMDHead"] = (_headConfig == HeadConfig::HMD) ? true : false;
+    configurationSettings["handController"] = (_handConfig == HandConfig::HandController) ? true : false;
+    return configurationSettings;
+}
+
+void ViveControllerManager::InputDevice::emitCalibrationStatus(const bool success) {
+    auto inputConfiguration = DependencyManager::get<InputConfiguration>();
+    QJsonObject status = QJsonObject();
+
+    if (_calibrated && success) {
+        status["calibrated"] = _calibrated;
+        status["configuration"] = configToString(_preferedConfig);
+    } else if (!_calibrated && !success) {
+        status["calibrated"] = _calibrated;
+        status["success"] = success;
+    } else if (!_calibrated && success) {
+        status["calibrated"] = _calibrated;
+        status["success"] = success;
+        status["configuration"] = configToString(_preferedConfig);
+        status["puckCount"] = (int)_validTrackedObjects.size();
+    }
+    
+    emit inputConfiguration->calibrationStatus(status); //inputConfiguration->calibrated(status);
 }
 
 void ViveControllerManager::InputDevice::handleTrackedObject(uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData) {
@@ -330,102 +442,142 @@ void ViveControllerManager::InputDevice::calibrateOrUncalibrate(const controller
         calibrate(inputCalibration);
     } else {
         uncalibrate();
+        emitCalibrationStatus(true);
     }
 }
 
 void ViveControllerManager::InputDevice::calibrate(const controller::InputCalibrationData& inputCalibration) {
     qDebug() << "Puck Calibration: Starting...";
-    // convert the hmd head from sensor space to avatar space
-    glm::mat4 hmdSensorFlippedMat = inputCalibration.hmdSensorMat * Matrices::Y_180;
-    glm::mat4 sensorToAvatarMat = glm::inverse(inputCalibration.avatarMat) * inputCalibration.sensorToWorldMat;
-    glm::mat4 hmdAvatarMat = sensorToAvatarMat * hmdSensorFlippedMat;
-
-    // cancel the roll and pitch for the hmd head
-    glm::quat hmdRotation = cancelOutRollAndPitch(glmExtractRotation(hmdAvatarMat));
-    glm::vec3 hmdTranslation = extractTranslation(hmdAvatarMat);
-    glm::mat4 currentHmd = createMatFromQuatAndPos(hmdRotation, hmdTranslation);
-
-    // calculate the offset from the centerOfEye to defaultHeadMat
-    glm::mat4 defaultHeadOffset = glm::inverse(inputCalibration.defaultCenterEyeMat) * inputCalibration.defaultHeadMat;
-
-    glm::mat4 currentHead  = currentHmd * defaultHeadOffset;
-
-    // calculate the defaultToRefrenceXform
-    glm::mat4 defaultToReferenceMat = currentHead * glm::inverse(inputCalibration.defaultHeadMat);
 
     int puckCount = (int)_validTrackedObjects.size();
     qDebug() << "Puck Calibration: " << puckCount << " pucks found for calibration";
-    _config = _preferedConfig;
-    if (_config != Config::Auto && puckCount < MIN_PUCK_COUNT) {
-        qDebug() << "Puck Calibration: Failed: Could not meet the minimal # of pucks";
+
+    if (puckCount == 0) {
         uncalibrate();
+        emitCalibrationStatus(false);
         return;
-    } else if (_config == Config::Auto){
-        if (puckCount == MIN_PUCK_COUNT) {
-            _config = Config::Feet;
-            qDebug() << "Puck Calibration: Auto Config: " << configToString(_config) << " configuration";
-        } else if (puckCount == MIN_FEET_AND_HIPS) {
-            _config = Config::FeetAndHips;
-            qDebug() << "Puck Calibration: Auto Config: " << configToString(_config) << " configuration";
-        } else if (puckCount >= MIN_FEET_HIPS_CHEST) {
-            _config = Config::FeetHipsAndChest;
-            qDebug() << "Puck Calibration: Auto Config: " << configToString(_config) << " configuration";
-        } else {
-            qDebug() << "Puck Calibration: Auto Config Failed: Could not meet the minimal # of pucks";
-            uncalibrate();
-            return;
-        }
     }
 
-    std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksYPosition);
+    glm::mat4 defaultToReferenceMat = glm::mat4();
+    if (_headConfig == HeadConfig::HMD) {
+        defaultToReferenceMat = calculateDefaultToReferenceForHmd(inputCalibration);
+    } else if (_headConfig == HeadConfig::Puck) { 
+        defaultToReferenceMat = calculateDefaultToReferenceForHeadPuck(inputCalibration);
+    }
+    
+    _config = _preferedConfig;
+    
+    bool headConfigured = configureHead(defaultToReferenceMat, inputCalibration);
+    bool handsConfigured = configureHands(defaultToReferenceMat, inputCalibration);
+    bool bodyConfigured = configureBody(defaultToReferenceMat, inputCalibration);
 
-    if (_config == Config::Feet) {
+    if (!headConfigured || !handsConfigured || !bodyConfigured) {
+        uncalibrate();
+        emitCalibrationStatus(false);
+    } else {
+        _calibrated = true;
+        emitCalibrationStatus(true);
+        qDebug() << "PuckCalibration: " << configToString(_config) << " Configuration Successful";
+    }
+}
+
+bool ViveControllerManager::InputDevice::configureHands(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
+    std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksXPosition);
+    int puckCount = (int)_validTrackedObjects.size();
+    if (_handConfig == HandConfig::Pucks && puckCount >= MIN_PUCK_COUNT) {
+        glm::vec3 headXAxis = getReferenceHeadXAxis(defaultToReferenceMat, inputCalibration.defaultHeadMat);
+        glm::vec3 headPosition = getReferenceHeadPosition(defaultToReferenceMat, inputCalibration.defaultHeadMat);
+        size_t FIRST_INDEX = 0;
+        size_t LAST_INDEX = _validTrackedObjects.size() -1;
+        auto& firstHand = _validTrackedObjects[FIRST_INDEX];
+        auto& secondHand = _validTrackedObjects[LAST_INDEX];
+        controller::Pose& firstHandPose = firstHand.second;
+        controller::Pose& secondHandPose = secondHand.second;
+
+        if (determineLimbOrdering(firstHandPose, secondHandPose, headXAxis, headPosition)) {
+            calibrateLeftHand(defaultToReferenceMat, inputCalibration, firstHand);
+            calibrateRightHand(defaultToReferenceMat, inputCalibration, secondHand);
+            _validTrackedObjects.erase(_validTrackedObjects.begin());
+            _validTrackedObjects.erase(_validTrackedObjects.end() - 1);
+            _overrideHands = true;
+            return true;
+        } else {
+            calibrateLeftHand(defaultToReferenceMat, inputCalibration, secondHand);
+            calibrateRightHand(defaultToReferenceMat, inputCalibration, firstHand);
+            _validTrackedObjects.erase(_validTrackedObjects.begin());
+            _validTrackedObjects.erase(_validTrackedObjects.end() - 1);
+            _overrideHands = true;
+            return true;
+        }
+    } else if (_handConfig == HandConfig::HandController) {
+        _overrideHands = false;
+        return true;
+    }
+    return false;
+}
+
+bool ViveControllerManager::InputDevice::configureHead(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
+    std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksYPosition);
+    int puckCount = (int)_validTrackedObjects.size();
+    if (_headConfig == HeadConfig::Puck && puckCount >= MIN_HEAD) {
+         calibrateHead(defaultToReferenceMat, inputCalibration);
+        _validTrackedObjects.erase(_validTrackedObjects.end() - 1);
+        _overrideHead = true;
+        return true;
+    } else if (_headConfig == HeadConfig::HMD) {
+        return true;
+    }
+    return false;
+}
+
+bool ViveControllerManager::InputDevice::configureBody(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
+    std::sort(_validTrackedObjects.begin(), _validTrackedObjects.end(), sortPucksYPosition);
+    int puckCount = (int)_validTrackedObjects.size();
+    glm::vec3 headXAxis = getReferenceHeadXAxis(defaultToReferenceMat, inputCalibration.defaultHeadMat);
+    glm::vec3 headPosition = getReferenceHeadPosition(defaultToReferenceMat, inputCalibration.defaultHeadMat);
+    if (_config == Config::None) {
+        return true;
+    } else if (_config == Config::Feet && puckCount >= MIN_PUCK_COUNT) {
         calibrateFeet(defaultToReferenceMat, inputCalibration);
+        return true;
     } else if (_config == Config::FeetAndHips && puckCount >= MIN_FEET_AND_HIPS) {
         calibrateFeet(defaultToReferenceMat, inputCalibration);
         calibrateHips(defaultToReferenceMat, inputCalibration);
+        return true;
     } else if (_config == Config::FeetHipsAndChest && puckCount >= MIN_FEET_HIPS_CHEST) {
         calibrateFeet(defaultToReferenceMat, inputCalibration);
         calibrateHips(defaultToReferenceMat, inputCalibration);
         calibrateChest(defaultToReferenceMat, inputCalibration);
+        return true;
     } else if (_config == Config::FeetHipsAndShoulders && puckCount >= MIN_FEET_HIPS_SHOULDERS) {
         calibrateFeet(defaultToReferenceMat, inputCalibration);
         calibrateHips(defaultToReferenceMat, inputCalibration);
         int firstShoulderIndex = 3;
         int secondShoulderIndex = 4;
         calibrateShoulders(defaultToReferenceMat, inputCalibration, firstShoulderIndex, secondShoulderIndex);
-    } else if (_config == Config::FeetHipsAndHead && puckCount == MIN_FEET_HIPS_HEAD) {
-        glm::mat4 headPuckDefaultToReferenceMat = recalculateDefaultToReferenceForHeadPuck(inputCalibration);
-        glm::vec3 headXAxis = getReferenceHeadXAxis(headPuckDefaultToReferenceMat, inputCalibration.defaultHeadMat);
-        glm::vec3 headPosition = getReferenceHeadPosition(headPuckDefaultToReferenceMat, inputCalibration.defaultHeadMat);
-        calibrateFeet(headPuckDefaultToReferenceMat, inputCalibration, headXAxis, headPosition);
-        calibrateHips(headPuckDefaultToReferenceMat, inputCalibration);
-        calibrateHead(headPuckDefaultToReferenceMat, inputCalibration);
-        _overrideHead = true;
-    } else if (_config == Config::FeetHipsChestAndHead && puckCount == MIN_FEET_HIPS_CHEST_HEAD) {
-        glm::mat4 headPuckDefaultToReferenceMat = recalculateDefaultToReferenceForHeadPuck(inputCalibration);
-        glm::vec3 headXAxis = getReferenceHeadXAxis(headPuckDefaultToReferenceMat, inputCalibration.defaultHeadMat);
-        glm::vec3 headPosition = getReferenceHeadPosition(headPuckDefaultToReferenceMat, inputCalibration.defaultHeadMat);
-        calibrateFeet(headPuckDefaultToReferenceMat, inputCalibration, headXAxis, headPosition);
-        calibrateHips(headPuckDefaultToReferenceMat, inputCalibration);
-        calibrateChest(headPuckDefaultToReferenceMat, inputCalibration);
-        calibrateHead(headPuckDefaultToReferenceMat, inputCalibration);
-        _overrideHead = true;
-    } else {
-        qDebug() << "Puck Calibration: " << configToString(_config) << " Config Failed: Could not meet the minimal # of pucks";
-        uncalibrate();
-        return;
+        return true;
+    } else if (_config == Config::FeetHipsChestAndShoulders && puckCount >= MIN_FEET_HIPS_CHEST_SHOULDERS) {
+        calibrateFeet(defaultToReferenceMat, inputCalibration);
+        calibrateHips(defaultToReferenceMat, inputCalibration);
+        calibrateChest(defaultToReferenceMat, inputCalibration);
+        int firstShoulderIndex = 4;
+        int secondShoulderIndex = 5;
+        calibrateShoulders(defaultToReferenceMat, inputCalibration, firstShoulderIndex, secondShoulderIndex);
+        return true;
     }
-    _calibrated = true;
-    qDebug() << "PuckCalibration: " << configToString(_config) << " Configuration Successful";
+    qDebug() << "Puck Calibration: " << configToString(_config) << " Config Failed: Could not meet the minimal # of pucks";
+    uncalibrate();
+    emitCalibrationStatus(false);
+    return false;
 }
 
 void ViveControllerManager::InputDevice::uncalibrate() {
-    _config = Config::Auto;
+    _config = Config::None;
     _pucksOffset.clear();
     _jointToPuckMap.clear();
     _calibrated = false;
     _overrideHead = false;
+    _overrideHands = false;
 }
 
 void ViveControllerManager::InputDevice::updateCalibratedLimbs() {
@@ -439,6 +591,11 @@ void ViveControllerManager::InputDevice::updateCalibratedLimbs() {
     if (_overrideHead) {
         _poseStateMap[controller::HEAD] = addOffsetToPuckPose(controller::HEAD);
     }
+
+    if (_overrideHands) {
+        _poseStateMap[controller::LEFT_HAND] = addOffsetToPuckPose(controller::LEFT_HAND);
+        _poseStateMap[controller::RIGHT_HAND] = addOffsetToPuckPose(controller::RIGHT_HAND);
+    }
 }
 
 controller::Pose ViveControllerManager::InputDevice::addOffsetToPuckPose(int joint) const {
@@ -503,8 +660,29 @@ void ViveControllerManager::InputDevice::handleHandController(float deltaTime, u
          }
     }
 }
+glm::mat4 ViveControllerManager::InputDevice::calculateDefaultToReferenceForHmd(const controller::InputCalibrationData& inputCalibration) {
+    // convert the hmd head from sensor space to avatar space
+    glm::mat4 hmdSensorFlippedMat = inputCalibration.hmdSensorMat * Matrices::Y_180;
+    glm::mat4 sensorToAvatarMat = glm::inverse(inputCalibration.avatarMat) * inputCalibration.sensorToWorldMat;
+    glm::mat4 hmdAvatarMat = sensorToAvatarMat * hmdSensorFlippedMat;
 
-glm::mat4 ViveControllerManager::InputDevice::recalculateDefaultToReferenceForHeadPuck(const controller::InputCalibrationData& inputCalibration) {
+    // cancel the roll and pitch for the hmd head
+    glm::quat hmdRotation = cancelOutRollAndPitch(glmExtractRotation(hmdAvatarMat));
+    glm::vec3 hmdTranslation = extractTranslation(hmdAvatarMat);
+    glm::mat4 currentHmd = createMatFromQuatAndPos(hmdRotation, hmdTranslation);
+
+    // calculate the offset from the centerOfEye to defaultHeadMat
+    glm::mat4 defaultHeadOffset = glm::inverse(inputCalibration.defaultCenterEyeMat) * inputCalibration.defaultHeadMat;
+
+    glm::mat4 currentHead  = currentHmd * defaultHeadOffset;
+
+    // calculate the defaultToRefrenceXform
+    glm::mat4 defaultToReferenceMat = currentHead * glm::inverse(inputCalibration.defaultHeadMat);
+
+    return defaultToReferenceMat;
+}
+
+glm::mat4 ViveControllerManager::InputDevice::calculateDefaultToReferenceForHeadPuck(const controller::InputCalibrationData& inputCalibration) {
     glm::mat4 avatarToSensorMat = glm::inverse(inputCalibration.sensorToWorldMat) * inputCalibration.avatarMat;
     glm::mat4 sensorToAvatarMat = glm::inverse(inputCalibration.avatarMat) * inputCalibration.sensorToWorldMat;
     size_t headPuckIndex = _validTrackedObjects.size() - 1;
@@ -709,33 +887,78 @@ void ViveControllerManager::InputDevice::hapticsHelper(float deltaTime, bool lef
     }
 }
 
-void ViveControllerManager::InputDevice::calibrateFeet(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
-    auto& firstFoot = _validTrackedObjects[FIRST_FOOT];
-    auto& secondFoot = _validTrackedObjects[SECOND_FOOT];
-    controller::Pose& firstFootPose = firstFoot.second;
-    controller::Pose& secondFootPose = secondFoot.second;
-    
-    if (firstFootPose.translation.x < secondFootPose.translation.x) {
-        _jointToPuckMap[controller::LEFT_FOOT] = firstFoot.first;
-        _pucksOffset[firstFoot.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultLeftFoot, firstFootPose);
-        _jointToPuckMap[controller::RIGHT_FOOT] = secondFoot.first;
-        _pucksOffset[secondFoot.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultRightFoot, secondFootPose);   
-    } else {
-        _jointToPuckMap[controller::LEFT_FOOT] = secondFoot.first;
-        _pucksOffset[secondFoot.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultLeftFoot, secondFootPose);
-        _jointToPuckMap[controller::RIGHT_FOOT] = firstFoot.first;
-        _pucksOffset[firstFoot.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultRightFoot, firstFootPose);
+void ViveControllerManager::InputDevice::calibrateLeftHand(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair) {
+    controller::Pose& handPose = handPair.second;
+    glm::mat4 handPoseAvatarMat = createMatFromQuatAndPos(handPose.getRotation(), handPose.getTranslation());
+    glm::vec3 handPoseTranslation = extractTranslation(handPoseAvatarMat);
+    glm::vec3 handPoseZAxis = glmExtractRotation(handPoseAvatarMat) * glm::vec3(0.0f, 0.0f, 1.0f);
+    glm::vec3 avatarHandYAxis = transformVectorFast(inputCalibration.defaultLeftHand, glm::vec3(0.0f, 1.0f, 0.0f));
+    const float EPSILON = 1.0e-4f;
+    if (fabsf(fabsf(glm::dot(glm::normalize(avatarHandYAxis), glm::normalize(handPoseZAxis))) - 1.0f) < EPSILON) {
+        handPoseZAxis = glm::vec3(0.0f, 0.0f, 1.0f);
     }
+
+    glm::vec3 zPrime = handPoseZAxis;
+    glm::vec3 xPrime = glm::normalize(glm::cross(avatarHandYAxis, handPoseZAxis));
+    glm::vec3 yPrime = glm::normalize(glm::cross(zPrime, xPrime));
+
+    glm::mat4 newHandMat = glm::mat4(glm::vec4(xPrime, 0.0f), glm::vec4(yPrime, 0.0f),
+                                     glm::vec4(zPrime, 0.0f), glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    
+
+    glm::vec3 translationOffset = glm::vec3(0.0f, HAND_PUCK_Y_OFFSET, HAND_PUCK_Z_OFFSET);
+    glm::quat initialRotation = glmExtractRotation(handPoseAvatarMat);
+    glm::quat finalRotation = glmExtractRotation(newHandMat);
+    
+    glm::quat rotationOffset = glm::inverse(initialRotation) * finalRotation;
+
+    glm::mat4 offsetMat = createMatFromQuatAndPos(rotationOffset, translationOffset);
+
+    _jointToPuckMap[controller::LEFT_HAND] = handPair.first;
+    _pucksOffset[handPair.first] = offsetMat;
+}
+
+void ViveControllerManager::InputDevice::calibrateRightHand(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair) {
+    controller::Pose& handPose = handPair.second;
+    glm::mat4 handPoseAvatarMat = createMatFromQuatAndPos(handPose.getRotation(), handPose.getTranslation());
+    glm::vec3 handPoseTranslation = extractTranslation(handPoseAvatarMat);
+    glm::vec3 handPoseZAxis = glmExtractRotation(handPoseAvatarMat) * glm::vec3(0.0f, 0.0f, 1.0f);
+    glm::vec3 avatarHandYAxis = transformVectorFast(inputCalibration.defaultRightHand, glm::vec3(0.0f, 1.0f, 0.0f));
+    const float EPSILON = 1.0e-4f;
+    if (fabsf(fabsf(glm::dot(glm::normalize(avatarHandYAxis), glm::normalize(handPoseZAxis))) - 1.0f) < EPSILON) {
+        handPoseZAxis = glm::vec3(0.0f, 0.0f, 1.0f);
+    }
+
+    glm::vec3 zPrime = handPoseZAxis;
+    glm::vec3 xPrime = glm::normalize(glm::cross(avatarHandYAxis, handPoseZAxis));
+    glm::vec3 yPrime = glm::normalize(glm::cross(zPrime, xPrime));
+    glm::mat4 newHandMat = glm::mat4(glm::vec4(xPrime, 0.0f), glm::vec4(yPrime, 0.0f),
+                                     glm::vec4(zPrime, 0.0f), glm::vec4(0.0f, 0.0f, 0.0f, 1.0f));
+    
+
+
+    glm::vec3 translationOffset = glm::vec3(0.0f, HAND_PUCK_Y_OFFSET, HAND_PUCK_Z_OFFSET);
+    glm::quat initialRotation = glmExtractRotation(handPoseAvatarMat);
+    glm::quat finalRotation = glmExtractRotation(newHandMat);
+    
+    glm::quat rotationOffset = glm::inverse(initialRotation) * finalRotation;
+
+    glm::mat4 offsetMat = createMatFromQuatAndPos(rotationOffset, translationOffset);
+
+    _jointToPuckMap[controller::RIGHT_HAND] = handPair.first;
+    _pucksOffset[handPair.first] = offsetMat;
 }
 
 
-void ViveControllerManager::InputDevice::calibrateFeet(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, glm::vec3 headXAxis, glm::vec3 headPosition) {
+void ViveControllerManager::InputDevice::calibrateFeet(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration) {
+    glm::vec3 headXAxis = getReferenceHeadXAxis(defaultToReferenceMat, inputCalibration.defaultHeadMat);
+    glm::vec3 headPosition = getReferenceHeadPosition(defaultToReferenceMat, inputCalibration.defaultHeadMat);
     auto& firstFoot = _validTrackedObjects[FIRST_FOOT];
     auto& secondFoot = _validTrackedObjects[SECOND_FOOT];
     controller::Pose& firstFootPose = firstFoot.second;
     controller::Pose& secondFootPose = secondFoot.second;
     
-    if (determineFeetOrdering(firstFootPose, secondFootPose, headXAxis, headPosition)) {
+    if (determineLimbOrdering(firstFootPose, secondFootPose, headXAxis, headPosition)) {
         _jointToPuckMap[controller::LEFT_FOOT] = firstFoot.first;
         _pucksOffset[firstFoot.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultLeftFoot, firstFootPose);
         _jointToPuckMap[controller::RIGHT_FOOT] = secondFoot.first;
@@ -790,32 +1013,13 @@ void ViveControllerManager::InputDevice::calibrateHead(glm::mat4& defaultToRefer
     _pucksOffset[head.first] = computeOffset(defaultToReferenceMat, inputCalibration.defaultHeadMat, newHead);
 }
 
-
-void ViveControllerManager::InputDevice::loadSettings() {
-    Settings settings;
-    settings.beginGroup("PUCK_CONFIG");
-    {
-        _preferedConfig = (Config)settings.value("configuration", QVariant((int)Config::Auto)).toInt();
-    }
-    settings.endGroup();
-}
-
-void ViveControllerManager::InputDevice::saveSettings() const {
-    Settings settings;
-    settings.beginGroup("PUCK_CONFIG");
-    {
-        settings.setValue(QString("configuration"), (int)_preferedConfig);
-    }
-    settings.endGroup();
-}
-
 QString ViveControllerManager::InputDevice::configToString(Config config) {
     return _configStringMap[config];
 }
 
 void ViveControllerManager::InputDevice::setConfigFromString(const QString& value) {
-    if (value ==  "Auto") {
-        _preferedConfig = Config::Auto;
+    if (value ==  "None") {
+        _preferedConfig = Config::None;
     } else if (value == "Feet") {
         _preferedConfig = Config::Feet;
     } else if (value == "FeetAndHips") {
@@ -824,58 +1028,8 @@ void ViveControllerManager::InputDevice::setConfigFromString(const QString& valu
         _preferedConfig = Config::FeetHipsAndChest;
     } else if (value == "FeetHipsAndShoulders") {
         _preferedConfig = Config::FeetHipsAndShoulders;
-    } else if (value == "FeetHipsChestAndHead") {
-        _preferedConfig = Config::FeetHipsChestAndHead;
-    } else if (value == "FeetHipsAndHead") {
-        _preferedConfig = Config::FeetHipsAndHead;
-    }
-}
-
-void ViveControllerManager::InputDevice::createPreferences() {
-    loadSettings();
-    auto preferences = DependencyManager::get<Preferences>();
-    static const QString VIVE_PUCKS_CONFIG = "Vive Pucks Configuration";
-
-    {
-        static const float MIN_VALUE = -3.0f;
-        static const float MAX_VALUE = 3.0f;
-        static const float STEP = 0.01f;
-
-        auto getter = [this]()->float { return HEAD_PUCK_Y_OFFSET; };
-        auto setter = [this](const float& value) { HEAD_PUCK_Y_OFFSET = value; };
-
-        auto preference = new SpinnerPreference(VIVE_PUCKS_CONFIG, "HeadPuckYOffset", getter, setter);
-        preference->setMin(MIN_VALUE);
-        preference->setMax(MAX_VALUE);
-        preference->setDecimals(3);
-        preference->setStep(STEP);
-        preferences->addPreference(preference);
-    }
-
-    {
-        static const float MIN_VALUE = -3.0f;
-        static const float MAX_VALUE = 3.0f;
-        static const float STEP = 0.01f;
-
-        auto getter = [this]()->float { return HEAD_PUCK_Z_OFFSET; };
-        auto setter = [this](const float& value) { HEAD_PUCK_Z_OFFSET = value; };
-
-        auto preference = new SpinnerPreference(VIVE_PUCKS_CONFIG, "HeadPuckXOffset", getter, setter);
-        preference->setMin(MIN_VALUE);
-        preference->setMax(MAX_VALUE);
-        preference->setStep(STEP);
-        preference->setDecimals(3);
-        preferences->addPreference(preference);
-    }
-        
-    {
-        auto getter = [this]()->QString { return _configStringMap[_preferedConfig]; };
-        auto setter = [this](const QString& value) { setConfigFromString(value); saveSettings(); };
-        auto preference = new ComboBoxPreference(VIVE_PUCKS_CONFIG, "Configuration", getter, setter);
-        QStringList list = {"Auto", "Feet", "FeetAndHips", "FeetHipsAndChest", "FeetHipsAndShoulders", "FeetHipsAndHead"};
-        preference->setItems(list);
-        preferences->addPreference(preference);
-
+    } else if (value == "FeetHipsChestAndShoulders") {
+        _preferedConfig = Config::FeetHipsChestAndShoulders;
     }
 }
 

plugins/openvr/src/ViveControllerManager.h

@@ -39,6 +39,13 @@ public:
     const QString getName() const override { return NAME; }
 
     bool isHandController() const override { return true; }
+    bool configurable() override { return true; }
+
+    QString configurationLayout() override;
+    void setConfigurationSettings(const QJsonObject configurationSettings) override;
+    QJsonObject configurationSettings() override;
+    void calibrate() override;
+    bool uncalibrate() override;
     bool isHeadController() const override { return true; }
     bool isHeadControllerMounted() const;
 
@@ -61,14 +68,16 @@ private:
         QString getDefaultMappingConfig() const override;
         void update(float deltaTime, const controller::InputCalibrationData& inputCalibrationData) override;
         void focusOutEvent() override;
-        void createPreferences();
         bool triggerHapticPulse(float strength, float duration, controller::Hand hand) override;
         void hapticsHelper(float deltaTime, bool leftHand);
         void calibrateOrUncalibrate(const controller::InputCalibrationData& inputCalibration);
         void calibrate(const controller::InputCalibrationData& inputCalibration);
         void uncalibrate();
+        void configureCalibrationSettings(const QJsonObject configurationSettings);
+        QJsonObject configurationSettings();
         controller::Pose addOffsetToPuckPose(int joint) const;
-        glm::mat4 recalculateDefaultToReferenceForHeadPuck(const controller::InputCalibrationData& inputCalibration);
+        glm::mat4 calculateDefaultToReferenceForHeadPuck(const controller::InputCalibrationData& inputCalibration);
+        glm::mat4 calculateDefaultToReferenceForHmd(const controller::InputCalibrationData& inputCalibration);
         void updateCalibratedLimbs();
         bool checkForCalibrationEvent();
         void handleHandController(float deltaTime, uint32_t deviceIndex, const controller::InputCalibrationData& inputCalibrationData, bool isLeftHand);
@@ -83,16 +92,21 @@ private:
         void partitionTouchpad(int sButton, int xAxis, int yAxis, int centerPsuedoButton, int xPseudoButton, int yPseudoButton);
         void printDeviceTrackingResultChange(uint32_t deviceIndex);
         void setConfigFromString(const QString& value);
-        void loadSettings();
-        void saveSettings() const;
+        bool configureHead(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration);
+        bool configureHands(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration);
+        bool configureBody(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration);
+        void calibrateLeftHand(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair);
+        void calibrateRightHand(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, PuckPosePair& handPair);
         void calibrateFeet(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration);
-        void calibrateFeet(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration, glm::vec3 headXAxis, glm::vec3 headPosition);
         void calibrateHips(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration);
         void calibrateChest(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration);
-        
         void calibrateShoulders(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration,
                                 int firstShoulderIndex, int secondShoulderIndex);
         void calibrateHead(glm::mat4& defaultToReferenceMat, const controller::InputCalibrationData& inputCalibration);
+        void calibrateFromHandController(const controller::InputCalibrationData& inputCalibrationData);
+        void calibrateFromUI(const controller::InputCalibrationData& inputCalibrationData);
+        void emitCalibrationStatus(const bool success);
+        void calibrateNextFrame();
 
 
         class FilteredStick {
@@ -119,16 +133,28 @@ private:
             glm::vec2 _stick { 0.0f, 0.0f };
         };
         enum class Config {
-            Auto,
+            None,
             Feet,
             FeetAndHips,
             FeetHipsAndChest,
             FeetHipsAndShoulders,
-            FeetHipsChestAndHead,
-            FeetHipsAndHead
+            FeetHipsChestAndShoulders,
         };
-        Config _config { Config::Auto };
-        Config _preferedConfig { Config::Auto };
+
+        enum class HeadConfig {
+            HMD,
+            Puck
+        };
+
+        enum class HandConfig {
+            HandController,
+            Pucks
+        };
+            
+        Config _config { Config::None };
+        Config _preferedConfig { Config::None };
+        HeadConfig _headConfig { HeadConfig::HMD };
+        HandConfig _handConfig { HandConfig::HandController };
         FilteredStick _filteredLeftStick;
         FilteredStick _filteredRightStick;
 
@@ -152,7 +178,9 @@ private:
         bool _triggersPressedHandled { false };
         bool _calibrated { false };
         bool _timeTilCalibrationSet { false };
+        bool _calibrate { false };
         bool _overrideHead { false };
+        bool _overrideHands { false };
         mutable std::recursive_mutex _lock;
 
         QString configToString(Config config);

plugins/pcmCodec/CMakeLists.txt

@@ -8,6 +8,6 @@
 
 set(TARGET_NAME pcmCodec)
 setup_hifi_client_server_plugin()
-link_hifi_libraries(shared plugins)
+link_hifi_libraries(shared plugins input-plugins display-plugins)
 install_beside_console()
 

tools/oven/CMakeLists.txt

@@ -4,15 +4,28 @@ setup_hifi_project(Widgets Gui Concurrent)
 
 link_hifi_libraries(networking shared image gpu ktx)
 
+setup_memory_debugger()
+
 if (WIN32)
   package_libraries_for_deployment()
 endif ()
 
+if (UNIX)
+  find_package(Threads REQUIRED)
+  if(THREADS_HAVE_PTHREAD_ARG)
+    target_compile_options(PUBLIC oven "-pthread")
+  endif()
+endif ()
+
 # try to find the FBX SDK but fail silently if we don't
 # because this tool is not built by default
 find_package(FBX)
 if (FBX_FOUND)
-  target_link_libraries(${TARGET_NAME} ${FBX_LIBRARIES})
+  if (CMAKE_THREAD_LIBS_INIT)
+    target_link_libraries(${TARGET_NAME} ${FBX_LIBRARIES} "${CMAKE_THREAD_LIBS_INIT}")
+  else ()
+    target_link_libraries(${TARGET_NAME} ${FBX_LIBRARIES})
+  endif ()
   target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${FBX_INCLUDE_DIR})
 endif ()
 

tools/oven/src/Oven.cpp

@@ -18,7 +18,7 @@
 
 #include "ui/OvenMainWindow.h"
 #include "Oven.h"
-#include "BakerCli.h"
+#include "BakerCLI.h"
 
 static const QString OUTPUT_FOLDER = "/Users/birarda/code/hifi/lod/test-oven/export";