resolve conflicts on merge with upstream/master

assignment-client/src/Agent.cpp

@@ -27,12 +27,14 @@
 
 #include <recording/Deck.h>
 #include <recording/Recorder.h>
+#include <recording/Frame.h>
 
 #include <WebSocketServerClass.h>
 #include <EntityScriptingInterface.h> // TODO: consider moving to scriptengine.h
 
 #include "avatars/ScriptableAvatar.h"
 #include "RecordingScriptingInterface.h"
+#include "AbstractAudioInterface.h"
 
 #include "Agent.h"
 
@@ -170,15 +172,37 @@ void Agent::run() {
     _scriptEngine->setParent(this); // be the parent of the script engine so it gets moved when we do
 
     // setup an Avatar for the script to use
-    ScriptableAvatar scriptedAvatar(_scriptEngine.get());
-    scriptedAvatar.setForceFaceTrackerConnected(true);
+    auto scriptedAvatar = DependencyManager::get<ScriptableAvatar>();
+    connect(_scriptEngine.get(), SIGNAL(update(float)), scriptedAvatar.data(), SLOT(update(float)), Qt::ConnectionType::QueuedConnection);
+    scriptedAvatar->setForceFaceTrackerConnected(true);
 
     // call model URL setters with empty URLs so our avatar, if user, will have the default models
-    scriptedAvatar.setFaceModelURL(QUrl());
-    scriptedAvatar.setSkeletonModelURL(QUrl());
-
+    scriptedAvatar->setFaceModelURL(QUrl());
+    scriptedAvatar->setSkeletonModelURL(QUrl());
     // give this AvatarData object to the script engine
-    setAvatarData(&scriptedAvatar, "Avatar");
+    _scriptEngine->registerGlobalObject("Avatar", scriptedAvatar.data());
+
+
+    using namespace recording;
+    static const FrameType AVATAR_FRAME_TYPE = Frame::registerFrameType(AvatarData::FRAME_NAME);
+    // FIXME how to deal with driving multiple avatars locally?  
+    Frame::registerFrameHandler(AVATAR_FRAME_TYPE, [this, scriptedAvatar](Frame::ConstPointer frame) {
+        AvatarData::fromFrame(frame->data, *scriptedAvatar);
+    });
+
+
+    using namespace recording;
+    static const FrameType AUDIO_FRAME_TYPE = Frame::registerFrameType(AudioConstants::AUDIO_FRAME_NAME);
+    Frame::registerFrameHandler(AUDIO_FRAME_TYPE, [this, &scriptedAvatar](Frame::ConstPointer frame) {
+        const QByteArray& audio = frame->data;
+        static quint16 audioSequenceNumber{ 0 };
+        Transform audioTransform;
+        audioTransform.setTranslation(scriptedAvatar->getPosition());
+        audioTransform.setRotation(scriptedAvatar->getOrientation());
+        AbstractAudioInterface::emitAudioPacket(audio.data(), audio.size(), audioSequenceNumber, audioTransform, PacketType::MicrophoneAudioNoEcho);
+    });
+
+
 
     auto avatarHashMap = DependencyManager::set<AvatarHashMap>();
     _scriptEngine->registerGlobalObject("AvatarList", avatarHashMap.data());
@@ -218,6 +242,10 @@ void Agent::run() {
     QObject::connect(_scriptEngine.get(), &ScriptEngine::update, this, &Agent::processAgentAvatarAndAudio);
 
     _scriptEngine->run();
+
+    Frame::clearFrameHandler(AUDIO_FRAME_TYPE);
+    Frame::clearFrameHandler(AVATAR_FRAME_TYPE);
+
     setFinished(true);
 }
 
@@ -239,7 +267,6 @@ void Agent::setIsAvatar(bool isAvatar) {
     }
 
     if (!_isAvatar) {
-        DependencyManager::get<RecordingScriptingInterface>()->setControlledAvatar(nullptr);
 
         if (_avatarIdentityTimer) {
             _avatarIdentityTimer->stop();
@@ -255,34 +282,30 @@ void Agent::setIsAvatar(bool isAvatar) {
     }
 }
 
-void Agent::setAvatarData(AvatarData* avatarData, const QString& objectName) {
-    _avatarData = avatarData;
-    _scriptEngine->registerGlobalObject(objectName, avatarData);
-    DependencyManager::get<RecordingScriptingInterface>()->setControlledAvatar(avatarData);
-}
-
 void Agent::sendAvatarIdentityPacket() {
-    if (_isAvatar && _avatarData) {
-        _avatarData->sendIdentityPacket();
+    if (_isAvatar) {
+        auto scriptedAvatar = DependencyManager::get<ScriptableAvatar>();
+        scriptedAvatar->sendIdentityPacket();
     }
 }
 
 void Agent::sendAvatarBillboardPacket() {
-    if (_isAvatar && _avatarData) {
-        _avatarData->sendBillboardPacket();
+    if (_isAvatar) {
+        auto scriptedAvatar = DependencyManager::get<ScriptableAvatar>();
+        scriptedAvatar->sendBillboardPacket();
     }
 }
 
 
 void Agent::processAgentAvatarAndAudio(float deltaTime) {
-    if (!_scriptEngine->isFinished() && _isAvatar && _avatarData) {
-
+    if (!_scriptEngine->isFinished() && _isAvatar) {
+        auto scriptedAvatar = DependencyManager::get<ScriptableAvatar>();
         const int SCRIPT_AUDIO_BUFFER_SAMPLES = floor(((SCRIPT_DATA_CALLBACK_USECS * AudioConstants::SAMPLE_RATE)
             / (1000 * 1000)) + 0.5);
         const int SCRIPT_AUDIO_BUFFER_BYTES = SCRIPT_AUDIO_BUFFER_SAMPLES * sizeof(int16_t);
 
-        QByteArray avatarByteArray = _avatarData->toByteArray(true, randFloat() < AVATAR_SEND_FULL_UPDATE_RATIO);
-        _avatarData->doneEncoding(true);
+        QByteArray avatarByteArray = scriptedAvatar->toByteArray(true, randFloat() < AVATAR_SEND_FULL_UPDATE_RATIO);
+        scriptedAvatar->doneEncoding(true);
 
         static AvatarDataSequenceNumber sequenceNumber = 0;
         auto avatarPacket = NLPacket::create(PacketType::AvatarData, avatarByteArray.size() + sizeof(sequenceNumber));
@@ -347,8 +370,8 @@ void Agent::processAgentAvatarAndAudio(float deltaTime) {
                 audioPacket->writePrimitive(SCRIPT_AUDIO_BUFFER_SAMPLES);
 
                 // use the orientation and position of this avatar for the source of this audio
-                audioPacket->writePrimitive(_avatarData->getPosition());
-                glm::quat headOrientation = _avatarData->getHeadOrientation();
+                audioPacket->writePrimitive(scriptedAvatar->getPosition());
+                glm::quat headOrientation = scriptedAvatar->getHeadOrientation();
                 audioPacket->writePrimitive(headOrientation);
 
             }else if (nextSoundOutput) {
@@ -356,8 +379,8 @@ void Agent::processAgentAvatarAndAudio(float deltaTime) {
                 audioPacket->writePrimitive((quint8)0);
 
                 // use the orientation and position of this avatar for the source of this audio
-                audioPacket->writePrimitive(_avatarData->getPosition());
-                glm::quat headOrientation = _avatarData->getHeadOrientation();
+                audioPacket->writePrimitive(scriptedAvatar->getPosition());
+                glm::quat headOrientation = scriptedAvatar->getHeadOrientation();
                 audioPacket->writePrimitive(headOrientation);
 
                 // write the raw audio data

assignment-client/src/Agent.h

@@ -68,13 +68,11 @@ private:
     MixedAudioStream _receivedAudioStream;
     float _lastReceivedAudioLoudness;
 
-    void setAvatarData(AvatarData* avatarData, const QString& objectName);
     void setAvatarSound(Sound* avatarSound) { _avatarSound = avatarSound; }
 
     void sendAvatarIdentityPacket();
     void sendAvatarBillboardPacket();
 
-    AvatarData* _avatarData = nullptr;
     bool _isListeningToAudioStream = false;
     Sound* _avatarSound = nullptr;
     int _numAvatarSoundSentBytes = 0;

assignment-client/src/AssignmentClient.cpp

@@ -35,6 +35,7 @@
 #include "AssignmentActionFactory.h"
 
 #include "AssignmentClient.h"
+#include "avatars/ScriptableAvatar.h"
 
 const QString ASSIGNMENT_CLIENT_TARGET_NAME = "assignment-client";
 const long long ASSIGNMENT_REQUEST_INTERVAL_MSECS = 1 * 1000;
@@ -48,6 +49,7 @@ AssignmentClient::AssignmentClient(Assignment::Type requestAssignmentType, QStri
 
     QSettings::setDefaultFormat(QSettings::IniFormat);
  
+    auto scriptableAvatar = DependencyManager::set<ScriptableAvatar>();
     auto addressManager = DependencyManager::set<AddressManager>();
 
     // create a NodeList as an unassigned client, must be after addressManager

assignment-client/src/audio/AudioMixer.cpp

@@ -645,188 +645,187 @@ void AudioMixer::sendStatsPacket() {
 }
 
 void AudioMixer::run() {
-
+    
+    qDebug() << "Waiting for connection to domain to request settings from domain-server.";
+    
+    // wait until we have the domain-server settings, otherwise we bail
+    DomainHandler& domainHandler = DependencyManager::get<NodeList>()->getDomainHandler();
+    connect(&domainHandler, &DomainHandler::settingsReceived, this, &AudioMixer::domainSettingsRequestComplete);
+    connect(&domainHandler, &DomainHandler::settingsReceiveFail, this, &AudioMixer::domainSettingsRequestFailed);
+    
     ThreadedAssignment::commonInit(AUDIO_MIXER_LOGGING_TARGET_NAME, NodeType::AudioMixer);
+}
 
+void AudioMixer::domainSettingsRequestComplete() {
     auto nodeList = DependencyManager::get<NodeList>();
-
+    
     nodeList->addNodeTypeToInterestSet(NodeType::Agent);
-
+    
     nodeList->linkedDataCreateCallback = [](Node* node) {
         node->setLinkedData(std::unique_ptr<AudioMixerClientData> { new AudioMixerClientData });
     };
-
-    // wait until we have the domain-server settings, otherwise we bail
-    DomainHandler& domainHandler = nodeList->getDomainHandler();
-
-    qDebug() << "Waiting for domain settings from domain-server.";
-
-    // block until we get the settingsRequestComplete signal
-    QEventLoop loop;
-    connect(&domainHandler, &DomainHandler::settingsReceived, &loop, &QEventLoop::quit);
-    connect(&domainHandler, &DomainHandler::settingsReceiveFail, &loop, &QEventLoop::quit);
-    domainHandler.requestDomainSettings();
-    loop.exec();
     
-    if (domainHandler.getSettingsObject().isEmpty()) {
-        qDebug() << "Failed to retreive settings object from domain-server. Bailing on assignment.";
-        setFinished(true);
-        return;
-    }
-
+    DomainHandler& domainHandler = nodeList->getDomainHandler();
     const QJsonObject& settingsObject = domainHandler.getSettingsObject();
-
+    
     // check the settings object to see if we have anything we can parse out
     parseSettingsObject(settingsObject);
+    
+    // queue up a connection to start broadcasting mixes now that we're ready to go
+    QMetaObject::invokeMethod(this, "broadcastMixes", Qt::QueuedConnection);
+}
 
+void AudioMixer::broadcastMixes() {
+    auto nodeList = DependencyManager::get<NodeList>(); 
+    
     int nextFrame = 0;
     QElapsedTimer timer;
     timer.start();
-
+    
     int usecToSleep = AudioConstants::NETWORK_FRAME_USECS;
-
+    
     const int TRAILING_AVERAGE_FRAMES = 100;
     int framesSinceCutoffEvent = TRAILING_AVERAGE_FRAMES;
-
+    
     while (!_isFinished) {
         const float STRUGGLE_TRIGGER_SLEEP_PERCENTAGE_THRESHOLD = 0.10f;
         const float BACK_OFF_TRIGGER_SLEEP_PERCENTAGE_THRESHOLD = 0.20f;
-
+        
         const float RATIO_BACK_OFF = 0.02f;
-
+        
         const float CURRENT_FRAME_RATIO = 1.0f / TRAILING_AVERAGE_FRAMES;
         const float PREVIOUS_FRAMES_RATIO = 1.0f - CURRENT_FRAME_RATIO;
-
+        
         if (usecToSleep < 0) {
             usecToSleep = 0;
         }
-
+        
         _trailingSleepRatio = (PREVIOUS_FRAMES_RATIO * _trailingSleepRatio)
             + (usecToSleep * CURRENT_FRAME_RATIO / (float) AudioConstants::NETWORK_FRAME_USECS);
-
+        
         float lastCutoffRatio = _performanceThrottlingRatio;
         bool hasRatioChanged = false;
-
+        
         if (framesSinceCutoffEvent >= TRAILING_AVERAGE_FRAMES) {
             if (_trailingSleepRatio <= STRUGGLE_TRIGGER_SLEEP_PERCENTAGE_THRESHOLD) {
                 // we're struggling - change our min required loudness to reduce some load
                 _performanceThrottlingRatio = _performanceThrottlingRatio + (0.5f * (1.0f - _performanceThrottlingRatio));
-
+                
                 qDebug() << "Mixer is struggling, sleeping" << _trailingSleepRatio * 100 << "% of frame time. Old cutoff was"
                     << lastCutoffRatio << "and is now" << _performanceThrottlingRatio;
                 hasRatioChanged = true;
             } else if (_trailingSleepRatio >= BACK_OFF_TRIGGER_SLEEP_PERCENTAGE_THRESHOLD && _performanceThrottlingRatio != 0) {
                 // we've recovered and can back off the required loudness
                 _performanceThrottlingRatio = _performanceThrottlingRatio - RATIO_BACK_OFF;
-
+                
                 if (_performanceThrottlingRatio < 0) {
                     _performanceThrottlingRatio = 0;
                 }
-
+                
                 qDebug() << "Mixer is recovering, sleeping" << _trailingSleepRatio * 100 << "% of frame time. Old cutoff was"
                     << lastCutoffRatio << "and is now" << _performanceThrottlingRatio;
                 hasRatioChanged = true;
             }
-
+            
             if (hasRatioChanged) {
                 // set out min audability threshold from the new ratio
                 _minAudibilityThreshold = LOUDNESS_TO_DISTANCE_RATIO / (2.0f * (1.0f - _performanceThrottlingRatio));
                 qDebug() << "Minimum audability required to be mixed is now" << _minAudibilityThreshold;
-
+                
                 framesSinceCutoffEvent = 0;
             }
         }
-
+        
         if (!hasRatioChanged) {
             ++framesSinceCutoffEvent;
         }
-
+        
         quint64 now = usecTimestampNow();
         if (now - _lastPerSecondCallbackTime > USECS_PER_SECOND) {
             perSecondActions();
             _lastPerSecondCallbackTime = now;
         }
-
+        
         nodeList->eachNode([&](const SharedNodePointer& node) {
-
+            
             if (node->getLinkedData()) {
                 AudioMixerClientData* nodeData = (AudioMixerClientData*)node->getLinkedData();
-
+                
                 // this function will attempt to pop a frame from each audio stream.
                 // a pointer to the popped data is stored as a member in InboundAudioStream.
                 // That's how the popped audio data will be read for mixing (but only if the pop was successful)
                 nodeData->checkBuffersBeforeFrameSend();
-
+                
                 // if the stream should be muted, send mute packet
                 if (nodeData->getAvatarAudioStream()
                     && shouldMute(nodeData->getAvatarAudioStream()->getQuietestFrameLoudness())) {
                     auto mutePacket = NLPacket::create(PacketType::NoisyMute, 0);
                     nodeList->sendPacket(std::move(mutePacket), *node);
                 }
-
+                
                 if (node->getType() == NodeType::Agent && node->getActiveSocket()
                     && nodeData->getAvatarAudioStream()) {
-
+                    
                     int streamsMixed = prepareMixForListeningNode(node.data());
-
+                    
                     std::unique_ptr<NLPacket> mixPacket;
-
+                    
                     if (streamsMixed > 0) {
                         int mixPacketBytes = sizeof(quint16) + AudioConstants::NETWORK_FRAME_BYTES_STEREO;
                         mixPacket = NLPacket::create(PacketType::MixedAudio, mixPacketBytes);
-
+                        
                         // pack sequence number
                         quint16 sequence = nodeData->getOutgoingSequenceNumber();
                         mixPacket->writePrimitive(sequence);
-
+                        
                         // pack mixed audio samples
                         mixPacket->write(reinterpret_cast<char*>(_mixSamples),
                                          AudioConstants::NETWORK_FRAME_BYTES_STEREO);
                     } else {
                         int silentPacketBytes = sizeof(quint16) + sizeof(quint16);
                         mixPacket = NLPacket::create(PacketType::SilentAudioFrame, silentPacketBytes);
-
+                        
                         // pack sequence number
                         quint16 sequence = nodeData->getOutgoingSequenceNumber();
                         mixPacket->writePrimitive(sequence);
-
+                        
                         // pack number of silent audio samples
                         quint16 numSilentSamples = AudioConstants::NETWORK_FRAME_SAMPLES_STEREO;
                         mixPacket->writePrimitive(numSilentSamples);
                     }
-
+                    
                     // Send audio environment
                     sendAudioEnvironmentPacket(node);
-
+                    
                     // send mixed audio packet
                     nodeList->sendPacket(std::move(mixPacket), *node);
                     nodeData->incrementOutgoingMixedAudioSequenceNumber();
-
+                    
                     // send an audio stream stats packet if it's time
                     if (_sendAudioStreamStats) {
                         nodeData->sendAudioStreamStatsPackets(node);
                         _sendAudioStreamStats = false;
                     }
-
+                    
                     ++_sumListeners;
                 }
             }
         });
-
+        
         ++_numStatFrames;
-
+        
         // since we're a while loop we need to help Qt's event processing
         QCoreApplication::processEvents();
-
+        
         if (_isFinished) {
             // at this point the audio-mixer is done
             // check if we have a deferred delete event to process (which we should once finished)
             QCoreApplication::sendPostedEvents(this, QEvent::DeferredDelete);
             break;
         }
-
+        
         usecToSleep = (++nextFrame * AudioConstants::NETWORK_FRAME_USECS) - timer.nsecsElapsed() / 1000; // ns to us
-
+        
         if (usecToSleep > 0) {
             usleep(usecToSleep);
         }

assignment-client/src/audio/AudioMixer.h

@@ -40,10 +40,13 @@ public slots:
     static const InboundAudioStream::Settings& getStreamSettings() { return _streamSettings; }
 
 private slots:
+    void broadcastMixes();
     void handleNodeAudioPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode);
     void handleMuteEnvironmentPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode);
 
-private:
+private:    
+    void domainSettingsRequestComplete();
+    
     /// adds one stream to the mix for a listening node
     int addStreamToMixForListeningNodeWithStream(AudioMixerClientData* listenerNodeData,
                                                     const QUuid& streamUUID,

assignment-client/src/avatars/AvatarMixer.cpp

@@ -72,7 +72,6 @@ const float BILLBOARD_AND_IDENTITY_SEND_PROBABILITY = 1.0f / 187.0f;
 //    1) use the view frustum to cull those avatars that are out of view. Since avatar data doesn't need to be present
 //       if the avatar is not in view or in the keyhole.
 void AvatarMixer::broadcastAvatarData() {
-
     int idleTime = QDateTime::currentMSecsSinceEpoch() - _lastFrameTimestamp;
 
     ++_numStatFrames;
@@ -514,15 +513,15 @@ void AvatarMixer::sendStatsPacket() {
 }
 
 void AvatarMixer::run() {
+    qDebug() << "Waiting for connection to domain to request settings from domain-server.";
+    
+    // wait until we have the domain-server settings, otherwise we bail
+    DomainHandler& domainHandler = DependencyManager::get<NodeList>()->getDomainHandler();
+    connect(&domainHandler, &DomainHandler::settingsReceived, this, &AvatarMixer::domainSettingsRequestComplete);
+    connect(&domainHandler, &DomainHandler::settingsReceiveFail, this, &AvatarMixer::domainSettingsRequestFailed);
+    
     ThreadedAssignment::commonInit(AVATAR_MIXER_LOGGING_NAME, NodeType::AvatarMixer);
 
-    auto nodeList = DependencyManager::get<NodeList>();
-    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
-
-    nodeList->linkedDataCreateCallback = [] (Node* node) {
-        node->setLinkedData(std::unique_ptr<AvatarMixerClientData> { new AvatarMixerClientData });
-    };
-
     // setup the timer that will be fired on the broadcast thread
     _broadcastTimer = new QTimer;
     _broadcastTimer->setInterval(AVATAR_DATA_SEND_INTERVAL_MSECS);
@@ -531,33 +530,24 @@ void AvatarMixer::run() {
     // connect appropriate signals and slots
     connect(_broadcastTimer, &QTimer::timeout, this, &AvatarMixer::broadcastAvatarData, Qt::DirectConnection);
     connect(&_broadcastThread, SIGNAL(started()), _broadcastTimer, SLOT(start()));
+}
 
-    // wait until we have the domain-server settings, otherwise we bail
-    DomainHandler& domainHandler = nodeList->getDomainHandler();
-
-    qDebug() << "Waiting for domain settings from domain-server.";
-
-    // block until we get the settingsRequestComplete signal
-
-    QEventLoop loop;
-    connect(&domainHandler, &DomainHandler::settingsReceived, &loop, &QEventLoop::quit);
-    connect(&domainHandler, &DomainHandler::settingsReceiveFail, &loop, &QEventLoop::quit);
-    domainHandler.requestDomainSettings();
-    loop.exec();
-
-    if (domainHandler.getSettingsObject().isEmpty()) {
-        qDebug() << "Failed to retreive settings object from domain-server. Bailing on assignment.";
-        setFinished(true);
-        return;
-    }
-
+void AvatarMixer::domainSettingsRequestComplete() {
+    auto nodeList = DependencyManager::get<NodeList>();
+    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
+    
+    nodeList->linkedDataCreateCallback = [] (Node* node) {
+        node->setLinkedData(std::unique_ptr<AvatarMixerClientData> { new AvatarMixerClientData });
+    };
+    
     // parse the settings to pull out the values we need
-    parseDomainServerSettings(domainHandler.getSettingsObject());
-
+    parseDomainServerSettings(nodeList->getDomainHandler().getSettingsObject());
+    
     // start the broadcastThread
     _broadcastThread.start();
 }
 
+
 void AvatarMixer::parseDomainServerSettings(const QJsonObject& domainSettings) {
     const QString AVATAR_MIXER_SETTINGS_KEY = "avatar_mixer";
     const QString NODE_SEND_BANDWIDTH_KEY = "max_node_send_bandwidth";

assignment-client/src/avatars/AvatarMixer.h

@@ -36,6 +36,7 @@ private slots:
     void handleAvatarIdentityPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
     void handleAvatarBillboardPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
     void handleKillAvatarPacket(QSharedPointer<NLPacket> packet);
+    void domainSettingsRequestComplete();
     
 private:
     void broadcastAvatarData();

assignment-client/src/avatars/ScriptableAvatar.cpp

@@ -15,10 +15,6 @@
 
 #include "ScriptableAvatar.h"
 
-ScriptableAvatar::ScriptableAvatar(ScriptEngine* scriptEngine) : _scriptEngine(scriptEngine), _animation(NULL) {
-    connect(_scriptEngine, SIGNAL(update(float)), this, SLOT(update(float)));
-}
-
 // hold and priority unused but kept so that client side JS can run.
 void ScriptableAvatar::startAnimation(const QString& url, float fps, float priority,
                               bool loop, bool hold, float firstFrame, float lastFrame, const QStringList& maskedJoints) {

assignment-client/src/avatars/ScriptableAvatar.h

@@ -16,11 +16,10 @@
 #include <AvatarData.h>
 #include <ScriptEngine.h>
 
-class ScriptableAvatar : public AvatarData {
+class ScriptableAvatar : public AvatarData, public Dependency{
     Q_OBJECT
 public:
-    ScriptableAvatar(ScriptEngine* scriptEngine);
-    
+   
     /// Allows scripts to run animations.
     Q_INVOKABLE void startAnimation(const QString& url, float fps = 30.0f, float priority = 1.0f, bool loop = false,
                                     bool hold = false, float firstFrame = 0.0f, float lastFrame = FLT_MAX, const QStringList& maskedJoints = QStringList());
@@ -31,7 +30,6 @@ private slots:
     void update(float deltatime);
     
 private:
-    ScriptEngine* _scriptEngine;
     AnimationPointer _animation;
     AnimationDetails _animationDetails;
     QStringList _maskedJoints;

assignment-client/src/entities/EntityServer.cpp

@@ -253,7 +253,7 @@ void EntityServer::pruneDeletedEntities() {
     }
 }
 
-bool EntityServer::readAdditionalConfiguration(const QJsonObject& settingsSectionObject) {
+void EntityServer::readAdditionalConfiguration(const QJsonObject& settingsSectionObject) {
     bool wantEditLogging = false;
     readOptionBool(QString("wantEditLogging"), settingsSectionObject, wantEditLogging);
     qDebug("wantEditLogging=%s", debug::valueOf(wantEditLogging));
@@ -265,6 +265,4 @@ bool EntityServer::readAdditionalConfiguration(const QJsonObject& settingsSectio
     EntityTreePointer tree = std::static_pointer_cast<EntityTree>(_tree);
     tree->setWantEditLogging(wantEditLogging);
     tree->setWantTerseEditLogging(wantTerseEditLogging);
-
-    return true;
 }

assignment-client/src/entities/EntityServer.h

@@ -43,7 +43,7 @@ public:
     virtual int sendSpecialPackets(const SharedNodePointer& node, OctreeQueryNode* queryNode, int& packetsSent) override;
 
     virtual void entityCreated(const EntityItem& newEntity, const SharedNodePointer& senderNode) override;
-    virtual bool readAdditionalConfiguration(const QJsonObject& settingsSectionObject) override;
+    virtual void readAdditionalConfiguration(const QJsonObject& settingsSectionObject) override;
 
 public slots:
     void pruneDeletedEntities();

assignment-client/src/messages/MessagesMixer.cpp

@@ -12,30 +12,23 @@
 #include <QtCore/QCoreApplication>
 #include <QtCore/QJsonObject>
 #include <QBuffer>
-
 #include <LogHandler.h>
+#include <MessagesClient.h>
 #include <NodeList.h>
 #include <udt/PacketHeaders.h>
-
 #include "MessagesMixer.h"
 
 const QString MESSAGES_MIXER_LOGGING_NAME = "messages-mixer";
 
-MessagesMixer::MessagesMixer(NLPacket& packet) :
-    ThreadedAssignment(packet)
+MessagesMixer::MessagesMixer(NLPacket& packet) : ThreadedAssignment(packet)
 {
-    // make sure we hear about node kills so we can tell the other nodes
     connect(DependencyManager::get<NodeList>().data(), &NodeList::nodeKilled, this, &MessagesMixer::nodeKilled);
-
     auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
     packetReceiver.registerMessageListener(PacketType::MessagesData, this, "handleMessages");
     packetReceiver.registerMessageListener(PacketType::MessagesSubscribe, this, "handleMessagesSubscribe");
     packetReceiver.registerMessageListener(PacketType::MessagesUnsubscribe, this, "handleMessagesUnsubscribe");
 }
 
-MessagesMixer::~MessagesMixer() {
-}
-
 void MessagesMixer::nodeKilled(SharedNodePointer killedNode) {
     for (auto& channel : _channelSubscribers) {
         channel.remove(killedNode->getUUID());
@@ -43,92 +36,52 @@ void MessagesMixer::nodeKilled(SharedNodePointer killedNode) {
 }
 
 void MessagesMixer::handleMessages(QSharedPointer<NLPacketList> packetList, SharedNodePointer senderNode) {
-    Q_ASSERT(packetList->getType() == PacketType::MessagesData);
+    QString channel, message;
+    QUuid senderID;
+    MessagesClient::decodeMessagesPacket(packetList, channel, message, senderID);
 
-    QByteArray packetData = packetList->getMessage();
-    QBuffer packet{ &packetData };
-    packet.open(QIODevice::ReadOnly);
-
-    quint16 channelLength;
-    packet.read(reinterpret_cast<char*>(&channelLength), sizeof(channelLength));
-    auto channelData = packet.read(channelLength);
-    QString channel = QString::fromUtf8(channelData);
-
-    quint16 messageLength;
-    packet.read(reinterpret_cast<char*>(&messageLength), sizeof(messageLength));
-    auto messageData = packet.read(messageLength);
-    QString message = QString::fromUtf8(messageData);
-    
     auto nodeList = DependencyManager::get<NodeList>();
 
     nodeList->eachMatchingNode(
         [&](const SharedNodePointer& node)->bool {
-
         return node->getType() == NodeType::Agent && node->getActiveSocket() &&
                 _channelSubscribers[channel].contains(node->getUUID());
     },
         [&](const SharedNodePointer& node) {
-
-        auto packetList = NLPacketList::create(PacketType::MessagesData, QByteArray(), true, true);
-
-        auto channelUtf8 = channel.toUtf8();
-        quint16 channelLength = channelUtf8.length();
-        packetList->writePrimitive(channelLength);
-        packetList->write(channelUtf8);
-
-        auto messageUtf8 = message.toUtf8();
-        quint16 messageLength = messageUtf8.length();
-        packetList->writePrimitive(messageLength);
-        packetList->write(messageUtf8);
-
+        auto packetList = MessagesClient::encodeMessagesPacket(channel, message, senderID);
         nodeList->sendPacketList(std::move(packetList), *node);
     });
 }
 
 void MessagesMixer::handleMessagesSubscribe(QSharedPointer<NLPacketList> packetList, SharedNodePointer senderNode) {
-    Q_ASSERT(packetList->getType() == PacketType::MessagesSubscribe);
     QString channel = QString::fromUtf8(packetList->getMessage());
-    qDebug() << "Node [" << senderNode->getUUID() << "] subscribed to channel:" << channel;
     _channelSubscribers[channel] << senderNode->getUUID();
 }
 
 void MessagesMixer::handleMessagesUnsubscribe(QSharedPointer<NLPacketList> packetList, SharedNodePointer senderNode) {
-    Q_ASSERT(packetList->getType() == PacketType::MessagesUnsubscribe);
     QString channel = QString::fromUtf8(packetList->getMessage());
-    qDebug() << "Node [" << senderNode->getUUID() << "] unsubscribed from channel:" << channel;
-
     if (_channelSubscribers.contains(channel)) {
         _channelSubscribers[channel].remove(senderNode->getUUID());
     }
 }
 
-// FIXME - make these stats relevant
 void MessagesMixer::sendStatsPacket() {
-    QJsonObject statsObject;
-    QJsonObject messagesObject;
-    auto nodeList = DependencyManager::get<NodeList>();
+    QJsonObject statsObject, messagesMixerObject;
+
     // add stats for each listerner
-    nodeList->eachNode([&](const SharedNodePointer& node) {
-        QJsonObject messagesStats;
-
-        // add the key to ask the domain-server for a username replacement, if it has it
-        messagesStats[USERNAME_UUID_REPLACEMENT_STATS_KEY] = uuidStringWithoutCurlyBraces(node->getUUID());
-        messagesStats["outbound_kbps"] = node->getOutboundBandwidth();
-        messagesStats["inbound_kbps"] = node->getInboundBandwidth();
-
-        messagesObject[uuidStringWithoutCurlyBraces(node->getUUID())] = messagesStats;
+    DependencyManager::get<NodeList>()->eachNode([&](const SharedNodePointer& node) {
+        QJsonObject clientStats;
+        clientStats[USERNAME_UUID_REPLACEMENT_STATS_KEY] = uuidStringWithoutCurlyBraces(node->getUUID());
+        clientStats["outbound_kbps"] = node->getOutboundBandwidth();
+        clientStats["inbound_kbps"] = node->getInboundBandwidth();
+        messagesMixerObject[uuidStringWithoutCurlyBraces(node->getUUID())] = clientStats;
     });
 
-    statsObject["messages"] = messagesObject;
+    statsObject["messages"] = messagesMixerObject;
     ThreadedAssignment::addPacketStatsAndSendStatsPacket(statsObject);
 }
 
 void MessagesMixer::run() {
     ThreadedAssignment::commonInit(MESSAGES_MIXER_LOGGING_NAME, NodeType::MessagesMixer);
-
-    auto nodeList = DependencyManager::get<NodeList>();
-    nodeList->addNodeTypeToInterestSet(NodeType::Agent);
-    
-    // The messages-mixer currently does currently have any domain settings. If it did, they would be
-    // synchronously grabbed here.
-}
+    DependencyManager::get<NodeList>()->addNodeTypeToInterestSet(NodeType::Agent);
+}

assignment-client/src/messages/MessagesMixer.h

@@ -22,7 +22,6 @@ class MessagesMixer : public ThreadedAssignment {
     Q_OBJECT
 public:
     MessagesMixer(NLPacket& packet);
-    ~MessagesMixer();
 
 public slots:
     void run();

assignment-client/src/octree/OctreeServer.cpp

@@ -317,6 +317,7 @@ bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url
 #endif
 
     bool showStats = false;
+    QString persistFile = "/" + getPersistFilename();
 
     if (connection->requestOperation() == QNetworkAccessManager::GetOperation) {
         if (url.path() == "/") {
@@ -326,6 +327,18 @@ bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url
             _tree->resetEditStats();
             resetSendingStats();
             showStats = true;
+        } else if ((url.path() == persistFile) || (url.path() == persistFile + "/")) {
+            if (_persistFileDownload) {
+                QByteArray persistFileContents = getPersistFileContents();
+                if (persistFileContents.length() > 0) {
+                    connection->respond(HTTPConnection::StatusCode200, persistFileContents, qPrintable(getPersistFileMimeType()));
+                } else {
+                    connection->respond(HTTPConnection::StatusCode500, HTTPConnection::StatusCode500);
+                }
+            } else {
+                connection->respond(HTTPConnection::StatusCode403, HTTPConnection::StatusCode403); // not allowed
+            }
+            return true;
         }
     }
 
@@ -367,6 +380,12 @@ bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url
             statsString += getFileLoadTime();
             statsString += "\r\n";
 
+            if (_persistFileDownload) {
+                statsString += QString("Persist file: <a href='%1'>%1</a>\r\n").arg(persistFile);
+            } else {
+                statsString += QString("Persist file: %1\r\n").arg(persistFile);
+            }
+
         } else {
             statsString += "Octree file not yet loaded...\r\n";
         }
@@ -932,31 +951,14 @@ bool OctreeServer::readOptionString(const QString& optionName, const QJsonObject
     return optionAvailable;
 }
 
-bool OctreeServer::readConfiguration() {
+void OctreeServer::readConfiguration() {
     // if the assignment had a payload, read and parse that
     if (getPayload().size() > 0) {
         parsePayload();
     }
+    
+    const QJsonObject& settingsObject = DependencyManager::get<NodeList>()->getDomainHandler().getSettingsObject();
 
-    // wait until we have the domain-server settings, otherwise we bail
-    auto nodeList = DependencyManager::get<NodeList>();
-    DomainHandler& domainHandler = nodeList->getDomainHandler();
-
-    qDebug() << "Waiting for domain settings from domain-server.";
-
-    // block until we get the settingsRequestComplete signal
-    QEventLoop loop;
-    connect(&domainHandler, &DomainHandler::settingsReceived, &loop, &QEventLoop::quit);
-    connect(&domainHandler, &DomainHandler::settingsReceiveFail, &loop, &QEventLoop::quit);
-    domainHandler.requestDomainSettings();
-    loop.exec();
-
-    if (domainHandler.getSettingsObject().isEmpty()) {
-        qDebug() << "Failed to retreive settings object from domain-server. Bailing on assignment.";
-        return false;
-    }
-
-    const QJsonObject& settingsObject = domainHandler.getSettingsObject();
     QString settingsKey = getMyDomainSettingsKey();
     QJsonObject settingsSectionObject = settingsObject[settingsKey].toObject();
     _settings = settingsSectionObject; // keep this for later
@@ -1026,7 +1028,8 @@ bool OctreeServer::readConfiguration() {
         _wantBackup = !noBackup;
         qDebug() << "wantBackup=" << _wantBackup;
 
-        //qDebug() << "settingsSectionObject:" << settingsSectionObject;
+        readOptionBool(QString("persistFileDownload"), settingsSectionObject, _persistFileDownload);
+        qDebug() << "persistFileDownload=" << _persistFileDownload;
 
     } else {
         qDebug("persistFilename= DISABLED");
@@ -1064,79 +1067,79 @@ bool OctreeServer::readConfiguration() {
                     packetsPerSecondTotalMax, _packetsTotalPerInterval);
 
 
-    return readAdditionalConfiguration(settingsSectionObject);
+    readAdditionalConfiguration(settingsSectionObject);
 }
 
 void OctreeServer::run() {
-
-    auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
-    packetReceiver.registerListener(getMyQueryMessageType(), this, "handleOctreeQueryPacket");
-    packetReceiver.registerListener(PacketType::OctreeDataNack, this, "handleOctreeDataNackPacket");
-    packetReceiver.registerListener(PacketType::JurisdictionRequest, this, "handleJurisdictionRequestPacket");
-    
     _safeServerName = getMyServerName();
 
     // Before we do anything else, create our tree...
     OctreeElement::resetPopulationStatistics();
     _tree = createTree();
     _tree->setIsServer(true);
-
-    // make sure our NodeList knows what type we are
-    auto nodeList = DependencyManager::get<NodeList>();
-    nodeList->setOwnerType(getMyNodeType());
+    
+    qDebug() << "Waiting for connection to domain to request settings from domain-server.";
+    
+    // wait until we have the domain-server settings, otherwise we bail
+    DomainHandler& domainHandler = DependencyManager::get<NodeList>()->getDomainHandler();
+    connect(&domainHandler, &DomainHandler::settingsReceived, this, &OctreeServer::domainSettingsRequestComplete);
+    connect(&domainHandler, &DomainHandler::settingsReceiveFail, this, &OctreeServer::domainSettingsRequestFailed);
 
     // use common init to setup common timers and logging
     commonInit(getMyLoggingServerTargetName(), getMyNodeType());
+}
+
+void OctreeServer::domainSettingsRequestComplete() {
+    
+    auto nodeList = DependencyManager::get<NodeList>();
     
     // we need to ask the DS about agents so we can ping/reply with them
     nodeList->addNodeTypeToInterestSet(NodeType::Agent);
-
-    // read the configuration from either the payload or the domain server configuration
-    if (!readConfiguration()) {
-        qDebug() << "OctreeServer bailing on run since readConfiguration has failed.";
-        setFinished(true);
-        return; // bailing on run, because readConfiguration failed
-    }
-
+    
+    auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
+    packetReceiver.registerListener(getMyQueryMessageType(), this, "handleOctreeQueryPacket");
+    packetReceiver.registerListener(PacketType::OctreeDataNack, this, "handleOctreeDataNackPacket");
+    packetReceiver.registerListener(PacketType::JurisdictionRequest, this, "handleJurisdictionRequestPacket");
+    
+    readConfiguration();
+    
     beforeRun(); // after payload has been processed
-
+    
     connect(nodeList.data(), SIGNAL(nodeAdded(SharedNodePointer)), SLOT(nodeAdded(SharedNodePointer)));
     connect(nodeList.data(), SIGNAL(nodeKilled(SharedNodePointer)), SLOT(nodeKilled(SharedNodePointer)));
 
 #ifndef WIN32
     setvbuf(stdout, NULL, _IOLBF, 0);
 #endif
-
+    
     nodeList->linkedDataCreateCallback = [] (Node* node) {
         auto queryNodeData = _instance->createOctreeQueryNode();
         queryNodeData->init();
         node->setLinkedData(std::move(queryNodeData));
     };
-
+    
     srand((unsigned)time(0));
-
+    
     // if we want Persistence, set up the local file and persist thread
     if (_wantPersist) {
-
+        
         // now set up PersistThread
         _persistThread = new OctreePersistThread(_tree, _persistFilename, _persistInterval,
                                                  _wantBackup, _settings, _debugTimestampNow, _persistAsFileType);
         _persistThread->initialize(true);
     }
-
-    HifiSockAddr senderSockAddr;
-
+    
     // set up our jurisdiction broadcaster...
     if (_jurisdiction) {
         _jurisdiction->setNodeType(getMyNodeType());
     }
     _jurisdictionSender = new JurisdictionSender(_jurisdiction, getMyNodeType());
     _jurisdictionSender->initialize(true);
-
+    
     // set up our OctreeServerPacketProcessor
     _octreeInboundPacketProcessor = new OctreeInboundPacketProcessor(this);
     _octreeInboundPacketProcessor->initialize(true);
-
+    
     // Convert now to tm struct for local timezone
     tm* localtm = localtime(&_started);
     const int MAX_TIME_LENGTH = 128;
@@ -1148,6 +1151,7 @@ void OctreeServer::run() {
     if (gmtm) {
         strftime(utcBuffer, MAX_TIME_LENGTH, " [%m/%d/%Y %X UTC]", gmtm);
     }
+    
     qDebug() << "Now running... started at: " << localBuffer << utcBuffer;
 }
 

assignment-client/src/octree/OctreeServer.h

@@ -61,6 +61,9 @@ public:
     bool isInitialLoadComplete() const { return (_persistThread) ? _persistThread->isInitialLoadComplete() : true; }
     bool isPersistEnabled() const { return (_persistThread) ? true : false; }
     quint64 getLoadElapsedTime() const { return (_persistThread) ? _persistThread->getLoadElapsedTime() : 0; }
+    QString getPersistFilename() const { return (_persistThread) ? _persistThread->getPersistFilename() : ""; }
+    QString getPersistFileMimeType() const { return (_persistThread) ? _persistThread->getPersistFileMimeType() : "text/plain"; }
+    QByteArray getPersistFileContents() const { return (_persistThread) ? _persistThread->getPersistFileContents() : QByteArray(); }
 
     // Subclasses must implement these methods
     virtual std::unique_ptr<OctreeQueryNode> createOctreeQueryNode() = 0;
@@ -128,6 +131,7 @@ public slots:
     void sendStatsPacket();
 
 private slots:
+    void domainSettingsRequestComplete();
     void handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
     void handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
     void handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
@@ -137,8 +141,8 @@ protected:
     bool readOptionBool(const QString& optionName, const QJsonObject& settingsSectionObject, bool& result);
     bool readOptionInt(const QString& optionName, const QJsonObject& settingsSectionObject, int& result);
     bool readOptionString(const QString& optionName, const QJsonObject& settingsSectionObject, QString& result);
-    bool readConfiguration();
-    virtual bool readAdditionalConfiguration(const QJsonObject& settingsSectionObject) { return true;  };
+    void readConfiguration();
+    virtual void readAdditionalConfiguration(const QJsonObject& settingsSectionObject) { };
     void parsePayload();
     void initHTTPManager(int port);
     void resetSendingStats();
@@ -175,6 +179,7 @@ protected:
 
     int _persistInterval;
     bool _wantBackup;
+    bool _persistFileDownload;
     QString _backupExtensionFormat;
     int _backupInterval;
     int _maxBackupVersions;

domain-server/resources/describe-settings.json

@@ -476,6 +476,14 @@
           "default": "",
           "advanced": true
         },
+        {
+          "name": "persistFileDownload",
+          "type": "checkbox",
+          "label": "Persist File Download",
+          "help": "Includes a download link to the persist file in the server status page.",
+          "default": false,
+          "advanced": true
+        },
         {
           "name": "wantEditLogging",
           "type": "checkbox",

domain-server/src/DomainServer.cpp

@@ -1837,14 +1837,25 @@ void DomainServer::processNodeDisconnectRequestPacket(QSharedPointer<NLPacket> p
     
     qDebug() << "Received a disconnect request from node with UUID" << nodeUUID;
     
-    if (limitedNodeList->killNodeWithUUID(nodeUUID)) {        
+    // we want to check what type this node was before going to kill it so that we can avoid sending the RemovedNode
+    // packet to nodes that don't care about this type
+    auto nodeToKill = limitedNodeList->nodeWithUUID(nodeUUID);
+    
+    if (nodeToKill) {
+        auto nodeType = nodeToKill->getType();
+        limitedNodeList->killNodeWithUUID(nodeUUID);
+        
         static auto removedNodePacket = NLPacket::create(PacketType::DomainServerRemovedNode, NUM_BYTES_RFC4122_UUID);
         
         removedNodePacket->reset();
         removedNodePacket->write(nodeUUID.toRfc4122());
     
         // broadcast out the DomainServerRemovedNode message
-        limitedNodeList->eachNode([&limitedNodeList](const SharedNodePointer& otherNode){
+        limitedNodeList->eachMatchingNode([&nodeType](const SharedNodePointer& otherNode) -> bool {
+            // only send the removed node packet to nodes that care about the type of node this was
+            auto nodeLinkedData = dynamic_cast<DomainServerNodeData*>(otherNode->getLinkedData());
+            return (nodeLinkedData != nullptr) && nodeLinkedData->getNodeInterestSet().contains(nodeType);
+        }, [&limitedNodeList](const SharedNodePointer& otherNode){
             limitedNodeList->sendUnreliablePacket(*removedNodePacket, *otherNode);
         });
     }

examples/acScripts/playbackAgents.js

@@ -0,0 +1,155 @@
+//
+//  playbackAgents.js
+//  acScripts
+//
+//  Created by Edgar Pironti on 11/17/15.
+//  Copyright 2015 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
+//
+
+// Set the following variables to the values needed
+var channel = "PlaybackChannel1";
+var clip_url = null;
+var playFromCurrentLocation = true;
+var useDisplayName = true;
+var useAttachments = true;
+var useAvatarModel = true;
+
+// ID of the agent. Two agents can't have the same ID.
+var id = 0;
+
+// Set position/orientation/scale here if playFromCurrentLocation is true
+Avatar.position = { x:0, y: 0, z: 0 };
+Avatar.orientation = Quat.fromPitchYawRollDegrees(0, 0, 0);
+Avatar.scale = 1.0;
+
+var totalTime = 0;
+var subscribed = false;
+var WAIT_FOR_AUDIO_MIXER = 1;
+
+// Script. DO NOT MODIFY BEYOND THIS LINE.
+var DO_NOTHING = 0;
+var PLAY = 1;
+var PLAY_LOOP = 2;
+var STOP = 3;
+var SHOW = 4;
+var HIDE = 5;
+var LOAD = 6;
+
+Recording.setPlayFromCurrentLocation(playFromCurrentLocation);
+Recording.setPlayerUseDisplayName(useDisplayName);
+Recording.setPlayerUseAttachments(useAttachments);
+Recording.setPlayerUseHeadModel(false);
+Recording.setPlayerUseSkeletonModel(useAvatarModel);
+
+function getAction(channel, message, senderID) {    
+
+    if(subscribed) {
+        var command = JSON.parse(message);
+        print("I'm the agent " + id + " and I received this: ID: " + command.id_key + " Action: " + command.action_key + " URL: " + command.clip_url_key);
+        
+        if (command.id_key == id || command.id_key == -1) {
+            if (command.action_key === 6) {
+                clip_url = command.clip_url_key;
+                
+                // If the id is -1 (broadcast) and the action is 6, in the url should be the performance file
+                // with all the clips recorded in a session (not just the single clip url).
+                // It has to be computed here in order to retrieve the url for the single agent. 
+                // Checking the id we can assign the correct url to the correct agent.
+                
+                if (command.id_key == -1) {
+                    Assets.downloadData(clip_url, function (data) {
+                        var myJSONObject = JSON.parse(data);
+                        var hash = myJSONObject.results[id].hashATP;
+                    });
+                    
+                    Assets.downloadData(hash, function (data) {
+                        clip_url = JSON.parse(data);
+                    });
+                }
+            }
+            
+            action = command.action_key;
+            print("That command was for me!");
+            print("My clip is: " + clip_url);
+        } else {
+            action = DO_NOTHING;
+        } 
+        
+        switch(action) {
+        case PLAY:
+            print("Play");
+            if (!Agent.isAvatar) {
+                Agent.isAvatar = true;
+            }
+            if (!Recording.isPlaying()) {
+                Recording.startPlaying();
+            }
+            Recording.setPlayerLoop(false);
+            break;
+        case PLAY_LOOP:
+            print("Play loop");
+            if (!Agent.isAvatar) {
+                Agent.isAvatar = true;
+            }
+            if (!Recording.isPlaying()) {
+                Recording.startPlaying();
+            }
+            Recording.setPlayerLoop(true);
+            break;
+        case STOP:
+            print("Stop");
+            if (Recording.isPlaying()) {
+                Recording.stopPlaying();
+            }
+            break;
+        case SHOW:
+            print("Show");
+            if (!Agent.isAvatar) {
+                Agent.isAvatar = true;
+            }
+            break;
+        case HIDE:
+            print("Hide");
+            if (Recording.isPlaying()) {
+                Recording.stopPlaying();
+            }
+            Agent.isAvatar = false;
+            break;
+        case LOAD:
+            print("Load");            
+            if(clip_url !== null) {
+                Recording.loadRecording(clip_url);
+            }
+            break;
+        case DO_NOTHING:
+            break;
+        default:
+            print("Unknown action: " + action);
+            break;
+
+        }
+
+        if (Recording.isPlaying()) {
+            Recording.play();
+        }  
+    }
+}
+
+
+function update(deltaTime) {   
+
+    totalTime += deltaTime;
+
+    if (totalTime > WAIT_FOR_AUDIO_MIXER && !subscribed) {
+        Messages.subscribe(channel);
+        subscribed = true;
+        print("I'm the agent and I am ready to receive!")
+    }
+}
+
+Script.update.connect(update);
+Messages.messageReceived.connect(getAction);
+

examples/acScripts/playbackMaster.js

@@ -0,0 +1,260 @@
+//
+//  playbackMaster.js
+//  acScripts
+//
+//  Created by Edgar Pironti on 11/17/15.
+//  Copyright 2015 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
+//
+
+HIFI_PUBLIC_BUCKET = "http://s3.amazonaws.com/hifi-public/";
+
+
+var ac_number = 1; // This is the default number of ACs. Their ID need to be unique and between 0 (included) and ac_number (excluded)
+var names = new Array();  // It is possible to specify the name of the ACs in this array. ACs names ordered by IDs (Default name is "ACx", x = ID + 1))
+var channel = "PlaybackChannel1";
+var subscribed = false;
+var clip_url = null;
+var input_text = null;
+
+// Script. DO NOT MODIFY BEYOND THIS LINE.
+Script.include("../libraries/toolBars.js");
+
+var DO_NOTHING = 0;
+var PLAY = 1;
+var PLAY_LOOP = 2;
+var STOP = 3;
+var SHOW = 4;
+var HIDE = 5;
+var LOAD = 6;
+
+var windowDimensions = Controller.getViewportDimensions();
+var TOOL_ICON_URL = HIFI_PUBLIC_BUCKET + "images/tools/";
+var ALPHA_ON = 1.0;
+var ALPHA_OFF = 0.7;
+var COLOR_TOOL_BAR = { red: 0, green: 0, blue: 0 };
+var COLOR_MASTER = { red: 0, green: 0, blue: 0 };
+var TEXT_HEIGHT = 12;
+var TEXT_MARGIN = 3;
+
+var toolBars = new Array();
+var nameOverlays = new Array();
+var onOffIcon = new Array();
+var playIcon = new Array();
+var playLoopIcon = new Array();
+var stopIcon = new Array();
+var loadIcon = new Array();
+
+setupPlayback();
+
+function setupPlayback() {
+    ac_number = Window.prompt("Insert number of agents: ","1");
+    if (ac_number === "" || ac_number === null)
+        ac_number = 1;
+    Messages.subscribe(channel);
+    subscribed = true;
+    setupToolBars();
+}
+
+function setupToolBars() {      
+    if (toolBars.length > 0) {
+        print("Multiple calls to Recorder.js:setupToolBars()");
+        return;
+    }
+    Tool.IMAGE_HEIGHT /= 2;
+    Tool.IMAGE_WIDTH /= 2;
+    
+    for (i = 0; i <= ac_number; i++) {
+        toolBars.push(new ToolBar(0, 0, ToolBar.HORIZONTAL));
+        toolBars[i].setBack((i == ac_number) ? COLOR_MASTER : COLOR_TOOL_BAR, ALPHA_OFF);
+        
+        onOffIcon.push(toolBars[i].addTool({
+                                           imageURL: TOOL_ICON_URL + "ac-on-off.svg",
+                                           subImage: { x: 0, y: 0, width: Tool.IMAGE_WIDTH, height: Tool.IMAGE_HEIGHT },
+                                           x: 0, y: 0,
+                                           width: Tool.IMAGE_WIDTH,
+                                           height: Tool.IMAGE_HEIGHT,
+                                           alpha: ALPHA_ON,
+                                           visible: true
+                                           }, true, true));
+        
+        playIcon[i] = toolBars[i].addTool({
+                                          imageURL: TOOL_ICON_URL + "play.svg",
+                                          subImage: { x: 0, y: 0, width: Tool.IMAGE_WIDTH, height: Tool.IMAGE_HEIGHT },
+                                          width: Tool.IMAGE_WIDTH,
+                                          height: Tool.IMAGE_HEIGHT,
+                                          alpha: ALPHA_OFF,
+                                          visible: true
+                                          }, false);
+        
+        var playLoopWidthFactor = 1.65;
+        playLoopIcon[i] = toolBars[i].addTool({
+                                              imageURL: TOOL_ICON_URL + "play-and-loop.svg",
+                                              subImage: { x: 0, y: 0, width: playLoopWidthFactor * Tool.IMAGE_WIDTH, height: Tool.IMAGE_HEIGHT },
+                                              width: playLoopWidthFactor * Tool.IMAGE_WIDTH,
+                                              height: Tool.IMAGE_HEIGHT,
+                                              alpha: ALPHA_OFF,
+                                              visible: true
+                                              }, false);
+        
+        stopIcon[i] = toolBars[i].addTool({
+                                          imageURL: TOOL_ICON_URL + "recording-stop.svg",
+                                          width: Tool.IMAGE_WIDTH,
+                                          height: Tool.IMAGE_HEIGHT,
+                                          alpha: ALPHA_OFF,
+                                          visible: true
+                                          }, false);
+                                          
+        loadIcon[i] = toolBars[i].addTool({
+                                          imageURL: TOOL_ICON_URL + "recording-upload.svg",
+                                          width: Tool.IMAGE_WIDTH,
+                                          height: Tool.IMAGE_HEIGHT,
+                                          alpha: ALPHA_OFF,
+                                          visible: true
+                                          }, false);
+        
+        nameOverlays.push(Overlays.addOverlay("text", {
+                                              backgroundColor: { red: 0, green: 0, blue: 0 },
+                                              font: { size: TEXT_HEIGHT },
+                                              text: (i == ac_number) ? "Master" : i + ". " +
+                                              ((i < names.length) ? names[i] :
+                                               "AC" + i),
+                                              x: 0, y: 0,
+                                              width: toolBars[i].width + ToolBar.SPACING,
+                                              height: TEXT_HEIGHT + TEXT_MARGIN,
+                                              leftMargin: TEXT_MARGIN,
+                                              topMargin: TEXT_MARGIN,
+                                              alpha: ALPHA_OFF,
+                                              backgroundAlpha: ALPHA_OFF,
+                                              visible: true
+                                              }));
+    }
+}
+
+function sendCommand(id, action) {
+    
+    if (action === SHOW) {
+        toolBars[id].selectTool(onOffIcon[id], false);
+        toolBars[id].setAlpha(ALPHA_ON, playIcon[id]);
+        toolBars[id].setAlpha(ALPHA_ON, playLoopIcon[id]);
+        toolBars[id].setAlpha(ALPHA_ON, stopIcon[id]);
+        toolBars[id].setAlpha(ALPHA_ON, loadIcon[id]);
+    } else if (action === HIDE) {
+        toolBars[id].selectTool(onOffIcon[id], true);
+        toolBars[id].setAlpha(ALPHA_OFF, playIcon[id]);
+        toolBars[id].setAlpha(ALPHA_OFF, playLoopIcon[id]);
+        toolBars[id].setAlpha(ALPHA_OFF, stopIcon[id]);
+        toolBars[id].setAlpha(ALPHA_OFF, loadIcon[id]);
+    } else if (toolBars[id].toolSelected(onOffIcon[id])) {
+        return;
+    }
+    
+    if (id == (toolBars.length - 1))
+        id = -1; // Master command becomes broadcast.
+    
+    var message = {
+        id_key: id,
+        action_key: action,
+        clip_url_key: clip_url
+    };
+    
+    if(subscribed){
+        Messages.sendMessage(channel, JSON.stringify(message));
+        print("Message sent!");
+        clip_url = null;
+    }
+}
+
+function mousePressEvent(event) {
+    clickedOverlay = Overlays.getOverlayAtPoint({ x: event.x, y: event.y });
+    
+    // Check master control
+    var i = toolBars.length - 1;
+    if (onOffIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+        if (toolBars[i].toolSelected(onOffIcon[i])) {
+            sendCommand(i, SHOW);
+        } else {
+            sendCommand(i, HIDE);
+        }
+    } else if (playIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+        sendCommand(i, PLAY);
+    } else if (playLoopIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+        sendCommand(i, PLAY_LOOP);
+    } else if (stopIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+        sendCommand(i, STOP);
+    } else if (loadIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+        input_text = Window.prompt("Insert the url of the clip: ","");
+        if (!(input_text === "" || input_text === null)) {
+            clip_url = input_text;
+            sendCommand(i, LOAD);
+        }
+    } else {
+        // Check individual controls
+        for (i = 0; i < ac_number; i++) {
+            if (onOffIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+                if (toolBars[i].toolSelected(onOffIcon[i], false)) {
+                    sendCommand(i, SHOW);
+                } else {
+                    sendCommand(i, HIDE);
+                }
+            } else if (playIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+                sendCommand(i, PLAY);
+            } else if (playLoopIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+                sendCommand(i, PLAY_LOOP);
+            } else if (stopIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {
+                sendCommand(i, STOP);
+            } else if (loadIcon[i] === toolBars[i].clicked(clickedOverlay, false)) {                
+                input_text = Window.prompt("Insert the url of the clip: ","");
+                if (!(input_text === "" || input_text === null)) {
+                    clip_url = input_text;
+                    sendCommand(i, LOAD);
+                }                
+            } else {
+                
+            }
+        }
+    }
+}
+
+function moveUI() {
+    var textSize = TEXT_HEIGHT + 2 * TEXT_MARGIN;
+    var relative = { x: 70, y: 75 + (ac_number) * (Tool.IMAGE_HEIGHT + ToolBar.SPACING + textSize) };
+    
+    for (i = 0; i <= ac_number; i++) {
+        toolBars[i].move(relative.x,
+                         windowDimensions.y - relative.y +
+                         i * (Tool.IMAGE_HEIGHT + ToolBar.SPACING + textSize));
+        
+        Overlays.editOverlay(nameOverlays[i], {
+                             x: toolBars[i].x - ToolBar.SPACING,
+                             y: toolBars[i].y - textSize
+                             });
+    }
+}
+
+function update() {
+    var newDimensions = Controller.getViewportDimensions();
+    if (windowDimensions.x != newDimensions.x ||
+            windowDimensions.y != newDimensions.y) {
+        windowDimensions = newDimensions;
+        moveUI();
+    }
+}
+
+function scriptEnding() {
+    for (i = 0; i <= ac_number; i++) {
+        toolBars[i].cleanup();
+        Overlays.deleteOverlay(nameOverlays[i]);
+    }
+    
+    if(subscribed)
+        Messages.unsubscribe(channel);
+}
+
+Controller.mousePressEvent.connect(mousePressEvent);
+Script.update.connect(update);
+Script.scriptEnding.connect(scriptEnding);
+
+moveUI();

examples/controllers/handControllerGrab.js

@@ -37,9 +37,21 @@ var BUMPER_ON_VALUE = 0.5;
 var DISTANCE_HOLDING_RADIUS_FACTOR = 5; // multiplied by distance between hand and object
 var DISTANCE_HOLDING_ACTION_TIMEFRAME = 0.1; // how quickly objects move to their new position
 var DISTANCE_HOLDING_ROTATION_EXAGGERATION_FACTOR = 2.0; // object rotates this much more than hand did
-var NO_INTERSECT_COLOR = { red: 10, green: 10, blue: 255}; // line color when pick misses
-var INTERSECT_COLOR = { red: 250, green: 10, blue: 10}; // line color when pick hits
-var LINE_ENTITY_DIMENSIONS = { x: 1000, y: 1000,z: 1000};
+var NO_INTERSECT_COLOR = {
+    red: 10,
+    green: 10,
+    blue: 255
+}; // line color when pick misses
+var INTERSECT_COLOR = {
+    red: 250,
+    green: 10,
+    blue: 10
+}; // line color when pick hits
+var LINE_ENTITY_DIMENSIONS = {
+    x: 1000,
+    y: 1000,
+    z: 1000
+};
 var LINE_LENGTH = 500;
 var PICK_MAX_DISTANCE = 500; // max length of pick-ray
 
@@ -84,12 +96,13 @@ var ACTION_TTL_REFRESH = 5;
 var PICKS_PER_SECOND_PER_HAND = 5;
 var MSECS_PER_SEC = 1000.0;
 var GRABBABLE_PROPERTIES = ["position",
-                            "rotation",
-                            "gravity",
-                            "ignoreForCollisions",
-                            "collisionsWillMove",
-                            "locked",
-                            "name"];
+    "rotation",
+    "gravity",
+    "ignoreForCollisions",
+    "collisionsWillMove",
+    "locked",
+    "name"
+];
 
 
 var GRABBABLE_DATA_KEY = "grabbableKey"; // shared with grab.js
@@ -100,7 +113,7 @@ var DEFAULT_GRABBABLE_DATA = {
     invertSolidWhileHeld: false
 };
 
-var disabledHand ='none';
+var disabledHand = 'none';
 
 
 // states for the state machine
@@ -125,40 +138,40 @@ var STATE_EQUIP_SPRING = 16;
 
 function stateToName(state) {
     switch (state) {
-    case STATE_OFF:
-        return "off";
-    case STATE_SEARCHING:
-        return "searching";
-    case STATE_DISTANCE_HOLDING:
-        return "distance_holding";
-    case STATE_CONTINUE_DISTANCE_HOLDING:
-        return "continue_distance_holding";
-    case STATE_NEAR_GRABBING:
-        return "near_grabbing";
-    case STATE_CONTINUE_NEAR_GRABBING:
-        return "continue_near_grabbing";
-    case STATE_NEAR_TRIGGER:
-        return "near_trigger";
-    case STATE_CONTINUE_NEAR_TRIGGER:
-        return "continue_near_trigger";
-    case STATE_FAR_TRIGGER:
-        return "far_trigger";
-    case STATE_CONTINUE_FAR_TRIGGER:
-        return "continue_far_trigger";
-    case STATE_RELEASE:
-        return "release";
-    case STATE_EQUIP_SEARCHING:
-        return "equip_searching";
-    case STATE_EQUIP:
-        return "equip";
-    case STATE_CONTINUE_EQUIP_BD:
-        return "continue_equip_bd";
-    case STATE_CONTINUE_EQUIP:
-        return "continue_equip";
-    case STATE_WAITING_FOR_BUMPER_RELEASE:
-        return "waiting_for_bumper_release";
-    case STATE_EQUIP_SPRING:
-        return "state_equip_spring";
+        case STATE_OFF:
+            return "off";
+        case STATE_SEARCHING:
+            return "searching";
+        case STATE_DISTANCE_HOLDING:
+            return "distance_holding";
+        case STATE_CONTINUE_DISTANCE_HOLDING:
+            return "continue_distance_holding";
+        case STATE_NEAR_GRABBING:
+            return "near_grabbing";
+        case STATE_CONTINUE_NEAR_GRABBING:
+            return "continue_near_grabbing";
+        case STATE_NEAR_TRIGGER:
+            return "near_trigger";
+        case STATE_CONTINUE_NEAR_TRIGGER:
+            return "continue_near_trigger";
+        case STATE_FAR_TRIGGER:
+            return "far_trigger";
+        case STATE_CONTINUE_FAR_TRIGGER:
+            return "continue_far_trigger";
+        case STATE_RELEASE:
+            return "release";
+        case STATE_EQUIP_SEARCHING:
+            return "equip_searching";
+        case STATE_EQUIP:
+            return "equip";
+        case STATE_CONTINUE_EQUIP_BD:
+            return "continue_equip_bd";
+        case STATE_CONTINUE_EQUIP:
+            return "continue_equip";
+        case STATE_WAITING_FOR_BUMPER_RELEASE:
+            return "waiting_for_bumper_release";
+        case STATE_EQUIP_SPRING:
+            return "state_equip_spring";
     }
 
     return "unknown";
@@ -187,7 +200,6 @@ function entityIsGrabbedByOther(entityID) {
     return false;
 }
 
-
 function MyController(hand) {
     this.hand = hand;
     if (this.hand === RIGHT_HAND) {
@@ -211,8 +223,17 @@ function MyController(hand) {
     this.rawTriggerValue = 0;
     this.rawBumperValue = 0;
 
-    this.offsetPosition = { x: 0.0, y: 0.0, z: 0.0 };
-    this.offsetRotation = { x: 0.0, y: 0.0, z: 0.0, w: 1.0 };
+    this.offsetPosition = {
+        x: 0.0,
+        y: 0.0,
+        z: 0.0
+    };
+    this.offsetRotation = {
+        x: 0.0,
+        y: 0.0,
+        z: 0.0,
+        w: 1.0
+    };
 
     var _this = this;
 
@@ -277,7 +298,7 @@ function MyController(hand) {
         this.state = newState;
     }
 
-    this.debugLine = function(closePoint, farPoint, color){
+    this.debugLine = function(closePoint, farPoint, color) {
         Entities.addEntity({
             type: "Line",
             name: "Grab Debug Entity",
@@ -321,16 +342,16 @@ function MyController(hand) {
         this.pointer = null;
     };
 
-    this.triggerPress = function (value) {
+    this.triggerPress = function(value) {
         _this.rawTriggerValue = value;
     };
 
-    this.bumperPress = function (value) {
+    this.bumperPress = function(value) {
         _this.rawBumperValue = value;
     };
 
 
-    this.updateSmoothedTrigger = function () {
+    this.updateSmoothedTrigger = function() {
         var triggerValue = this.rawTriggerValue;
         // smooth out trigger value
         this.triggerValue = (this.triggerValue * TRIGGER_SMOOTH_RATIO) +
@@ -401,7 +422,7 @@ function MyController(hand) {
             this.lastPickTime = now;
         }
 
-        for (var index=0; index < pickRays.length; ++index) {
+        for (var index = 0; index < pickRays.length; ++index) {
             var pickRay = pickRays[index];
             var directionNormalized = Vec3.normalize(pickRay.direction);
             var directionBacked = Vec3.multiply(directionNormalized, PICK_BACKOFF_DISTANCE);
@@ -466,10 +487,9 @@ function MyController(hand) {
                         }
                         return;
                     }
-                } else if (! entityIsGrabbedByOther(intersection.entityID)) {
+                } else if (!entityIsGrabbedByOther(intersection.entityID)) {
                     // don't allow two people to distance grab the same object
-                    if (intersection.properties.collisionsWillMove
-                        && !intersection.properties.locked) {
+                    if (intersection.properties.collisionsWillMove && !intersection.properties.locked) {
                         // the hand is far from the intersected object.  go into distance-holding mode
                         this.grabbedEntity = intersection.entityID;
                         if (typeof grabbableData.spatialKey !== 'undefined' && this.state == STATE_EQUIP_SEARCHING) {
@@ -494,10 +514,18 @@ function MyController(hand) {
             Entities.addEntity({
                 type: "Sphere",
                 name: "Grab Debug Entity",
-                dimensions: {x: GRAB_RADIUS, y: GRAB_RADIUS, z: GRAB_RADIUS},
+                dimensions: {
+                    x: GRAB_RADIUS,
+                    y: GRAB_RADIUS,
+                    z: GRAB_RADIUS
+                },
                 visible: true,
                 position: handPosition,
-                color: { red: 0, green: 255, blue: 0},
+                color: {
+                    red: 0,
+                    green: 255,
+                    blue: 0
+                },
                 lifetime: 0.1
             });
         }
@@ -604,6 +632,7 @@ function MyController(hand) {
             } else {
                 Entities.callEntityMethod(this.grabbedEntity, "setLeftHand");
             }
+            Entities.callEntityMethod(this.grabbedEntity, "setHand", [this.hand]);
             Entities.callEntityMethod(this.grabbedEntity, "startDistantGrab");
         }
 
@@ -639,7 +668,7 @@ function MyController(hand) {
 
         // the action was set up on a previous call.  update the targets.
         var radius = Math.max(Vec3.distance(this.currentObjectPosition, handControllerPosition) *
-                              DISTANCE_HOLDING_RADIUS_FACTOR, DISTANCE_HOLDING_RADIUS_FACTOR);
+            DISTANCE_HOLDING_RADIUS_FACTOR, DISTANCE_HOLDING_RADIUS_FACTOR);
         // how far did avatar move this timestep?
         var currentPosition = MyAvatar.position;
         var avatarDeltaPosition = Vec3.subtract(currentPosition, this.currentAvatarPosition);
@@ -688,9 +717,9 @@ function MyController(hand) {
 
         // this doubles hand rotation
         var handChange = Quat.multiply(Quat.slerp(this.handPreviousRotation,
-                                                  handRotation,
-                                                  DISTANCE_HOLDING_ROTATION_EXAGGERATION_FACTOR),
-                                       Quat.inverse(this.handPreviousRotation));
+                handRotation,
+                DISTANCE_HOLDING_ROTATION_EXAGGERATION_FACTOR),
+            Quat.inverse(this.handPreviousRotation));
         this.handPreviousRotation = handRotation;
         this.currentObjectRotation = Quat.multiply(handChange, this.currentObjectRotation);
 
@@ -773,6 +802,8 @@ function MyController(hand) {
                 this.setState(STATE_CONTINUE_NEAR_GRABBING);
             } else {
                 // equipping
+                Entities.callEntityMethod(this.grabbedEntity, "startEquip", [JSON.stringify(this.hand)]);
+                this.startHandGrasp();
                 this.setState(STATE_CONTINUE_EQUIP_BD);
             }
 
@@ -781,6 +812,9 @@ function MyController(hand) {
             } else {
                 Entities.callEntityMethod(this.grabbedEntity, "setLeftHand");
             }
+
+            Entities.callEntityMethod(this.grabbedEntity, "setHand", [this.hand]);
+
             Entities.callEntityMethod(this.grabbedEntity, "startNearGrab");
 
         }
@@ -807,6 +841,7 @@ function MyController(hand) {
         }
         if (this.state == STATE_CONTINUE_NEAR_GRABBING && this.bumperSqueezed()) {
             this.setState(STATE_CONTINUE_EQUIP_BD);
+            Entities.callEntityMethod(this.grabbedEntity, "startEquip", [JSON.stringify(this.hand)]);
             return;
         }
 
@@ -827,6 +862,10 @@ function MyController(hand) {
         this.currentObjectTime = now;
         Entities.callEntityMethod(this.grabbedEntity, "continueNearGrab");
 
+        if (this.state === STATE_CONTINUE_EQUIP_BD) {
+            Entities.callEntityMethod(this.grabbedEntity, "continueEquip");
+        }
+
         if (this.actionTimeout - now < ACTION_TTL_REFRESH * MSEC_PER_SEC) {
             // if less than a 5 seconds left, refresh the actions ttl
             Entities.updateAction(this.grabbedEntity, this.actionID, {
@@ -846,6 +885,8 @@ function MyController(hand) {
         if (this.bumperReleased()) {
             this.setState(STATE_RELEASE);
             Entities.callEntityMethod(this.grabbedEntity, "releaseGrab");
+            Entities.callEntityMethod(this.grabbedEntity, "unequip");
+            this.endHandGrasp();
         }
     };
 
@@ -856,8 +897,17 @@ function MyController(hand) {
         var grabbableData = getEntityCustomData(GRABBABLE_DATA_KEY, this.grabbedEntity, DEFAULT_GRABBABLE_DATA);
 
         // use a spring to pull the object to where it will be when equipped
-        var relativeRotation = { x: 0.0, y: 0.0, z: 0.0, w: 1.0 };
-        var relativePosition = { x: 0.0, y: 0.0, z: 0.0 };
+        var relativeRotation = {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+            w: 1.0
+        };
+        var relativePosition = {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0
+        };
         if (grabbableData.spatialKey.relativePosition) {
             relativePosition = grabbableData.spatialKey.relativePosition;
         }
@@ -913,6 +963,9 @@ function MyController(hand) {
         } else {
             Entities.callEntityMethod(this.grabbedEntity, "setLeftHand");
         }
+
+        Entities.callEntityMethod(this.grabbedEntity, "setHand", [this.hand]);
+
         Entities.callEntityMethod(this.grabbedEntity, "startNearTrigger");
         this.setState(STATE_CONTINUE_NEAR_TRIGGER);
     };
@@ -929,6 +982,7 @@ function MyController(hand) {
         } else {
             Entities.callEntityMethod(this.grabbedEntity, "setLeftHand");
         }
+        Entities.callEntityMethod(this.grabbedEntity, "setHand", [this.hand]);
         Entities.callEntityMethod(this.grabbedEntity, "startFarTrigger");
         this.setState(STATE_CONTINUE_FAR_TRIGGER);
     };
@@ -1040,7 +1094,7 @@ function MyController(hand) {
 
     this.release = function() {
 
-        if(this.hand !== disabledHand){
+        if (this.hand !== disabledHand) {
             //release the disabled hand when we let go with the main one
             disabledHand = 'none';
         }
@@ -1061,6 +1115,7 @@ function MyController(hand) {
 
     this.cleanup = function() {
         this.release();
+        this.endHandGrasp();
     };
 
     this.activateEntity = function(entityID, grabbedProperties) {
@@ -1075,9 +1130,15 @@ function MyController(hand) {
             data["gravity"] = grabbedProperties.gravity;
             data["ignoreForCollisions"] = grabbedProperties.ignoreForCollisions;
             data["collisionsWillMove"] = grabbedProperties.collisionsWillMove;
-            var whileHeldProperties = {gravity: {x:0, y:0, z:0}};
+            var whileHeldProperties = {
+                gravity: {
+                    x: 0,
+                    y: 0,
+                    z: 0
+                }
+            };
             if (invertSolidWhileHeld) {
-                whileHeldProperties["ignoreForCollisions"] = ! grabbedProperties.ignoreForCollisions;
+                whileHeldProperties["ignoreForCollisions"] = !grabbedProperties.ignoreForCollisions;
             }
             Entities.editEntity(entityID, whileHeldProperties);
         }
@@ -1103,6 +1164,44 @@ function MyController(hand) {
         }
         setEntityCustomData(GRAB_USER_DATA_KEY, entityID, data);
     };
+
+
+    //this is our handler, where we do the actual work of changing animation settings
+    this.graspHand = function(animationProperties) {
+        var result = {};
+        //full alpha on overlay for this hand
+        //set grab to true
+        //set idle to false
+        //full alpha on the blend btw open and grab
+        if (_this.hand === RIGHT_HAND) {
+            result['rightHandOverlayAlpha'] = 1.0;
+            result['isRightHandGrab'] = true;
+            result['isRightHandIdle'] = false;
+            result['rightHandGrabBlend'] = 1.0;
+        } else if (_this.hand === LEFT_HAND) {
+            result['leftHandOverlayAlpha'] = 1.0;
+            result['isLeftHandGrab'] = true;
+            result['isLeftHandIdle'] = false;
+            result['leftHandGrabBlend'] = 1.0;
+        }
+        //return an object with our updated settings
+        return result;
+    }
+
+    this.graspHandler = null
+    this.startHandGrasp = function() {
+        if (this.hand === RIGHT_HAND) {
+            this.graspHandler = MyAvatar.addAnimationStateHandler(this.graspHand, ['isRightHandGrab']);
+        } else if (this.hand === LEFT_HAND) {
+            this.graspHandler = MyAvatar.addAnimationStateHandler(this.graspHand, ['isLeftHandGrab']);
+        }
+    }
+
+    this.endHandGrasp = function() {
+        // Tell the animation system we don't need any more callbacks.
+        MyAvatar.removeAnimationStateHandler(this.graspHandler);
+    }
+
 }
 
 var rightController = new MyController(RIGHT_HAND);
@@ -1132,4 +1231,4 @@ function cleanup() {
 }
 
 Script.scriptEnding.connect(cleanup);
-Script.update.connect(update);
+Script.update.connect(update);

examples/defaultScripts.js

@@ -19,4 +19,3 @@ Script.load("controllers/handControllerGrab.js");
 Script.load("grab.js");
 Script.load("directory.js");
 Script.load("dialTone.js");
-Script.load("libraries/omniTool.js");

examples/entityScripts/messagesReceiverEntityExample.js

@@ -0,0 +1,56 @@
+//
+//  messagesReceiverEntityExample.js
+//  examples/entityScripts
+//
+//  Created by Brad Hefta-Gaub on 11/18/15.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  This is an example of an entity script which when assigned to an entity, will detect when the entity is being grabbed by the hydraGrab script
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+(function () {
+
+    var _this;
+
+    var messageReceived = function (channel, message, senderID) {
+        print("message received on channel:" + channel + ", message:" + message + ", senderID:" + senderID);
+    };
+
+    // this is the "constructor" for the entity as a JS object we don't do much here, but we do want to remember
+    // our this object, so we can access it in cases where we're called without a this (like in the case of various global signals)
+    MessagesReceiver = function () {
+        _this = this;
+    };
+
+    MessagesReceiver.prototype = {
+
+        // preload() will be called when the entity has become visible (or known) to the interface
+        // it gives us a chance to set our local JavaScript object up. In this case it means:
+        //   * remembering our entityID, so we can access it in cases where we're called without an entityID
+        //   * unsubscribing from messages
+        //   * connectingf to the messageReceived signal
+        preload: function (entityID) {
+            this.entityID = entityID;
+
+            print("---- subscribing ----");
+            Messages.subscribe("example");
+            Messages.messageReceived.connect(messageReceived);
+        },
+
+        // unload() will be called when the entity has become no longer known to the interface
+        // it gives us a chance to clean up our local JavaScript object. In this case it means:
+        //   * unsubscribing from messages
+        //   * disconnecting from the messageReceived signal
+        unload: function (entityID) {
+            print("---- unsubscribing ----");
+            Messages.unsubscribe("example");
+            Messages.messageReceived.disconnect(messageReceived);
+        },
+    };
+
+    // entity scripts always need to return a newly constructed object of our type
+    return new MessagesReceiver();
+})

examples/entityScripts/recordingMaster.js

@@ -27,7 +27,6 @@ var toolBar = null;
 var recordIcon;
 var isRecording = false;
 var channel = "groupRecordingChannel";
-Messages.subscribe(channel);
 setupToolBar();
 
 function setupToolBar() {

examples/entityScripts/synchronizerEntityScript.js

@@ -1,90 +0,0 @@
-//
-//  synchronizerEntityScript.js
-//  examples/entityScripts
-//
-//  Created by Alessandro Signa on 11/12/15.
-//  Copyright 2015 High Fidelity, Inc.
-//
-
-//  This script shows how to create a synchronized event between avatars trhough an entity.
-//  It works using the entity's userData: the master change its value and every client checks it every frame
-//  This entity prints a message when the event starts and when it ends. 
-//  The client running synchronizerMaster.js is the event master and it decides when the event starts/ends by pressing a button.
-//  All the avatars in the area when the master presses the button will receive a message.
-//  
-
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-
-
-
-
-(function() {
-    var insideArea = false;
-    var isJoiningTheEvent = false;
-    var _this;
-    
-    
-
-    function ParamsEntity() {
-        _this = this;
-        return;
-    }
-    
-    
-    ParamsEntity.prototype = {
-        update: function(){
-            var userData = JSON.parse(Entities.getEntityProperties(_this.entityID, ["userData"]).userData);
-            var valueToCheck = userData.myKey.valueToCheck;
-            if(valueToCheck && !isJoiningTheEvent){
-                _this.sendMessage();
-            }else if((!valueToCheck && isJoiningTheEvent) || (isJoiningTheEvent && !insideArea)){
-                _this.stopMessage();
-            }
-        },
-        preload: function(entityID) {
-            print('entity loaded')
-            this.entityID = entityID;
-            Script.update.connect(_this.update);
-        },
-        enterEntity: function(entityID) {       
-            print("enterEntity("+entityID+")");
-            var userData = JSON.parse(Entities.getEntityProperties(_this.entityID, ["userData"]).userData);
-            var valueToCheck = userData.myKey.valueToCheck;
-            if(!valueToCheck){
-                //i'm in the area in time (before the event starts)
-                insideArea = true;
-            }
-            change(entityID);
-        },
-        leaveEntity: function(entityID) {      
-            print("leaveEntity("+entityID+")");
-            Entities.editEntity(entityID, { color: { red: 255, green: 190, blue: 20} });
-            insideArea = false;
-        },
-        
-        sendMessage: function(myID){
-            if(insideArea && !isJoiningTheEvent){
-                print("The event started");
-                isJoiningTheEvent = true;
-            }
-        },
-        
-        stopMessage: function(myID){
-            if(isJoiningTheEvent){
-                print("The event ended");
-                isJoiningTheEvent = false;
-            }
-        },
-        clean: function(entityID) {
-            Script.update.disconnect(_this.update);
-        }
-    }
-    
-    function change(entityID) {
-        Entities.editEntity(entityID, { color: { red: 255, green: 100, blue: 220} });
-    }
-    
-
-    return new ParamsEntity();
-});

examples/entityScripts/synchronizerMaster.js

@@ -1,117 +0,0 @@
-//
-//  synchronizerMaster.js
-//  examples/entityScripts
-//
-//  Created by Alessandro Signa on 11/12/15.
-//  Copyright 2015 High Fidelity, Inc.
-//
-//  Run this script to spawn a box (synchronizer) and drive the start/end of the event for anyone who is inside the box
-//  
-//  Distributed under the Apache License, Version 2.0.
-//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
-
-var PARAMS_SCRIPT_URL = Script.resolvePath('synchronizerEntityScript.js');
-
-
-HIFI_PUBLIC_BUCKET = "http://s3.amazonaws.com/hifi-public/";
-Script.include("../libraries/toolBars.js");
-Script.include("../libraries/utils.js");
-
-
-
-var rotation = Quat.safeEulerAngles(Camera.getOrientation());
-rotation = Quat.fromPitchYawRollDegrees(0, rotation.y, 0);
-var center = Vec3.sum(MyAvatar.position, Vec3.multiply(1, Quat.getFront(rotation)));
-
-var TOOL_ICON_URL = HIFI_PUBLIC_BUCKET + "images/tools/";
-var ALPHA_ON = 1.0;
-var ALPHA_OFF = 0.7;
-var COLOR_TOOL_BAR = { red: 0, green: 0, blue: 0 };
-
-var toolBar = null;
-var recordIcon;
-
-
-
-var isHappening = false;
-
-var testEntity = Entities.addEntity({
-    name: 'paramsTestEntity',
-    dimensions: {
-        x: 2,
-        y: 1,
-        z: 2
-    },
-    type: 'Box',
-    position: center,
-    color: {
-        red: 255,
-        green: 255,
-        blue: 255
-    },
-    visible: true,
-    ignoreForCollisions: true,
-    script: PARAMS_SCRIPT_URL,
-    
-    userData: JSON.stringify({
-        myKey: {
-            valueToCheck: false
-        }
-    })
-});
-
-
-setupToolBar();
-
-function setupToolBar() {
-    if (toolBar != null) {
-        print("Multiple calls to setupToolBar()");
-        return;
-    }
-    Tool.IMAGE_HEIGHT /= 2;
-    Tool.IMAGE_WIDTH /= 2;
-    
-    toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL);    //put the button in the up-left corner
-    
-    toolBar.setBack(COLOR_TOOL_BAR, ALPHA_OFF);
-    
-    recordIcon = toolBar.addTool({
-        imageURL: TOOL_ICON_URL + "recording-record.svg",
-        subImage: { x: 0, y: 0, width: Tool.IMAGE_WIDTH, height: Tool.IMAGE_HEIGHT },
-        x: 0, y: 0,
-        width: Tool.IMAGE_WIDTH,
-        height: Tool.IMAGE_HEIGHT,
-        alpha: MyAvatar.isPlaying() ? ALPHA_OFF : ALPHA_ON,
-        visible: true
-    }, true, isHappening);
-    
-}
-
-function mousePressEvent(event) {
-    clickedOverlay = Overlays.getOverlayAtPoint({ x: event.x, y: event.y });
-    if (recordIcon === toolBar.clicked(clickedOverlay, false)) {
-        if (!isHappening) {
-            print("I'm the event master. I want the event starts");
-            isHappening = true;
-            setEntityCustomData("myKey", testEntity, {valueToCheck: true});
-            
-        } else {
-            print("I want the event stops");
-            isHappening = false;
-            setEntityCustomData("myKey", testEntity, {valueToCheck: false});
-            
-        }
-    } 
-}
-
-
-function cleanup() {
-    toolBar.cleanup();
-    Entities.callEntityMethod(testEntity, 'clean');      //have to call this before deleting to avoid the JSON warnings
-    Entities.deleteEntity(testEntity);
-}
-
-
-
- Script.scriptEnding.connect(cleanup);
- Controller.mousePressEvent.connect(mousePressEvent);

examples/example/assetsExample.js

@@ -0,0 +1,11 @@
+var data = "this is some data";
+var extension = "txt";
+var uploadedFile;
+
+Assets.uploadData(data, extension, function (url) {
+    print("data uploaded to:" + url);
+    uploadedFile = url;
+    Assets.downloadData(url, function (data) {
+        print("data downloaded from:" + url + " the data is:" + data);
+    });
+});

examples/example/avatarcontrol/graspHands.js

@@ -0,0 +1,68 @@
+//  graspHands.js
+//
+//  Created by James B. Pollack @imgntn -- 11/19/2015
+//  Copyright 2015 High Fidelity, Inc.
+// 
+//  Shows how to use the animation API to grasp an Avatar's hands.
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+
+//choose a hand.  set it programatically if you'd like
+var handToGrasp = 'LEFT_HAND';
+
+//this is our handler, where we do the actual work of changing animation settings
+function graspHand(animationProperties) {
+    var result = {};
+    //full alpha on overlay for this hand
+    //set grab to true
+    //set idle to false
+    //full alpha on the blend btw open and grab
+    if (handToGrasp === 'RIGHT_HAND') {
+        result['rightHandOverlayAlpha'] = 1.0;
+        result['isRightHandGrab'] = true;
+        result['isRightHandIdle'] = false;
+        result['rightHandGrabBlend'] = 1.0;
+    } else if (handToGrasp === 'LEFT_HAND') {
+        result['leftHandOverlayAlpha'] = 1.0;
+        result['isLeftHandGrab'] = true;
+        result['isLeftHandIdle'] = false;
+        result['leftHandGrabBlend'] = 1.0;
+    }
+    //return an object with our updated settings
+    return result;
+}
+
+//keep a reference to this so we can clear it
+var handler;
+
+//register our handler with the animation system
+function startHandGrasp() {
+    if (handToGrasp === 'RIGHT_HAND') {
+        handler = MyAvatar.addAnimationStateHandler(graspHand, ['isRightHandGrab']);
+    } else if (handToGrasp === 'LEFT_HAND') {
+        handler = MyAvatar.addAnimationStateHandler(graspHand, ['isLeftHandGrab']);
+    }
+}
+
+function endHandGrasp() {
+    // Tell the animation system we don't need any more callbacks.
+    MyAvatar.removeAnimationStateHandler(handler);
+}
+
+//make sure to clean this up when the script ends so we don't get stuck.
+Script.scriptEnding.connect(function() {
+    Script.clearInterval(graspInterval);
+    endHandGrasp();
+})
+
+//set an interval and toggle grasping
+var isGrasping = false;
+var graspInterval = Script.setInterval(function() {
+    if (isGrasping === false) {
+        startHandGrasp();
+        isGrasping = true;
+    } else {
+        endHandGrasp();
+        isGrasping = false
+    }
+}, 1000)

examples/tests/lodTest.js

@@ -0,0 +1,40 @@
+//
+//  lodTest.js
+//  examples/tests
+//
+//  Created by Ryan Huffman on 11/19/15.
+//  Copyright 2015 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
+//
+
+var MIN_DIM = 0.001;
+var MAX_DIM = 2.0;
+var NUM_SPHERES = 20;
+
+// Rough estimate of the width the spheres will span, not taking into account MIN_DIM
+var WIDTH = MAX_DIM * NUM_SPHERES;
+
+var entities = [];
+var right = Quat.getRight(Camera.orientation);
+// Starting position will be 30 meters in front of the camera
+var position = Vec3.sum(Camera.position, Vec3.multiply(30, Quat.getFront(Camera.orientation)));
+position = Vec3.sum(position, Vec3.multiply(-WIDTH/2, right));
+
+for (var i = 0; i < NUM_SPHERES; ++i) {
+    var dim = (MAX_DIM - MIN_DIM) * ((i + 1) / NUM_SPHERES);
+    entities.push(Entities.addEntity({
+        type: "Sphere",
+        dimensions: { x: dim, y: dim, z: dim },
+        position: position,
+    }));
+
+    position = Vec3.sum(position, Vec3.multiply(dim * 2, right));
+}
+
+Script.scriptEnding.connect(function() {
+    for (var i = 0; i < entities.length; ++i) {
+        Entities.deleteEntity(entities[i]);
+    }
+})

examples/tests/playbackAcTest.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var origin = {x: 512, y: 512, z: 512};
+var millisecondsToWaitBeforeStarting = 2 * 1000; // To give the various servers a chance to start.
+var millisecondsToWaitBeforeEnding = 30 * 1000; 
+
+Avatar.skeletonModelURL = "https://hifi-public.s3.amazonaws.com/marketplace/contents/dd03b8e3-52fb-4ab3-9ac9-3b17e00cd85d/98baa90b3b66803c5d7bd4537fca6993.fst"; //lovejoy
+Avatar.displayName = "AC Avatar";
+Agent.isAvatar = true;
+
+Script.setTimeout(function () {
+    Avatar.position = origin;
+    Recording.loadRecording("d:/hifi.rec");
+    Recording.setPlayerLoop(true);
+    Recording.startPlaying();
+}, millisecondsToWaitBeforeStarting);
+
+
+Script.setTimeout(function () {
+    print("Stopping script");
+    Agent.isAvatar = false;
+    Recording.stopPlaying();
+    Script.stop();
+}, millisecondsToWaitBeforeEnding);

examples/toybox/bubblewand/createWand.js

@@ -12,8 +12,8 @@
 
 Script.include("../../libraries/utils.js");
 
-var WAND_MODEL = 'http://hifi-public.s3.amazonaws.com/models/bubblewand/wand.fbx';
-var WAND_COLLISION_SHAPE = 'http://hifi-public.s3.amazonaws.com/models/bubblewand/actual_no_top_collision_hull.obj';
+var WAND_MODEL = 'http://hifi-content.s3.amazonaws.com/james/bubblewand/wand.fbx';
+var WAND_COLLISION_SHAPE = 'http://hifi-content.s3.amazonaws.com/james/bubblewand/wand_collision_hull.obj';
 
 var WAND_SCRIPT_URL = Script.resolvePath("wand.js");
 
@@ -43,5 +43,18 @@ var wand = Entities.addEntity({
     //must be enabled to be grabbable in the physics engine
     collisionsWillMove: true,
     compoundShapeURL: WAND_COLLISION_SHAPE,
-    script: WAND_SCRIPT_URL
+    script: WAND_SCRIPT_URL,
+    userData: JSON.stringify({
+        grabbableKey: {
+            invertSolidWhileHeld: true,
+            spatialKey: {
+                relativePosition: {
+                    x: 0,
+                    y: 0.1,
+                    z: 0
+                },
+                relativeRotation: Quat.fromPitchYawRollDegrees(0, 0, 90)
+            }
+        }
+    })
 });

examples/toybox/bubblewand/wand.js

@@ -12,7 +12,7 @@
 
 /*global MyAvatar, Entities, AnimationCache, SoundCache, Scene, Camera, Overlays, HMD, AvatarList, AvatarManager, Controller, UndoStack, Window, Account, GlobalServices, Script, ScriptDiscoveryService, LODManager, Menu, Vec3, Quat, AudioDevice, Paths, Clipboard, Settings, XMLHttpRequest, randFloat, randInt */
 
-(function () {
+(function() {
 
     Script.include("../../libraries/utils.js");
 
@@ -58,23 +58,23 @@
     BubbleWand.prototype = {
         timePassed: null,
         currentBubble: null,
-        preload: function (entityID) {
+        preload: function(entityID) {
             this.entityID = entityID;
         },
-        getWandTipPosition: function (properties) {
+        getWandTipPosition: function(properties) {
             //the tip of the wand is going to be in a different place than the center, so we move in space relative to the model to find that position
             var upVector = Quat.getUp(properties.rotation);
             var upOffset = Vec3.multiply(upVector, WAND_TIP_OFFSET);
             var wandTipPosition = Vec3.sum(properties.position, upOffset);
             return wandTipPosition;
         },
-        addCollisionsToBubbleAfterCreation: function (bubble) {
+        addCollisionsToBubbleAfterCreation: function(bubble) {
             //if the bubble collide immediately, we get weird effects.  so we add collisions after release
             Entities.editEntity(bubble, {
                 collisionsWillMove: true
             });
         },
-        randomizeBubbleGravity: function () {
+        randomizeBubbleGravity: function() {
             //change up the gravity a little bit for variation in floating effects
             var randomNumber = randFloat(BUBBLE_GRAVITY_MIN, BUBBLE_GRAVITY_MAX);
             var gravity = {
@@ -84,7 +84,7 @@
             };
             return gravity;
         },
-        growBubbleWithWandVelocity: function (properties, deltaTime) {
+        growBubbleWithWandVelocity: function(properties, deltaTime) {
             //get the wand and tip position for calculations
             var wandPosition = properties.position;
             this.getWandTipPosition(properties);
@@ -145,7 +145,7 @@
                 dimensions: dimensions
             });
         },
-        createBubbleAtTipOfWand: function () {
+        createBubbleAtTipOfWand: function() {
 
             //create a new bubble at the tip of the wand
             var properties = Entities.getEntityProperties(this.entityID, ["position", "rotation"]);
@@ -162,24 +162,23 @@
                 position: this.getWandTipPosition(properties),
                 dimensions: BUBBLE_INITIAL_DIMENSIONS,
                 collisionsWillMove: false,
-                ignoreForCollisions: false,
+                ignoreForCollisions: true,
                 linearDamping: BUBBLE_LINEAR_DAMPING,
                 shapeType: "sphere"
             });
 
         },
-        startNearGrab: function () {
+        startNearGrab: function() {
             //create a bubble to grow at the start of the grab
             if (this.currentBubble === null) {
                 this.createBubbleAtTipOfWand();
             }
         },
-        continueNearGrab: function () {
+        continueNearGrab: function() {
             var deltaTime = checkInterval();
             //only get the properties that we need
             var properties = Entities.getEntityProperties(this.entityID, ["position", "rotation"]);
 
-
             var wandTipPosition = this.getWandTipPosition(properties);
 
             //update the bubble to stay with the wand tip
@@ -189,7 +188,7 @@
             this.growBubbleWithWandVelocity(properties, deltaTime);
 
         },
-        releaseGrab: function () {
+        releaseGrab: function() {
             //delete the  current buble and reset state when the wand is released
             Entities.deleteEntity(this.currentBubble);
             this.currentBubble = null;

interface/src/Application.cpp

@@ -454,6 +454,17 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     audioIO->setOrientationGetter([this]{ return getMyAvatar()->getOrientationForAudio(); });
 
     audioIO->moveToThread(audioThread);
+    recording::Frame::registerFrameHandler(AudioConstants::AUDIO_FRAME_NAME, [=](recording::Frame::ConstPointer frame) {
+        audioIO->handleRecordedAudioInput(frame->data);
+    });
+
+    connect(audioIO.data(), &AudioClient::inputReceived, [](const QByteArray& audio){
+        static auto recorder = DependencyManager::get<recording::Recorder>();
+        if (recorder->isRecording()) {
+            static const recording::FrameType AUDIO_FRAME_TYPE = recording::Frame::registerFrameType(AudioConstants::AUDIO_FRAME_NAME);
+            recorder->recordFrame(AUDIO_FRAME_TYPE, audio);
+        }
+    });
 
     auto& audioScriptingInterface = AudioScriptingInterface::getInstance();
 
@@ -743,10 +754,6 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
     connect(applicationUpdater.data(), &AutoUpdater::newVersionIsAvailable, dialogsManager.data(), &DialogsManager::showUpdateDialog);
     applicationUpdater->checkForUpdate();
 
-    // Assign MyAvatar to th eRecording Singleton
-    DependencyManager::get<RecordingScriptingInterface>()->setControlledAvatar(getMyAvatar());
-
-
     // Now that menu is initalized we can sync myAvatar with it's state.
     getMyAvatar()->updateMotionBehaviorFromMenu();
 
@@ -841,8 +848,6 @@ void Application::cleanupBeforeQuit() {
 #ifdef HAVE_IVIEWHMD
     DependencyManager::get<EyeTracker>()->setEnabled(false, true);
 #endif
-    DependencyManager::get<RecordingScriptingInterface>()->setControlledAvatar(nullptr);
-
     AnimDebugDraw::getInstance().shutdown();
 
     // FIXME: once we move to shared pointer for the INputDevice we shoud remove this naked delete:

interface/src/avatar/Avatar.cpp

@@ -1187,7 +1187,7 @@ void Avatar::computeShapeInfo(ShapeInfo& shapeInfo) {
 
 // virtual
 void Avatar::rebuildSkeletonBody() {
-    DependencyManager::get<AvatarManager>()->updateAvatarPhysicsShape(getSessionUUID());
+    DependencyManager::get<AvatarManager>()->updateAvatarPhysicsShape(this);
 }
 
 glm::vec3 Avatar::getLeftPalmPosition() {

interface/src/avatar/AvatarManager.cpp

@@ -110,28 +110,34 @@ void AvatarManager::updateMyAvatar(float deltaTime) {
 }
 
 void AvatarManager::updateOtherAvatars(float deltaTime) {
+    // lock the hash for read to check the size
+    QReadLocker lock(&_hashLock);
+    
     if (_avatarHash.size() < 2 && _avatarFades.isEmpty()) {
         return;
     }
+    
+    lock.unlock();
+    
     bool showWarnings = Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings);
     PerformanceWarning warn(showWarnings, "Application::updateAvatars()");
 
     PerformanceTimer perfTimer("otherAvatars");
 
     // simulate avatars
-    AvatarHash::iterator avatarIterator = _avatarHash.begin();
-    while (avatarIterator != _avatarHash.end()) {
-        auto avatar = std::dynamic_pointer_cast<Avatar>(avatarIterator.value());
+    auto hashCopy = getHashCopy();
+    
+    AvatarHash::iterator avatarIterator = hashCopy.begin();
+    while (avatarIterator != hashCopy.end()) {
+        auto avatar = std::static_pointer_cast<Avatar>(avatarIterator.value());
 
         if (avatar == _myAvatar || !avatar->isInitialized()) {
             // DO NOT update _myAvatar!  Its update has already been done earlier in the main loop.
             // DO NOT update or fade out uninitialized Avatars
             ++avatarIterator;
         } else if (avatar->shouldDie()) {
-            removeAvatarMotionState(avatar);
-            _avatarFades.push_back(avatarIterator.value());
-            QWriteLocker locker(&_hashLock);
-            avatarIterator = _avatarHash.erase(avatarIterator);
+            removeAvatar(avatarIterator.key());
+            ++avatarIterator;
         } else {
             avatar->startUpdate();
             avatar->simulate(deltaTime);
@@ -169,19 +175,21 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
 }
 
 AvatarSharedPointer AvatarManager::newSharedAvatar() {
-    return AvatarSharedPointer(std::make_shared<Avatar>(std::make_shared<AvatarRig>()));
+    return std::make_shared<Avatar>(std::make_shared<AvatarRig>());
 }
 
-// virtual
 AvatarSharedPointer AvatarManager::addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {
-    auto avatar = std::dynamic_pointer_cast<Avatar>(AvatarHashMap::addAvatar(sessionUUID, mixerWeakPointer));
+    auto newAvatar = AvatarHashMap::addAvatar(sessionUUID, mixerWeakPointer);
+    auto rawRenderableAvatar = std::static_pointer_cast<Avatar>(newAvatar);
+    
     render::ScenePointer scene = qApp->getMain3DScene();
     render::PendingChanges pendingChanges;
     if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderAvatars()) {
-        avatar->addToScene(avatar, scene, pendingChanges);
+        rawRenderableAvatar->addToScene(rawRenderableAvatar, scene, pendingChanges);
     }
     scene->enqueuePendingChanges(pendingChanges);
-    return avatar;
+    
+    return newAvatar;
 }
 
 // protected
@@ -200,20 +208,25 @@ void AvatarManager::removeAvatarMotionState(AvatarSharedPointer avatar) {
 
 // virtual
 void AvatarManager::removeAvatar(const QUuid& sessionUUID) {
-    AvatarHash::iterator avatarIterator = _avatarHash.find(sessionUUID);
-    if (avatarIterator != _avatarHash.end()) {
-        std::shared_ptr<Avatar> avatar = std::dynamic_pointer_cast<Avatar>(avatarIterator.value());
-        if (avatar != _myAvatar && avatar->isInitialized()) {
-            removeAvatarMotionState(avatar);
-            _avatarFades.push_back(avatarIterator.value());
-            QWriteLocker locker(&_hashLock);
-            _avatarHash.erase(avatarIterator);
-        }
+    QWriteLocker locker(&_hashLock);
+    
+    auto removedAvatar = _avatarHash.take(sessionUUID);
+    if (removedAvatar) {
+        handleRemovedAvatar(removedAvatar);
     }
 }
 
+void AvatarManager::handleRemovedAvatar(const AvatarSharedPointer& removedAvatar) {
+    AvatarHashMap::handleRemovedAvatar(removedAvatar);
+    
+    removeAvatarMotionState(removedAvatar);
+    _avatarFades.push_back(removedAvatar);
+}
+
 void AvatarManager::clearOtherAvatars() {
     // clear any avatars that came from an avatar-mixer
+    QWriteLocker locker(&_hashLock);
+    
     AvatarHash::iterator avatarIterator =  _avatarHash.begin();
     while (avatarIterator != _avatarHash.end()) {
         auto avatar = std::static_pointer_cast<Avatar>(avatarIterator.value());
@@ -221,10 +234,10 @@ void AvatarManager::clearOtherAvatars() {
             // don't remove myAvatar or uninitialized avatars from the list
             ++avatarIterator;
         } else {
-            removeAvatarMotionState(avatar);
-            _avatarFades.push_back(avatarIterator.value());
-            QWriteLocker locker(&_hashLock);
+            auto removedAvatar = avatarIterator.value();
             avatarIterator = _avatarHash.erase(avatarIterator);
+            
+            handleRemovedAvatar(removedAvatar);
         }
     }
     _myAvatar->clearLookAtTargetAvatar();
@@ -252,6 +265,7 @@ QVector<QUuid> AvatarManager::getAvatarIdentifiers() {
     QReadLocker locker(&_hashLock);
     return _avatarHash.keys().toVector();
 }
+
 AvatarData* AvatarManager::getAvatar(QUuid avatarID) {
     QReadLocker locker(&_hashLock);
     return _avatarHash[avatarID].get();  // Non-obvious: A bogus avatarID answers your own avatar.
@@ -317,23 +331,19 @@ void AvatarManager::handleCollisionEvents(const CollisionEvents& collisionEvents
     }
 }
 
-void AvatarManager::updateAvatarPhysicsShape(const QUuid& id) {
-    AvatarHash::iterator avatarItr = _avatarHash.find(id);
-    if (avatarItr != _avatarHash.end()) {
-        auto avatar = std::static_pointer_cast<Avatar>(avatarItr.value());
-        AvatarMotionState* motionState = avatar->getMotionState();
-        if (motionState) {
-            motionState->addDirtyFlags(Simulation::DIRTY_SHAPE);
-        } else {
-            ShapeInfo shapeInfo;
-            avatar->computeShapeInfo(shapeInfo);
-            btCollisionShape* shape = ObjectMotionState::getShapeManager()->getShape(shapeInfo);
-            if (shape) {
-                AvatarMotionState* motionState = new AvatarMotionState(avatar.get(), shape);
-                avatar->setMotionState(motionState);
-                _motionStatesToAdd.insert(motionState);
-                _avatarMotionStates.insert(motionState);
-            }
+void AvatarManager::updateAvatarPhysicsShape(Avatar* avatar) {
+    AvatarMotionState* motionState = avatar->getMotionState();
+    if (motionState) {
+        motionState->addDirtyFlags(Simulation::DIRTY_SHAPE);
+    } else {
+        ShapeInfo shapeInfo;
+        avatar->computeShapeInfo(shapeInfo);
+        btCollisionShape* shape = ObjectMotionState::getShapeManager()->getShape(shapeInfo);
+        if (shape) {
+            AvatarMotionState* motionState = new AvatarMotionState(avatar, shape);
+            avatar->setMotionState(motionState);
+            _motionStatesToAdd.insert(motionState);
+            _avatarMotionStates.insert(motionState);
         }
     }
 }
@@ -341,7 +351,7 @@ void AvatarManager::updateAvatarPhysicsShape(const QUuid& id) {
 void AvatarManager::updateAvatarRenderStatus(bool shouldRenderAvatars) {
     if (DependencyManager::get<SceneScriptingInterface>()->shouldRenderAvatars()) {
         for (auto avatarData : _avatarHash) {
-            auto avatar = std::dynamic_pointer_cast<Avatar>(avatarData);
+            auto avatar = std::static_pointer_cast<Avatar>(avatarData);
             render::ScenePointer scene = qApp->getMain3DScene();
             render::PendingChanges pendingChanges;
             avatar->addToScene(avatar, scene, pendingChanges);
@@ -349,7 +359,7 @@ void AvatarManager::updateAvatarRenderStatus(bool shouldRenderAvatars) {
         }
     } else {
         for (auto avatarData : _avatarHash) {
-            auto avatar = std::dynamic_pointer_cast<Avatar>(avatarData);
+            auto avatar = std::static_pointer_cast<Avatar>(avatarData);
             render::ScenePointer scene = qApp->getMain3DScene();
             render::PendingChanges pendingChanges;
             avatar->removeFromScene(avatar, scene, pendingChanges);
@@ -363,11 +373,6 @@ AvatarSharedPointer AvatarManager::getAvatarBySessionID(const QUuid& sessionID)
     if (sessionID == _myAvatar->getSessionUUID()) {
         return std::static_pointer_cast<Avatar>(_myAvatar);
     }
-    QReadLocker locker(&_hashLock);
-    auto iter = _avatarHash.find(sessionID);
-    if (iter != _avatarHash.end()) {
-        return iter.value();
-    } else {
-        return AvatarSharedPointer();
-    }
+    
+    return findAvatar(sessionID);
 }

interface/src/avatar/AvatarManager.h

@@ -63,7 +63,7 @@ public:
     void handleOutgoingChanges(const VectorOfMotionStates& motionStates);
     void handleCollisionEvents(const CollisionEvents& collisionEvents);
 
-    void updateAvatarPhysicsShape(const QUuid& id);
+    void updateAvatarPhysicsShape(Avatar* avatar);
    
 public slots:
     void setShouldShowReceiveStats(bool shouldShowReceiveStats) { _shouldShowReceiveStats = shouldShowReceiveStats; }
@@ -79,7 +79,9 @@ private:
     virtual AvatarSharedPointer newSharedAvatar();
     virtual AvatarSharedPointer addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);
     void removeAvatarMotionState(AvatarSharedPointer avatar);
+    
     virtual void removeAvatar(const QUuid& sessionUUID);
+    virtual void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar);
     
     QVector<AvatarSharedPointer> _avatarFades;
     std::shared_ptr<MyAvatar> _myAvatar;

interface/src/avatar/MyAvatar.cpp

@@ -39,10 +39,10 @@
 #include <recording/Recorder.h>
 #include <recording/Clip.h>
 #include <recording/Frame.h>
-#include "devices/Faceshift.h"
-
+#include <RecordingScriptingInterface.h>
 
 #include "Application.h"
+#include "devices/Faceshift.h"
 #include "AvatarManager.h"
 #include "Environment.h"
 #include "Menu.h"
@@ -127,6 +127,65 @@ MyAvatar::MyAvatar(RigPointer rig) :
     _characterController.setEnabled(true);
 
     _bodySensorMatrix = deriveBodyFromHMDSensor();
+
+    using namespace recording;
+
+    auto player = DependencyManager::get<Deck>();
+    auto recorder = DependencyManager::get<Recorder>();
+    connect(player.data(), &Deck::playbackStateChanged, [=] {
+        if (player->isPlaying()) {
+            auto recordingInterface = DependencyManager::get<RecordingScriptingInterface>();
+            if (recordingInterface->getPlayFromCurrentLocation()) {
+                setRecordingBasis();
+            }
+        } else {
+            clearRecordingBasis();
+        }
+    });
+
+    connect(recorder.data(), &Recorder::recordingStateChanged, [=] {
+        if (recorder->isRecording()) {
+            setRecordingBasis();
+        } else {
+            clearRecordingBasis();
+        }
+    });
+
+    static const recording::FrameType AVATAR_FRAME_TYPE = recording::Frame::registerFrameType(AvatarData::FRAME_NAME);
+    Frame::registerFrameHandler(AVATAR_FRAME_TYPE, [=](Frame::ConstPointer frame) {
+        static AvatarData dummyAvatar;
+        AvatarData::fromFrame(frame->data, dummyAvatar);
+        if (getRecordingBasis()) {
+            dummyAvatar.setRecordingBasis(getRecordingBasis());
+        } else {
+            dummyAvatar.clearRecordingBasis();
+        }
+
+        auto recordingInterface = DependencyManager::get<RecordingScriptingInterface>();
+        if (recordingInterface->getPlayerUseHeadModel() && dummyAvatar.getFaceModelURL().isValid() &&
+            (dummyAvatar.getFaceModelURL() != getFaceModelURL())) {
+            // FIXME
+            //myAvatar->setFaceModelURL(_dummyAvatar.getFaceModelURL());
+        }
+
+        if (recordingInterface->getPlayerUseSkeletonModel() && dummyAvatar.getSkeletonModelURL().isValid() &&
+            (dummyAvatar.getSkeletonModelURL() != getSkeletonModelURL())) {
+            // FIXME
+            //myAvatar->useFullAvatarURL()
+        }
+
+        if (recordingInterface->getPlayerUseDisplayName() && dummyAvatar.getDisplayName() != getDisplayName()) {
+            setDisplayName(dummyAvatar.getDisplayName());
+        }
+
+        setPosition(dummyAvatar.getPosition());
+        setOrientation(dummyAvatar.getOrientation());
+
+        // FIXME attachments
+        // FIXME joints
+        // FIXME head lean
+        // FIXME head orientation
+    });
 }
 
 MyAvatar::~MyAvatar() {
@@ -369,7 +428,7 @@ void MyAvatar::updateHMDFollowVelocity() {
         }
         if (_followSpeed > 0.0f) {
             // to compute new velocity we must rotate offset into the world-frame
-            glm::quat sensorToWorldRotation = extractRotation(_sensorToWorldMatrix);
+            glm::quat sensorToWorldRotation = glm::normalize(glm::quat_cast(_sensorToWorldMatrix));
             _followVelocity = _followSpeed * glm::normalize(sensorToWorldRotation * offset);
         }
     }
@@ -923,10 +982,8 @@ void MyAvatar::updateLookAtTargetAvatar() {
     const float KEEP_LOOKING_AT_CURRENT_ANGLE_FACTOR = 1.3f;
     const float GREATEST_LOOKING_AT_DISTANCE = 10.0f;
 
-    AvatarHash hash;
-    DependencyManager::get<AvatarManager>()->withAvatarHash([&] (const AvatarHash& locked) {
-        hash = locked; // make a shallow copy and operate on that, to minimize lock time
-    });
+    AvatarHash hash = DependencyManager::get<AvatarManager>()->getHashCopy();
+    
     foreach (const AvatarSharedPointer& avatarPointer, hash) {
         auto avatar = static_pointer_cast<Avatar>(avatarPointer);
         bool isCurrentTarget = avatar->getIsLookAtTarget();

interface/src/ui/PreferencesDialog.cpp

@@ -56,7 +56,7 @@ PreferencesDialog::PreferencesDialog(QWidget* parent) :
 
     // move dialog to left side
     move(parentWidget()->geometry().topLeft());
-    setFixedHeight(parentWidget()->size().height() - PREFERENCES_HEIGHT_PADDING);
+    resize(sizeHint().width(), parentWidget()->size().height() - PREFERENCES_HEIGHT_PADDING);
 
     UIUtil::scaleWidgetFontSizes(this);
 }

libraries/audio-client/src/AudioClient.cpp

@@ -62,6 +62,7 @@ extern "C" {
 #include <SettingHandle.h>
 #include <SharedUtil.h>
 #include <UUID.h>
+#include <Transform.h>
 
 #include "AudioInjector.h"
 #include "AudioConstants.h"
@@ -839,93 +840,27 @@ void AudioClient::handleAudioInput() {
             _inputRingBuffer.shiftReadPosition(inputSamplesRequired);
         }
 
-        emitAudioPacket(networkAudioSamples);
-    }
-}
+        auto packetType = _shouldEchoToServer ?
+            PacketType::MicrophoneAudioWithEcho : PacketType::MicrophoneAudioNoEcho;
 
-void AudioClient::emitAudioPacket(const int16_t* audioData, PacketType packetType) {
-    static std::mutex _mutex;
-    using Locker = std::unique_lock<std::mutex>;
-
-    // FIXME recorded audio isn't guaranteed to have the same stereo state
-    // as the current system
-    const int numNetworkBytes = _isStereoInput
-        ? AudioConstants::NETWORK_FRAME_BYTES_STEREO
-        : AudioConstants::NETWORK_FRAME_BYTES_PER_CHANNEL;
-    const int numNetworkSamples = _isStereoInput
-        ? AudioConstants::NETWORK_FRAME_SAMPLES_STEREO
-        : AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL;
-
-    auto nodeList = DependencyManager::get<NodeList>();
-    SharedNodePointer audioMixer = nodeList->soloNodeOfType(NodeType::AudioMixer);
-
-    if (audioMixer && audioMixer->getActiveSocket()) {
-        Locker lock(_mutex);
-        if (!_audioPacket) {
-            // we don't have an audioPacket yet - set that up now
-            _audioPacket = NLPacket::create(PacketType::MicrophoneAudioWithEcho);
+        if (_lastInputLoudness == 0) {
+            packetType = PacketType::SilentAudioFrame;
         }
-
-        glm::vec3 headPosition = _positionGetter();
-        glm::quat headOrientation = _orientationGetter();
-        quint8 isStereo = _isStereoInput ? 1 : 0;
-
-        if (packetType == PacketType::Unknown) {
-            if (_lastInputLoudness == 0) {
-                _audioPacket->setType(PacketType::SilentAudioFrame);
-            } else {
-                if (_shouldEchoToServer) {
-                    _audioPacket->setType(PacketType::MicrophoneAudioWithEcho);
-                } else {
-                    _audioPacket->setType(PacketType::MicrophoneAudioNoEcho);
-                }
-            }
-        } else {
-            _audioPacket->setType(packetType);
-        }
-
-        // reset the audio packet so we can start writing
-        _audioPacket->reset();
-
-        // write sequence number
-        _audioPacket->writePrimitive(_outgoingAvatarAudioSequenceNumber);
-
-        if (_audioPacket->getType() == PacketType::SilentAudioFrame) {
-            // pack num silent samples
-            quint16 numSilentSamples = numNetworkSamples;
-            _audioPacket->writePrimitive(numSilentSamples);
-        } else {
-            // set the mono/stereo byte
-            _audioPacket->writePrimitive(isStereo);
-        }
-
-        // pack the three float positions
-        _audioPacket->writePrimitive(headPosition);
-
-        // pack the orientation
-        _audioPacket->writePrimitive(headOrientation);
-
-        if (_audioPacket->getType() != PacketType::SilentAudioFrame) {
-            // audio samples have already been packed (written to networkAudioSamples)
-            _audioPacket->setPayloadSize(_audioPacket->getPayloadSize() + numNetworkBytes);
-        }
-
-        static const int leadingBytes = sizeof(quint16) + sizeof(glm::vec3) + sizeof(glm::quat) + sizeof(quint8);
-        int16_t* const networkAudioSamples = (int16_t*)(_audioPacket->getPayload() + leadingBytes);
-        memcpy(networkAudioSamples, audioData, numNetworkBytes);
-
+        Transform audioTransform;
+        audioTransform.setTranslation(_positionGetter());
+        audioTransform.setRotation(_orientationGetter());
+        // FIXME find a way to properly handle both playback audio and user audio concurrently
+        emitAudioPacket(networkAudioSamples, numNetworkBytes, _outgoingAvatarAudioSequenceNumber, audioTransform, packetType);
         _stats.sentPacket();
-
-        nodeList->flagTimeForConnectionStep(LimitedNodeList::ConnectionStep::SendAudioPacket);
-
-        nodeList->sendUnreliablePacket(*_audioPacket, *audioMixer);
-
-        _outgoingAvatarAudioSequenceNumber++;
     }
 }
 
 void AudioClient::handleRecordedAudioInput(const QByteArray& audio) {
-    emitAudioPacket((int16_t*)audio.data(), PacketType::MicrophoneAudioWithEcho);
+    Transform audioTransform;
+    audioTransform.setTranslation(_positionGetter());
+    audioTransform.setRotation(_orientationGetter());
+    // FIXME check a flag to see if we should echo audio?
+    emitAudioPacket(audio.data(), audio.size(), _outgoingAvatarAudioSequenceNumber, audioTransform, PacketType::MicrophoneAudioWithEcho);
 }
 
 void AudioClient::processReceivedSamples(const QByteArray& inputBuffer, QByteArray& outputBuffer) {

libraries/audio-client/src/AudioClient.h

@@ -74,9 +74,10 @@ class QAudioInput;
 class QAudioOutput;
 class QIODevice;
 
+
 typedef struct ty_gverb ty_gverb;
 
-
+class Transform;
 class NLPacket;
 
 class AudioClient : public AbstractAudioInterface, public Dependency {
@@ -212,7 +213,6 @@ protected:
     }
 
 private:
-    void emitAudioPacket(const int16_t* audioData, PacketType packetType = PacketType::Unknown);
     void outputFormatChanged();
 
     QByteArray firstInputFrame;
@@ -319,8 +319,6 @@ private:
     void checkDevices();
 
     bool _hasReceivedFirstPacket = false;
-
-    std::unique_ptr<NLPacket> _audioPacket;
 };
 
 

libraries/audio/src/AbstractAudioInterface.cpp

@@ -0,0 +1,61 @@
+//
+//  Created by Bradley Austin Davis on 2015/11/18
+//  Copyright 2013 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "AbstractAudioInterface.h"
+
+#include <QtCore/QSharedPointer>
+
+#include <Node.h>
+#include <NodeType.h>
+#include <DependencyManager.h>
+#include <NodeList.h>
+#include <NLPacket.h>
+#include <Transform.h>
+
+#include "AudioConstants.h"
+
+void AbstractAudioInterface::emitAudioPacket(const void* audioData, size_t bytes, quint16& sequenceNumber, const Transform& transform, PacketType packetType) {
+    static std::mutex _mutex;
+    using Locker = std::unique_lock<std::mutex>;
+    auto nodeList = DependencyManager::get<NodeList>();
+    SharedNodePointer audioMixer = nodeList->soloNodeOfType(NodeType::AudioMixer);
+    if (audioMixer && audioMixer->getActiveSocket()) {
+        Locker lock(_mutex);
+        static std::unique_ptr<NLPacket> audioPacket = NLPacket::create(PacketType::Unknown);
+        quint8 isStereo = bytes == AudioConstants::NETWORK_FRAME_BYTES_STEREO ? 1 : 0;
+        audioPacket->setType(packetType);
+        // reset the audio packet so we can start writing
+        audioPacket->reset();
+        // write sequence number
+        audioPacket->writePrimitive(sequenceNumber++);
+        if (audioPacket->getType() == PacketType::SilentAudioFrame) {
+            // pack num silent samples
+            quint16 numSilentSamples = isStereo ?
+                AudioConstants::NETWORK_FRAME_SAMPLES_STEREO :
+                AudioConstants::NETWORK_FRAME_SAMPLES_PER_CHANNEL;
+            audioPacket->writePrimitive(numSilentSamples);
+        } else {
+            // set the mono/stereo byte
+            audioPacket->writePrimitive(isStereo);
+        }
+
+        // pack the three float positions
+        audioPacket->writePrimitive(transform.getTranslation());
+        // pack the orientation
+        audioPacket->writePrimitive(transform.getRotation());
+
+        if (audioPacket->getType() != PacketType::SilentAudioFrame) {
+            // audio samples have already been packed (written to networkAudioSamples)
+            audioPacket->setPayloadSize(audioPacket->getPayloadSize() + bytes);
+            static const int leadingBytes = sizeof(quint16) + sizeof(glm::vec3) + sizeof(glm::quat) + sizeof(quint8);
+            memcpy(audioPacket->getPayload() + leadingBytes, audioData, bytes);
+        }
+        nodeList->flagTimeForConnectionStep(LimitedNodeList::ConnectionStep::SendAudioPacket);
+        nodeList->sendUnreliablePacket(*audioPacket, *audioMixer);
+    }
+}

libraries/audio/src/AbstractAudioInterface.h

@@ -15,16 +15,21 @@
 #include <QtCore/QObject>
 #include <QtMultimedia/qaudiooutput.h>
 
+#include <udt/PacketHeaders.h>
+
 #include "AudioInjectorOptions.h"
 
 class AudioInjector;
 class AudioInjectorLocalBuffer;
+class Transform;
 
 class AbstractAudioInterface : public QObject {
     Q_OBJECT
 public:
     AbstractAudioInterface(QObject* parent = 0) : QObject(parent) {};
     
+    static void emitAudioPacket(const void* audioData, size_t bytes, quint16& sequenceNumber, const Transform& transform, PacketType packetType);
+
 public slots:
     virtual bool outputLocalInjector(bool isStereo, AudioInjector* injector) = 0;
     

libraries/audio/src/AudioConstants.h

@@ -20,7 +20,9 @@ namespace AudioConstants {
     const int SAMPLE_RATE = 24000;
     
     typedef int16_t AudioSample;
-    
+
+    static const char* AUDIO_FRAME_NAME = "com.highfidelity.recording.Audio";
+
     const int NETWORK_FRAME_BYTES_STEREO = 1024;
     const int NETWORK_FRAME_SAMPLES_STEREO = NETWORK_FRAME_BYTES_STEREO / sizeof(AudioSample);
     const int NETWORK_FRAME_BYTES_PER_CHANNEL = 512;

libraries/avatars/src/AvatarHashMap.cpp

@@ -22,13 +22,9 @@ AvatarHashMap::AvatarHashMap() {
     connect(DependencyManager::get<NodeList>().data(), &NodeList::uuidChanged, this, &AvatarHashMap::sessionUUIDChanged);
 }
 
-void AvatarHashMap::withAvatarHash(std::function<void(const AvatarHash& hash)> callback) {
-    QReadLocker locker(&_hashLock);
-    callback(_avatarHash);
-}
 bool AvatarHashMap::isAvatarInRange(const glm::vec3& position, const float range) {
-    QReadLocker locker(&_hashLock);
-    foreach(const AvatarSharedPointer& sharedAvatar, _avatarHash) {
+    auto hashCopy = getHashCopy();
+    foreach(const AvatarSharedPointer& sharedAvatar, hashCopy) {
         glm::vec3 avatarPosition = sharedAvatar->getPosition();
         float distance = glm::distance(avatarPosition, position);
         if (distance < range) {
@@ -44,16 +40,34 @@ AvatarSharedPointer AvatarHashMap::newSharedAvatar() {
 
 AvatarSharedPointer AvatarHashMap::addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {
     qCDebug(avatars) << "Adding avatar with sessionUUID " << sessionUUID << "to AvatarHashMap.";
-
-    AvatarSharedPointer avatar = newSharedAvatar();
+    
+    auto avatar = newSharedAvatar();
     avatar->setSessionUUID(sessionUUID);
     avatar->setOwningAvatarMixer(mixerWeakPointer);
-    QWriteLocker locker(&_hashLock);
+    
     _avatarHash.insert(sessionUUID, avatar);
     emit avatarAddedEvent(sessionUUID);
+    
     return avatar;
 }
 
+AvatarSharedPointer AvatarHashMap::newOrExistingAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {
+    QWriteLocker locker(&_hashLock);
+    
+    auto avatar = _avatarHash.value(sessionUUID);
+    
+    if (!avatar) {
+        avatar = addAvatar(sessionUUID, mixerWeakPointer);
+    }
+    
+    return avatar;
+}
+
+AvatarSharedPointer AvatarHashMap::findAvatar(const QUuid& sessionUUID) {
+    QReadLocker locker(&_hashLock);
+    return _avatarHash.value(sessionUUID);
+}
+
 void AvatarHashMap::processAvatarDataPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode) {
 
     // enumerate over all of the avatars in this packet
@@ -66,10 +80,7 @@ void AvatarHashMap::processAvatarDataPacket(QSharedPointer<NLPacket> packet, Sha
         QByteArray byteArray = packet->readWithoutCopy(packet->bytesLeftToRead());
         
         if (sessionUUID != _lastOwnerSessionUUID) {
-            AvatarSharedPointer avatar = _avatarHash.value(sessionUUID);
-            if (!avatar) {
-                avatar = addAvatar(sessionUUID, sendingNode);
-            }
+            auto avatar = newOrExistingAvatar(sessionUUID, sendingNode);
             
             // have the matching (or new) avatar parse the data from the packet
             int bytesRead = avatar->parseDataFromBuffer(byteArray);
@@ -97,10 +108,8 @@ void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<NLPacket> packet,
         identityStream >> sessionUUID >> faceMeshURL >> skeletonURL >> attachmentData >> displayName;
 
         // mesh URL for a UUID, find avatar in our list
-        AvatarSharedPointer avatar = _avatarHash.value(sessionUUID);
-        if (!avatar) {
-            avatar = addAvatar(sessionUUID, sendingNode);
-        }
+        auto avatar = newOrExistingAvatar(sessionUUID, sendingNode);
+        
         if (avatar->getFaceModelURL() != faceMeshURL) {
             avatar->setFaceModelURL(faceMeshURL);
         }
@@ -122,10 +131,7 @@ void AvatarHashMap::processAvatarIdentityPacket(QSharedPointer<NLPacket> packet,
 void AvatarHashMap::processAvatarBillboardPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode) {
     QUuid sessionUUID = QUuid::fromRfc4122(packet->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
 
-    AvatarSharedPointer avatar = _avatarHash.value(sessionUUID);
-    if (!avatar) {
-        avatar = addAvatar(sessionUUID, sendingNode);
-    }
+    auto avatar = newOrExistingAvatar(sessionUUID, sendingNode);
 
     QByteArray billboard = packet->read(packet->bytesLeftToRead());
     if (avatar->getBillboard() != billboard) {
@@ -137,13 +143,22 @@ void AvatarHashMap::processKillAvatar(QSharedPointer<NLPacket> packet, SharedNod
     // read the node id
     QUuid sessionUUID = QUuid::fromRfc4122(packet->readWithoutCopy(NUM_BYTES_RFC4122_UUID));
     removeAvatar(sessionUUID);
-
 }
 
 void AvatarHashMap::removeAvatar(const QUuid& sessionUUID) {
     QWriteLocker locker(&_hashLock);
-    _avatarHash.remove(sessionUUID);
-    emit avatarRemovedEvent(sessionUUID);
+    
+    auto removedAvatar = _avatarHash.take(sessionUUID);
+    
+    if (removedAvatar) {
+        handleRemovedAvatar(removedAvatar);
+    }
+}
+
+void AvatarHashMap::handleRemovedAvatar(const AvatarSharedPointer& removedAvatar) {
+    qDebug() << "Removed avatar with UUID" << uuidStringWithoutCurlyBraces(removedAvatar->getSessionUUID())
+        << "from AvatarHashMap";
+    emit avatarRemovedEvent(removedAvatar->getSessionUUID());
 }
 
 void AvatarHashMap::sessionUUIDChanged(const QUuid& sessionUUID, const QUuid& oldUUID) {

libraries/avatars/src/AvatarHashMap.h

@@ -31,7 +31,7 @@ class AvatarHashMap : public QObject, public Dependency {
     SINGLETON_DEPENDENCY
 
 public:
-    void withAvatarHash(std::function<void(const AvatarHash& hash)>);
+    AvatarHash getHashCopy() { QReadLocker lock(&_hashLock); return _avatarHash; }
     int size() { return _avatarHash.size(); }
 
 signals:
@@ -55,7 +55,11 @@ protected:
 
     virtual AvatarSharedPointer newSharedAvatar();
     virtual AvatarSharedPointer addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);
+    AvatarSharedPointer newOrExistingAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer);
+    virtual AvatarSharedPointer findAvatar(const QUuid& sessionUUID); // uses a QReadLocker on the hashLock
     virtual void removeAvatar(const QUuid& sessionUUID);
+    
+    virtual void handleRemovedAvatar(const AvatarSharedPointer& removedAvatar);
 
     AvatarHash _avatarHash;
     // "Case-based safety": Most access to the _avatarHash is on the same thread. Write access is protected by a write-lock.

libraries/embedded-webserver/src/HTTPConnection.cpp

@@ -23,7 +23,9 @@ const char* HTTPConnection::StatusCode301 = "301 Moved Permanently";
 const char* HTTPConnection::StatusCode302 = "302 Found";
 const char* HTTPConnection::StatusCode400 = "400 Bad Request";
 const char* HTTPConnection::StatusCode401 = "401 Unauthorized";
+const char* HTTPConnection::StatusCode403 = "403 Forbidden";
 const char* HTTPConnection::StatusCode404 = "404 Not Found";
+const char* HTTPConnection::StatusCode500 = "500 Internal server error";
 const char* HTTPConnection::DefaultContentType = "text/plain; charset=ISO-8859-1";
 
 HTTPConnection::HTTPConnection (QTcpSocket* socket, HTTPManager* parentManager) :

libraries/embedded-webserver/src/HTTPConnection.h

@@ -47,7 +47,9 @@ public:
     static const char* StatusCode302;
     static const char* StatusCode400;
     static const char* StatusCode401;
+    static const char* StatusCode403;
     static const char* StatusCode404;
+    static const char* StatusCode500;
     static const char* DefaultContentType;
 
     /// WebSocket close status codes.

libraries/entities/src/EntityItem.cpp

@@ -500,6 +500,15 @@ int EntityItem::readEntityDataFromBuffer(const unsigned char* data, int bytesLef
         }
     }
 
+    // before proceeding, check to see if this is an entity that we know has been deleted, which
+    // might happen in the case of out-of-order and/or recorvered packets, if we've deleted the entity
+    // we can confidently ignore this packet
+    EntityTreePointer tree = getTree();
+    if (tree && tree->isDeletedEntity(_id)) {
+        qDebug() << "Recieved packet for previously deleted entity [" << _id << "] ignoring. (inside " << __FUNCTION__ << ")";
+        ignoreServerPacket = true;
+    }
+
     if (ignoreServerPacket) {
         overwriteLocalData = false;
         #ifdef WANT_DEBUG

libraries/entities/src/EntityTree.cpp

@@ -68,6 +68,7 @@ void EntityTree::eraseAllOctreeElements(bool createNewRoot) {
     Octree::eraseAllOctreeElements(createNewRoot);
 
     resetClientEditStats();
+    clearDeletedEntities();
 }
 
 bool EntityTree::handlesEditPacketType(PacketType packetType) const {
@@ -398,6 +399,9 @@ void EntityTree::processRemovedEntities(const DeleteEntityOperator& theOperator)
             // set up the deleted entities ID
             QWriteLocker locker(&_recentlyDeletedEntitiesLock);
             _recentlyDeletedEntityItemIDs.insert(deletedAt, theEntity->getEntityItemID());
+        } else {
+            // on the client side, we also remember that we deleted this entity, we don't care about the time
+            trackDeletedEntity(theEntity->getEntityItemID());
         }
 
         if (_simulation) {

libraries/entities/src/EntityTree.h

@@ -228,6 +228,11 @@ public:
 
     EntityTreePointer getThisPointer() { return std::static_pointer_cast<EntityTree>(shared_from_this()); }
 
+    bool isDeletedEntity(const QUuid& id) {
+        QReadLocker locker(&_deletedEntitiesLock);
+        return _deletedEntityItemIDs.contains(id);
+    }
+
 signals:
     void deletingEntity(const EntityItemID& entityID);
     void addingEntity(const EntityItemID& entityID);
@@ -235,7 +240,7 @@ signals:
     void newCollisionSoundURL(const QUrl& url);
     void clearingEntities();
 
-private:
+protected:
 
     void processRemovedEntities(const DeleteEntityOperator& theOperator);
     bool updateEntityWithElement(EntityItemPointer entity, const EntityItemProperties& properties,
@@ -252,8 +257,22 @@ private:
     QReadWriteLock _newlyCreatedHooksLock;
     QVector<NewlyCreatedEntityHook*> _newlyCreatedHooks;
 
-    mutable QReadWriteLock _recentlyDeletedEntitiesLock;
-    QMultiMap<quint64, QUuid> _recentlyDeletedEntityItemIDs;
+    mutable QReadWriteLock _recentlyDeletedEntitiesLock; /// lock of server side recent deletes
+    QMultiMap<quint64, QUuid> _recentlyDeletedEntityItemIDs; /// server side recent deletes
+
+    mutable QReadWriteLock _deletedEntitiesLock; /// lock of client side recent deletes
+    QSet<QUuid> _deletedEntityItemIDs; /// client side recent deletes
+
+    void clearDeletedEntities() {
+        QWriteLocker locker(&_deletedEntitiesLock);
+        _deletedEntityItemIDs.clear();
+    }
+
+    void trackDeletedEntity(const QUuid& id) {
+        QWriteLocker locker(&_deletedEntitiesLock);
+        _deletedEntityItemIDs << id;
+    }
+
     EntityItemFBXService* _fbxService;
 
     QHash<EntityItemID, EntityTreeElementPointer> _entityToElementMap;

libraries/entities/src/EntityTreeElement.cpp

@@ -894,12 +894,19 @@ int EntityTreeElement::readElementDataFromBuffer(const unsigned char* data, int
                     entityItem = EntityTypes::constructEntityItem(dataAt, bytesLeftToRead, args);
                     if (entityItem) {
                         bytesForThisEntity = entityItem->readEntityDataFromBuffer(dataAt, bytesLeftToRead, args);
-                        addEntityItem(entityItem); // add this new entity to this elements entities
-                        entityItemID = entityItem->getEntityItemID();
-                        _myTree->setContainingElement(entityItemID, getThisPointer());
-                        _myTree->postAddEntity(entityItem);
-                        if (entityItem->getCreated() == UNKNOWN_CREATED_TIME) {
-                            entityItem->recordCreationTime();
+
+                        // don't add if we've recently deleted....
+                        if (!_myTree->isDeletedEntity(entityItem->getID())) {
+                            addEntityItem(entityItem); // add this new entity to this elements entities
+                            entityItemID = entityItem->getEntityItemID();
+                            _myTree->setContainingElement(entityItemID, getThisPointer());
+                            _myTree->postAddEntity(entityItem);
+                            if (entityItem->getCreated() == UNKNOWN_CREATED_TIME) {
+                                entityItem->recordCreationTime();
+                            }
+                        } else {
+                            qDebug() << "Recieved packet for previously deleted entity [" << 
+                                        entityItem->getID() << "] ignoring. (inside " << __FUNCTION__ << ")";
                         }
                     }
                 }

libraries/networking/src/AssetClient.cpp

@@ -365,3 +365,65 @@ void AssetClient::handleNodeKilled(SharedNodePointer node) {
         }
     }
 }
+
+void AssetScriptingInterface::uploadData(QString data, QString extension, QScriptValue callback) {
+    QByteArray dataByteArray = data.toUtf8();
+    auto upload = DependencyManager::get<AssetClient>()->createUpload(dataByteArray, extension);
+    QObject::connect(upload, &AssetUpload::finished, this, [callback, extension](AssetUpload* upload, const QString& hash) mutable {
+        if (callback.isFunction()) {
+            QString url = "atp://" + hash + "." + extension;
+            QScriptValueList args { url };
+            callback.call(QScriptValue(), args);
+        }
+    });
+
+    // start the upload now
+    upload->start();
+}
+
+void AssetScriptingInterface::downloadData(QString urlString, QScriptValue callback) {
+    const QString ATP_SCHEME { "atp://" };
+
+    if (!urlString.startsWith(ATP_SCHEME)) {
+        return;
+    }
+
+    // Make request to atp
+    auto path = urlString.right(urlString.length() - ATP_SCHEME.length());
+    auto parts = path.split(".", QString::SkipEmptyParts);
+    auto hash = parts.length() > 0 ? parts[0] : "";
+    auto extension = parts.length() > 1 ? parts[1] : "";
+
+    if (hash.length() != SHA256_HASH_HEX_LENGTH) {
+        return;
+    }
+
+    auto assetClient = DependencyManager::get<AssetClient>();
+    auto assetRequest = assetClient->createRequest(hash, extension);
+
+    if (!assetRequest) {
+        return;
+    }
+
+    _pendingRequests << assetRequest;
+
+    connect(assetRequest, &AssetRequest::finished, [this, callback](AssetRequest* request) mutable {
+        Q_ASSERT(request->getState() == AssetRequest::Finished);
+
+        if (request->getError() == AssetRequest::Error::NoError) {
+            if (callback.isFunction()) {
+                QString data = QString::fromUtf8(request->getData());
+                QScriptValueList args { data };
+                callback.call(QScriptValue(), args);
+            }
+        }
+
+        request->deleteLater();
+        _pendingRequests.remove(request);
+    });
+
+    assetRequest->start();
+}
+
+
+

libraries/networking/src/AssetClient.h

@@ -14,6 +14,7 @@
 #define hifi_AssetClient_h
 
 #include <QString>
+#include <QScriptValue>
 
 #include <DependencyManager.h>
 
@@ -21,6 +22,7 @@
 #include "LimitedNodeList.h"
 #include "NLPacket.h"
 #include "Node.h"
+#include "ResourceCache.h"
 
 class AssetRequest;
 class AssetUpload;
@@ -68,4 +70,15 @@ private:
     friend class AssetUpload;
 };
 
+
+class AssetScriptingInterface : public QObject {
+    Q_OBJECT
+public:
+    Q_INVOKABLE void uploadData(QString data, QString extension, QScriptValue callback);
+    Q_INVOKABLE void downloadData(QString url, QScriptValue downloadComplete);
+protected:
+    QSet<AssetRequest*> _pendingRequests;
+};
+
+
 #endif

libraries/networking/src/DomainHandler.cpp

@@ -38,12 +38,17 @@ DomainHandler::DomainHandler(QObject* parent) :
     _icePeer(this),
     _isConnected(false),
     _settingsObject(),
-    _failedSettingsRequests(0)
+    _settingsTimer(this)
 {
     _sockAddr.setObjectName("DomainServer");
 
     // if we get a socket that make sure our NetworkPeer ping timer stops
     connect(this, &DomainHandler::completedSocketDiscovery, &_icePeer, &NetworkPeer::stopPingTimer);
+    
+    // setup a timeout for failure on settings requests
+    static const int DOMAIN_SETTINGS_TIMEOUT_MS = 5000;
+    _settingsTimer.setInterval(DOMAIN_SETTINGS_TIMEOUT_MS);
+    connect(&_settingsTimer, &QTimer::timeout, this, &DomainHandler::settingsReceiveFail);
 }
 
 void DomainHandler::disconnect() {
@@ -80,13 +85,16 @@ void DomainHandler::sendDisconnectPacket() {
 
 void DomainHandler::clearSettings() {
     _settingsObject = QJsonObject();
-    _failedSettingsRequests = 0;
 }
 
 void DomainHandler::softReset() {
     qCDebug(networking) << "Resetting current domain connection information.";
     disconnect();
+    
     clearSettings();
+    
+    // cancel the failure timeout for any pending requests for settings
+    QMetaObject::invokeMethod(&_settingsTimer, "stop", Qt::AutoConnection);
 }
 
 void DomainHandler::hardReset() {
@@ -250,34 +258,35 @@ void DomainHandler::requestDomainSettings() {
     
     NodeType_t owningNodeType = DependencyManager::get<NodeList>()->getOwnerType();
     if (owningNodeType == NodeType::Agent) {
-        // for now the agent nodes don't need any settings - this allows local assignment-clients
-        // to connect to a domain that is using automatic networking (since we don't have TCP hole punch yet)
+        // for now the agent nodes don't need any domain settings
         _settingsObject = QJsonObject();
         emit settingsReceived(_settingsObject);
     } else {
-        if (_settingsObject.isEmpty()) {
-            qCDebug(networking) << "Requesting settings from domain server";
-
-            Assignment::Type assignmentType = Assignment::typeForNodeType(DependencyManager::get<NodeList>()->getOwnerType());
-
-            auto packet = NLPacket::create(PacketType::DomainSettingsRequest, sizeof(assignmentType), true, false);
-            packet->writePrimitive(assignmentType);
-
-            auto nodeList = DependencyManager::get<LimitedNodeList>();
-            nodeList->sendPacket(std::move(packet), _sockAddr);
-        }
+        qCDebug(networking) << "Requesting settings from domain server";
+        
+        Assignment::Type assignmentType = Assignment::typeForNodeType(DependencyManager::get<NodeList>()->getOwnerType());
+        
+        auto packet = NLPacket::create(PacketType::DomainSettingsRequest, sizeof(assignmentType), true, false);
+        packet->writePrimitive(assignmentType);
+        
+        auto nodeList = DependencyManager::get<LimitedNodeList>();
+        nodeList->sendPacket(std::move(packet), _sockAddr);
+        
+        _settingsTimer.start();
     }
 }
 
 void DomainHandler::processSettingsPacketList(QSharedPointer<NLPacketList> packetList) {
+    // stop our settings timer since we successfully requested the settings we need
+    _settingsTimer.stop();
+    
     auto data = packetList->getMessage();
 
     _settingsObject = QJsonDocument::fromJson(data).object();
-
-    qCDebug(networking) << "Received domain settings: \n" << QString(data);
-
-    // reset failed settings requests to 0, we got them
-    _failedSettingsRequests = 0;
+    
+    if (!_settingsObject.isEmpty()) {
+        qCDebug(networking) << "Received domain settings: \n" << _settingsObject;
+    }
 
     emit settingsReceived(_settingsObject);
 }

libraries/networking/src/DomainHandler.h

@@ -127,8 +127,8 @@ private:
     NetworkPeer _icePeer;
     bool _isConnected;
     QJsonObject _settingsObject;
-    int _failedSettingsRequests;
     QString _pendingPath;
+    QTimer _settingsTimer;
 };
 
 #endif // hifi_DomainHandler_h

libraries/networking/src/MessagesClient.cpp

@@ -36,7 +36,7 @@ void MessagesClient::init() {
     }
 }
 
-void MessagesClient::handleMessagesPacket(QSharedPointer<NLPacketList> packetList, SharedNodePointer senderNode) {
+void MessagesClient::decodeMessagesPacket(QSharedPointer<NLPacketList> packetList, QString& channel, QString& message, QUuid& senderID) {
     QByteArray packetData = packetList->getMessage();
     QBuffer packet{ &packetData };
     packet.open(QIODevice::ReadOnly);
@@ -44,38 +44,60 @@ void MessagesClient::handleMessagesPacket(QSharedPointer<NLPacketList> packetLis
     quint16 channelLength;
     packet.read(reinterpret_cast<char*>(&channelLength), sizeof(channelLength));
     auto channelData = packet.read(channelLength);
-    QString channel = QString::fromUtf8(channelData);
+    channel = QString::fromUtf8(channelData);
 
     quint16 messageLength;
     packet.read(reinterpret_cast<char*>(&messageLength), sizeof(messageLength));
     auto messageData = packet.read(messageLength);
-    QString message = QString::fromUtf8(messageData);
+    message = QString::fromUtf8(messageData);
 
-    emit messageReceived(channel, message, senderNode->getUUID());
+    QByteArray bytesSenderID = packet.read(NUM_BYTES_RFC4122_UUID);
+    if (bytesSenderID.length() == NUM_BYTES_RFC4122_UUID) {
+        senderID = QUuid::fromRfc4122(bytesSenderID);
+    } else {
+        QUuid emptyUUID;
+        senderID = emptyUUID; // packet was missing UUID use default instead
+    }
 }
 
-void MessagesClient::sendMessage(const QString& channel, const QString& message) {
+std::unique_ptr<NLPacketList> MessagesClient::encodeMessagesPacket(QString channel, QString message, QUuid senderID) {
+    auto packetList = NLPacketList::create(PacketType::MessagesData, QByteArray(), true, true);
+
+    auto channelUtf8 = channel.toUtf8();
+    quint16 channelLength = channelUtf8.length();
+    packetList->writePrimitive(channelLength);
+    packetList->write(channelUtf8);
+
+    auto messageUtf8 = message.toUtf8();
+    quint16 messageLength = messageUtf8.length();
+    packetList->writePrimitive(messageLength);
+    packetList->write(messageUtf8);
+
+    packetList->write(senderID.toRfc4122());
+
+    return packetList;
+}
+
+
+void MessagesClient::handleMessagesPacket(QSharedPointer<NLPacketList> packetList, SharedNodePointer senderNode) {
+    QString channel, message;
+    QUuid senderID;
+    decodeMessagesPacket(packetList, channel, message, senderID);
+    emit messageReceived(channel, message, senderID);
+}
+
+void MessagesClient::sendMessage(QString channel, QString message) {
     auto nodeList = DependencyManager::get<NodeList>();
     SharedNodePointer messagesMixer = nodeList->soloNodeOfType(NodeType::MessagesMixer);
     
     if (messagesMixer) {
-        auto packetList = NLPacketList::create(PacketType::MessagesData, QByteArray(), true, true);
-
-        auto channelUtf8 = channel.toUtf8();
-        quint16 channelLength = channelUtf8.length();
-        packetList->writePrimitive(channelLength);
-        packetList->write(channelUtf8);
-
-        auto messageUtf8 = message.toUtf8();
-        quint16 messageLength = messageUtf8.length();
-        packetList->writePrimitive(messageLength);
-        packetList->write(messageUtf8);
-
+        QUuid senderID = nodeList->getSessionUUID();
+        auto packetList = encodeMessagesPacket(channel, message, senderID);
         nodeList->sendPacketList(std::move(packetList), *messagesMixer);
     }
 }
 
-void MessagesClient::subscribe(const QString& channel) {
+void MessagesClient::subscribe(QString channel) {
     _subscribedChannels << channel;
     auto nodeList = DependencyManager::get<NodeList>();
     SharedNodePointer messagesMixer = nodeList->soloNodeOfType(NodeType::MessagesMixer);
@@ -87,7 +109,7 @@ void MessagesClient::subscribe(const QString& channel) {
     }
 }
 
-void MessagesClient::unsubscribe(const QString& channel) {
+void MessagesClient::unsubscribe(QString channel) {
     _subscribedChannels.remove(channel);
     auto nodeList = DependencyManager::get<NodeList>();
     SharedNodePointer messagesMixer = nodeList->soloNodeOfType(NodeType::MessagesMixer);

libraries/networking/src/MessagesClient.h

@@ -28,12 +28,16 @@ public:
     
     Q_INVOKABLE void init();
 
-    Q_INVOKABLE void sendMessage(const QString& channel, const QString& message);
-    Q_INVOKABLE void subscribe(const QString& channel);
-    Q_INVOKABLE void unsubscribe(const QString& channel);
+    Q_INVOKABLE void sendMessage(QString channel, QString message);
+    Q_INVOKABLE void subscribe(QString channel);
+    Q_INVOKABLE void unsubscribe(QString channel);
+
+    static void decodeMessagesPacket(QSharedPointer<NLPacketList> packetList, QString& channel, QString& message, QUuid& senderID);
+    static std::unique_ptr<NLPacketList> encodeMessagesPacket(QString channel, QString message, QUuid senderID);
+
 
 signals:
-    void messageReceived(const QString& channel, const QString& message, const QUuid& senderUUID);
+    void messageReceived(QString channel, QString message, QUuid senderUUID);
 
 private slots:
     void handleMessagesPacket(QSharedPointer<NLPacketList> packetList, SharedNodePointer senderNode);

libraries/networking/src/ThreadedAssignment.cpp

@@ -77,6 +77,9 @@ void ThreadedAssignment::commonInit(const QString& targetName, NodeType_t nodeTy
     connect(_domainServerTimer, SIGNAL(timeout()), this, SLOT(checkInWithDomainServerOrExit()));
     _domainServerTimer->start(DOMAIN_SERVER_CHECK_IN_MSECS);
     
+    // send a domain-server check in immediately
+    checkInWithDomainServerOrExit();
+    
     // move the domain server time to the NL so check-ins fire from there
     _domainServerTimer->moveToThread(nodeList->thread());
 
@@ -130,3 +133,8 @@ void ThreadedAssignment::checkInWithDomainServerOrExit() {
         DependencyManager::get<NodeList>()->sendDomainServerCheckIn();
     }
 }
+
+void ThreadedAssignment::domainSettingsRequestFailed() {
+    qDebug() << "Failed to retreive settings object from domain-server. Bailing on assignment.";
+    setFinished(true);
+}

libraries/networking/src/ThreadedAssignment.h

@@ -40,7 +40,10 @@ protected:
     bool _isFinished;
     QTimer* _domainServerTimer = nullptr;
     QTimer* _statsTimer = nullptr;
-
+    
+protected slots:
+    void domainSettingsRequestFailed();
+    
 private slots:
     void startSendingStats();
     void stopSendingStats();

libraries/networking/src/udt/SendQueue.cpp

@@ -395,7 +395,7 @@ bool SendQueue::isInactive(bool sentAPacket) {
             
 #ifdef UDT_CONNECTION_DEBUG
             qCDebug(networking) << "SendQueue to" << _destination << "reached" << NUM_TIMEOUTS_BEFORE_INACTIVE << "timeouts"
-            << "and 5s before receiving any ACK/NAK and is now inactive. Stopping.";
+                << "and 5s before receiving any ACK/NAK and is now inactive. Stopping.";
 #endif
             
             deactivate();
@@ -427,9 +427,9 @@ bool SendQueue::isInactive(bool sentAPacket) {
                 if (cvStatus == std::cv_status::timeout) {
 #ifdef UDT_CONNECTION_DEBUG
                     qCDebug(networking) << "SendQueue to" << _destination << "has been empty for"
-                    << EMPTY_QUEUES_INACTIVE_TIMEOUT.count()
-                    << "seconds and receiver has ACKed all packets."
-                    << "The queue is now inactive and will be stopped.";
+                        << EMPTY_QUEUES_INACTIVE_TIMEOUT.count()
+                        << "seconds and receiver has ACKed all packets."
+                        << "The queue is now inactive and will be stopped.";
 #endif
                     
                     // Deactivate queue

libraries/octree/src/Octree.cpp

@@ -1841,6 +1841,7 @@ bool Octree::readFromStream(unsigned long streamLength, QDataStream& inputStream
 
 
 bool Octree::readSVOFromStream(unsigned long streamLength, QDataStream& inputStream) {
+    qWarning() << "SVO file format depricated. Support for reading SVO files is no longer support and will be removed soon.";
 
     bool fileOk = false;
 
@@ -2062,6 +2063,8 @@ void Octree::writeToJSONFile(const char* fileName, OctreeElementPointer element,
 }
 
 void Octree::writeToSVOFile(const char* fileName, OctreeElementPointer element) {
+    qWarning() << "SVO file format depricated. Support for reading SVO files is no longer support and will be removed soon.";
+
     std::ofstream file(fileName, std::ios::out|std::ios::binary);
 
     if(file.is_open()) {

libraries/octree/src/OctreeConstants.h

@@ -24,7 +24,7 @@ const int HALF_TREE_SCALE = TREE_SCALE / 2;
 const float DEFAULT_OCTREE_SIZE_SCALE = TREE_SCALE * 400.0f; 
 
 // This is used in the LOD Tools to translate between the size scale slider and the values used to set the OctreeSizeScale
-const float MAX_LOD_SIZE_MULTIPLIER = 800.0f;
+const float MAX_LOD_SIZE_MULTIPLIER = 4000.0f;
 
 const int NUMBER_OF_CHILDREN = 8;
 

libraries/octree/src/OctreePersistThread.cpp

@@ -52,6 +52,15 @@ OctreePersistThread::OctreePersistThread(OctreePointer tree, const QString& file
     _filename = sansExt + "." + _persistAsFileType;
 }
 
+QString OctreePersistThread::getPersistFileMimeType() const {
+    if (_persistAsFileType == "json") {
+        return "application/json";
+    } if (_persistAsFileType == "json.gz") {
+        return "application/zip";
+    }
+    return "";
+}
+
 void OctreePersistThread::parseSettings(const QJsonObject& settings) {
     if (settings["backups"].isArray()) {
         const QJsonArray& backupRules = settings["backups"].toArray();
@@ -229,6 +238,15 @@ void OctreePersistThread::aboutToFinish() {
     _stopThread = true;
 }
 
+QByteArray OctreePersistThread::getPersistFileContents() const {
+    QByteArray fileContents;
+    QFile file(_filename);
+    if (file.open(QIODevice::ReadOnly)) {
+        fileContents = file.readAll();
+    }
+    return fileContents;
+}
+
 void OctreePersistThread::persist() {
     if (_tree->isDirty()) {
 

libraries/octree/src/OctreePersistThread.h

@@ -42,6 +42,10 @@ public:
 
     void aboutToFinish(); /// call this to inform the persist thread that the owner is about to finish to support final persist
 
+    QString getPersistFilename() const { return _filename; }
+    QString getPersistFileMimeType() const;
+    QByteArray getPersistFileContents() const;
+
 signals:
     void loadCompleted();
 

libraries/recording/CMakeLists.txt

@@ -4,6 +4,6 @@ set(TARGET_NAME recording)
 setup_hifi_library(Script)
 
 # use setup_hifi_library macro to setup our project and link appropriate Qt modules
-link_hifi_libraries(shared)
+link_hifi_libraries(shared networking)
 
 GroupSources("src/recording")

libraries/recording/src/recording/Clip.cpp

@@ -13,6 +13,11 @@
 #include "impl/FileClip.h"
 #include "impl/BufferClip.h"
 
+#include <QtCore/QJsonDocument>
+#include <QtCore/QJsonObject>
+#include <QtCore/QBuffer>
+#include <QtCore/QDebug>
+
 using namespace recording;
 
 Clip::Pointer Clip::fromFile(const QString& filePath) {
@@ -27,6 +32,15 @@ void Clip::toFile(const QString& filePath, const Clip::ConstPointer& clip) {
     FileClip::write(filePath, clip->duplicate());
 }
 
+QByteArray Clip::toBuffer(const Clip::ConstPointer& clip) {
+    QBuffer buffer;
+    if (buffer.open(QFile::Truncate | QFile::WriteOnly)) {
+        clip->duplicate()->write(buffer);
+        buffer.close();
+    }
+    return buffer.data();
+}
+
 Clip::Pointer Clip::newClip() {
     return std::make_shared<BufferClip>();
 }
@@ -37,4 +51,70 @@ void Clip::seek(float offset) {
 
 float Clip::position() const {
     return Frame::frameTimeToSeconds(positionFrameTime());
-};
+}
+
+// FIXME move to frame?
+bool writeFrame(QIODevice& output, const Frame& frame, bool compressed = true) {
+    if (frame.type == Frame::TYPE_INVALID) {
+        qWarning() << "Attempting to write invalid frame";
+        return true;
+    }
+
+    auto written = output.write((char*)&(frame.type), sizeof(FrameType));
+    if (written != sizeof(FrameType)) {
+        return false;
+    }
+    //qDebug() << "Writing frame with time offset " << frame.timeOffset;
+    written = output.write((char*)&(frame.timeOffset), sizeof(Frame::Time));
+    if (written != sizeof(Frame::Time)) {
+        return false;
+    }
+    QByteArray frameData = frame.data;
+    if (compressed) {
+        frameData = qCompress(frameData);
+    }
+
+    uint16_t dataSize = frameData.size();
+    written = output.write((char*)&dataSize, sizeof(FrameSize));
+    if (written != sizeof(uint16_t)) {
+        return false;
+    }
+
+    if (dataSize != 0) {
+        written = output.write(frameData);
+        if (written != dataSize) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const QString Clip::FRAME_TYPE_MAP = QStringLiteral("frameTypes");
+const QString Clip::FRAME_COMREPSSION_FLAG = QStringLiteral("compressed");
+
+bool Clip::write(QIODevice& output) {
+    auto frameTypes = Frame::getFrameTypes();
+    QJsonObject frameTypeObj;
+    for (const auto& frameTypeName : frameTypes.keys()) {
+        frameTypeObj[frameTypeName] = frameTypes[frameTypeName];
+    }
+
+    QJsonObject rootObject;
+    rootObject.insert(FRAME_TYPE_MAP, frameTypeObj);
+    // Always mark new files as compressed
+    rootObject.insert(FRAME_COMREPSSION_FLAG, true);
+    QByteArray headerFrameData = QJsonDocument(rootObject).toBinaryData();
+    // Never compress the header frame
+    if (!writeFrame(output, Frame({ Frame::TYPE_HEADER, 0, headerFrameData }), false)) {
+        return false;
+    }
+
+    seek(0);
+
+    for (auto frame = nextFrame(); frame; frame = nextFrame()) {
+        if (!writeFrame(output, *frame)) {
+            return false;
+        }
+    }
+    return true;
+}

libraries/recording/src/recording/Clip.h

@@ -47,10 +47,16 @@ public:
     virtual void skipFrame() = 0;
     virtual void addFrame(FrameConstPointer) = 0;
 
+    bool write(QIODevice& output);
+
     static Pointer fromFile(const QString& filePath);
     static void toFile(const QString& filePath, const ConstPointer& clip);
+    static QByteArray toBuffer(const ConstPointer& clip);
     static Pointer newClip();
     
+    static const QString FRAME_TYPE_MAP;
+    static const QString FRAME_COMREPSSION_FLAG;
+
 protected:
     friend class WrapperClip;
     using Mutex = std::recursive_mutex;

libraries/recording/src/recording/ClipCache.cpp

@@ -0,0 +1,40 @@
+//
+//  Created by Bradley Austin Davis on 2015/11/19
+//  Copyright 2015 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 "ClipCache.h"
+#include "impl/PointerClip.h"
+
+using namespace recording;
+NetworkClipLoader::NetworkClipLoader(const QUrl& url, bool delayLoad)
+    : Resource(url, delayLoad), _clip(std::make_shared<NetworkClip>(url))
+{
+    
+}
+
+
+void NetworkClip::init(const QByteArray& clipData) {
+    _clipData = clipData;
+    PointerClip::init((uchar*)_clipData.data(), _clipData.size());
+}
+
+void NetworkClipLoader::downloadFinished(const QByteArray& data) {
+    _clip->init(data);
+}
+
+ClipCache& ClipCache::instance() {
+    static ClipCache _instance;
+    return _instance;
+}
+
+NetworkClipLoaderPointer ClipCache::getClipLoader(const QUrl& url) {
+    return ResourceCache::getResource(url, QUrl(), false, nullptr).staticCast<NetworkClipLoader>();
+}
+
+QSharedPointer<Resource> ClipCache::createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) {
+    return QSharedPointer<Resource>(new NetworkClipLoader(url, delayLoad), &Resource::allReferencesCleared);
+}
+

libraries/recording/src/recording/ClipCache.h

@@ -0,0 +1,57 @@
+//
+//  Created by Bradley Austin Davis on 2015/11/19
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+#pragma once
+#ifndef hifi_Recording_ClipCache_h
+#define hifi_Recording_ClipCache_h
+
+#include <ResourceCache.h>
+
+#include "Forward.h"
+#include "impl/PointerClip.h"
+
+namespace recording {
+
+class NetworkClip : public PointerClip {
+public:
+    using Pointer = std::shared_ptr<NetworkClip>;
+
+    NetworkClip(const QUrl& url) : _url(url) {}
+    virtual void init(const QByteArray& clipData);
+    virtual QString getName() const override { return _url.toString(); }
+
+private:
+    QByteArray _clipData;
+    QUrl _url;
+};
+
+class NetworkClipLoader : public Resource {
+public:
+    NetworkClipLoader(const QUrl& url, bool delayLoad);
+    virtual void downloadFinished(const QByteArray& data) override;
+    ClipPointer getClip() { return _clip; }
+    bool completed() { return _failedToLoad || isLoaded(); }
+
+private:
+    const NetworkClip::Pointer _clip;
+};
+
+using NetworkClipLoaderPointer = QSharedPointer<NetworkClipLoader>;
+
+class ClipCache : public ResourceCache {
+public:
+    static ClipCache& instance();
+
+    NetworkClipLoaderPointer getClipLoader(const QUrl& url);
+
+protected:
+    virtual QSharedPointer<Resource> createResource(const QUrl& url, const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) override;
+};
+
+}
+
+#endif

libraries/recording/src/recording/Frame.cpp

@@ -131,6 +131,25 @@ Frame::Handler Frame::registerFrameHandler(FrameType type, Handler handler) {
     return result;
 }
 
+Frame::Handler Frame::registerFrameHandler(const QString& frameTypeName, Handler handler) {
+    auto frameType = registerFrameType(frameTypeName);
+    return registerFrameHandler(frameType, handler);
+}
+
+void Frame::clearFrameHandler(FrameType type) {
+    Locker lock(mutex);
+    auto iterator = handlerMap.find(type);
+    if (iterator != handlerMap.end()) {
+        handlerMap.erase(iterator);
+    }
+}
+
+void Frame::clearFrameHandler(const QString& frameTypeName) {
+    auto frameType = registerFrameType(frameTypeName);
+    clearFrameHandler(frameType); 
+}
+
+
 void Frame::handleFrame(const Frame::ConstPointer& frame) {
     Handler handler; 
     {

libraries/recording/src/recording/Frame.h

@@ -55,9 +55,12 @@ public:
         : FrameHeader(type, timeOffset), data(data) { }
 
     static FrameType registerFrameType(const QString& frameTypeName);
+    static Handler registerFrameHandler(FrameType type, Handler handler);
+    static Handler registerFrameHandler(const QString& frameTypeName, Handler handler);
+    static void clearFrameHandler(FrameType type);
+    static void clearFrameHandler(const QString& frameTypeName);
     static QMap<QString, FrameType> getFrameTypes();
     static QMap<FrameType, QString> getFrameTypeNames();
-    static Handler registerFrameHandler(FrameType type, Handler handler);
     static void handleFrame(const ConstPointer& frame);
 };
 

libraries/recording/src/recording/impl/FileClip.cpp

@@ -11,8 +11,6 @@
 #include <algorithm>
 
 #include <QtCore/QDebug>
-#include <QtCore/QJsonDocument>
-#include <QtCore/QJsonObject>
 
 #include <Finally.h>
 
@@ -23,122 +21,16 @@
 
 using namespace recording;
 
-static const qint64 MINIMUM_FRAME_SIZE = sizeof(FrameType) + sizeof(Frame::Time) + sizeof(FrameSize);
-static const QString FRAME_TYPE_MAP = QStringLiteral("frameTypes");
-static const QString FRAME_COMREPSSION_FLAG = QStringLiteral("compressed");
-
-using FrameTranslationMap = QMap<FrameType, FrameType>;
-
-FrameTranslationMap parseTranslationMap(const QJsonDocument& doc) {
-    FrameTranslationMap results;
-    auto headerObj = doc.object();
-    if (headerObj.contains(FRAME_TYPE_MAP)) {
-        auto frameTypeObj = headerObj[FRAME_TYPE_MAP].toObject();
-        auto currentFrameTypes = Frame::getFrameTypes();
-        for (auto frameTypeName : frameTypeObj.keys()) {
-            qDebug() << frameTypeName;
-            if (!currentFrameTypes.contains(frameTypeName)) {
-                continue;
-            }
-            FrameType currentTypeEnum = currentFrameTypes[frameTypeName];
-            FrameType storedTypeEnum = static_cast<FrameType>(frameTypeObj[frameTypeName].toInt());
-            results[storedTypeEnum] = currentTypeEnum;
-        }
-    }
-    return results;
-}
-
-
-FileFrameHeaderList parseFrameHeaders(uchar* const start, const qint64& size) {
-    FileFrameHeaderList results;
-    auto current = start;
-    auto end = current + size;
-    // Read all the frame headers
-    // FIXME move to Frame::readHeader?
-    while (end - current >= MINIMUM_FRAME_SIZE) {
-        FileFrameHeader header;
-        memcpy(&(header.type), current, sizeof(FrameType));
-        current += sizeof(FrameType);
-        memcpy(&(header.timeOffset), current, sizeof(Frame::Time));
-        current += sizeof(Frame::Time);
-        memcpy(&(header.size), current, sizeof(FrameSize));
-        current += sizeof(FrameSize);
-        header.fileOffset = current - start;
-        if (end - current < header.size) {
-            current = end;
-            break;
-        }
-        current += header.size;
-        results.push_back(header);
-    }
-    qDebug() << "Parsed source data into " << results.size() << " frames";
-    int i = 0;
-    for (const auto& frameHeader : results) {
-        qDebug() << "Frame " << i++ << " time " << frameHeader.timeOffset;
-    }
-    return results;
-}
-
-
 FileClip::FileClip(const QString& fileName) : _file(fileName) {
     auto size = _file.size();
+    qDebug() << "Opening file of size: " << size;
     bool opened = _file.open(QIODevice::ReadOnly);
     if (!opened) {
         qCWarning(recordingLog) << "Unable to open file " << fileName;
         return;
     }
-    _map = _file.map(0, size, QFile::MapPrivateOption);
-    if (!_map) {
-        qCWarning(recordingLog) << "Unable to map file " << fileName;
-        return;
-    }
-
-    auto parsedFrameHeaders = parseFrameHeaders(_map, size);
-
-    // Verify that at least one frame exists and that the first frame is a header
-    if (0 == parsedFrameHeaders.size()) {
-        qWarning() << "No frames found, invalid file";
-        return;
-    }
-
-    // Grab the file header
-    {
-        auto fileHeaderFrameHeader = *parsedFrameHeaders.begin();
-        parsedFrameHeaders.pop_front();
-        if (fileHeaderFrameHeader.type != Frame::TYPE_HEADER) {
-            qWarning() << "Missing header frame, invalid file";
-            return;
-        }
-
-        QByteArray fileHeaderData((char*)_map + fileHeaderFrameHeader.fileOffset, fileHeaderFrameHeader.size);
-        _fileHeader = QJsonDocument::fromBinaryData(fileHeaderData);
-    }
-
-    // Check for compression
-    {
-        _compressed = _fileHeader.object()[FRAME_COMREPSSION_FLAG].toBool();
-    }
-
-    // Find the type enum translation map and fix up the frame headers
-    {
-        FrameTranslationMap translationMap = parseTranslationMap(_fileHeader);
-        if (translationMap.empty()) {
-            qWarning() << "Header missing frame type map, invalid file";
-            return;
-        }
-        qDebug() << translationMap;
-
-        // Update the loaded headers with the frame data
-        _frames.reserve(parsedFrameHeaders.size());
-        for (auto& frameHeader : parsedFrameHeaders) {
-            if (!translationMap.contains(frameHeader.type)) {
-                continue;
-            }
-            frameHeader.type = translationMap[frameHeader.type];
-            _frames.push_back(frameHeader);
-        }
-    }
-
+    auto mappedFile = _file.map(0, size, QFile::MapPrivateOption);
+    init(mappedFile, size);
 }
 
 
@@ -146,41 +38,7 @@ QString FileClip::getName() const {
     return _file.fileName();
 }
 
-// FIXME move to frame?
-bool writeFrame(QIODevice& output, const Frame& frame, bool compressed = true) {
-    if (frame.type == Frame::TYPE_INVALID) {
-        qWarning() << "Attempting to write invalid frame";
-        return true;
-    }
 
-    auto written = output.write((char*)&(frame.type), sizeof(FrameType));
-    if (written != sizeof(FrameType)) {
-        return false;
-    }
-    //qDebug() << "Writing frame with time offset " << frame.timeOffset;
-    written = output.write((char*)&(frame.timeOffset), sizeof(Frame::Time));
-    if (written != sizeof(Frame::Time)) {
-        return false;
-    }
-    QByteArray frameData = frame.data;
-    if (compressed) {
-        frameData = qCompress(frameData);
-    }
-
-    uint16_t dataSize = frameData.size();
-    written = output.write((char*)&dataSize, sizeof(FrameSize));
-    if (written != sizeof(uint16_t)) {
-        return false;
-    }
-
-    if (dataSize != 0) {
-        written = output.write(frameData);
-        if (written != dataSize) {
-            return false;
-        }
-    }
-    return true;
-}
 
 bool FileClip::write(const QString& fileName, Clip::Pointer clip) {
     // FIXME need to move this to a different thread
@@ -196,62 +54,14 @@ bool FileClip::write(const QString& fileName, Clip::Pointer clip) {
     }
 
     Finally closer([&] { outputFile.close(); });
-    {
-        auto frameTypes = Frame::getFrameTypes();
-        QJsonObject frameTypeObj;
-        for (const auto& frameTypeName : frameTypes.keys()) {
-            frameTypeObj[frameTypeName] = frameTypes[frameTypeName];
-        }
-
-        QJsonObject rootObject;
-        rootObject.insert(FRAME_TYPE_MAP, frameTypeObj);
-        // Always mark new files as compressed
-        rootObject.insert(FRAME_COMREPSSION_FLAG, true);
-        QByteArray headerFrameData = QJsonDocument(rootObject).toBinaryData();
-        // Never compress the header frame
-        if (!writeFrame(outputFile, Frame({ Frame::TYPE_HEADER, 0, headerFrameData }), false)) {
-            return false;
-        }
-
-    }
-
-    clip->seek(0);
-    for (auto frame = clip->nextFrame(); frame; frame = clip->nextFrame()) {
-        if (!writeFrame(outputFile, *frame)) {
-            return false;
-        }
-    }
-    outputFile.close();
-    return true;
+    return clip->write(outputFile);
 }
 
 FileClip::~FileClip() {
     Locker lock(_mutex);
-    _file.unmap(_map);
-    _map = nullptr;
+    _file.unmap(_data);
     if (_file.isOpen()) {
         _file.close();
     }
-}
-
-// Internal only function, needs no locking
-FrameConstPointer FileClip::readFrame(size_t frameIndex) const {
-    FramePointer result;
-    if (frameIndex < _frames.size()) {
-        result = std::make_shared<Frame>();
-        const auto& header = _frames[frameIndex];
-        result->type = header.type;
-        result->timeOffset = header.timeOffset;
-        if (header.size) {
-            result->data.insert(0, reinterpret_cast<char*>(_map)+header.fileOffset, header.size);
-            if (_compressed) {
-                result->data = qUncompress(result->data);
-            }
-        }
-    }
-    return result;
-}
-
-void FileClip::addFrame(FrameConstPointer) {
-    throw std::runtime_error("File clips are read only");
+    reset();
 }

libraries/recording/src/recording/impl/FileClip.h

@@ -10,27 +10,13 @@
 #ifndef hifi_Recording_Impl_FileClip_h
 #define hifi_Recording_Impl_FileClip_h
 
-#include "ArrayClip.h"
-
-#include <mutex>
+#include "PointerClip.h"
 
 #include <QtCore/QFile>
-#include <QtCore/QJsonDocument>
-
-#include "../Frame.h"
 
 namespace recording {
 
-struct FileFrameHeader : public FrameHeader {
-    FrameType type;
-    Frame::Time timeOffset;
-    uint16_t size;
-    quint64 fileOffset;
-};
-
-using FileFrameHeaderList = std::list<FileFrameHeader>;
-
-class FileClip : public ArrayClip<FileFrameHeader> {
+class FileClip : public PointerClip {
 public:
     using Pointer = std::shared_ptr<FileClip>;
 
@@ -38,20 +24,11 @@ public:
     virtual ~FileClip();
 
     virtual QString getName() const override;
-    virtual void addFrame(FrameConstPointer) override;
-
-    const QJsonDocument& getHeader() {
-        return _fileHeader;
-    }
 
     static bool write(const QString& filePath, Clip::Pointer clip);
 
 private:
-    virtual FrameConstPointer readFrame(size_t index) const override;
-    QJsonDocument _fileHeader;
     QFile _file;
-    uchar* _map { nullptr };
-    bool _compressed { true };
 };
 
 }

libraries/recording/src/recording/impl/PointerClip.cpp

@@ -0,0 +1,160 @@
+//
+//  Created by Bradley Austin Davis 2015/11/04
+//  Copyright 2015 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 "PointerClip.h"
+
+#include <algorithm>
+
+#include <QtCore/QDebug>
+#include <QtCore/QJsonDocument>
+#include <QtCore/QJsonObject>
+
+#include <Finally.h>
+
+#include "../Frame.h"
+#include "../Logging.h"
+#include "BufferClip.h"
+
+
+using namespace recording;
+
+using FrameTranslationMap = QMap<FrameType, FrameType>;
+
+FrameTranslationMap parseTranslationMap(const QJsonDocument& doc) {
+    FrameTranslationMap results;
+    auto headerObj = doc.object();
+    if (headerObj.contains(Clip::FRAME_TYPE_MAP)) {
+        auto frameTypeObj = headerObj[Clip::FRAME_TYPE_MAP].toObject();
+        auto currentFrameTypes = Frame::getFrameTypes();
+        for (auto frameTypeName : frameTypeObj.keys()) {
+            qDebug() << frameTypeName;
+            if (!currentFrameTypes.contains(frameTypeName)) {
+                continue;
+            }
+            FrameType currentTypeEnum = currentFrameTypes[frameTypeName];
+            FrameType storedTypeEnum = static_cast<FrameType>(frameTypeObj[frameTypeName].toInt());
+            results[storedTypeEnum] = currentTypeEnum;
+        }
+    }
+    return results;
+}
+
+
+PointerFrameHeaderList parseFrameHeaders(uchar* const start, const size_t& size) {
+    PointerFrameHeaderList results;
+    auto current = start;
+    auto end = current + size;
+    // Read all the frame headers
+    // FIXME move to Frame::readHeader?
+    while (end - current >= PointerClip::MINIMUM_FRAME_SIZE) {
+        PointerFrameHeader header;
+        memcpy(&(header.type), current, sizeof(FrameType));
+        current += sizeof(FrameType);
+        memcpy(&(header.timeOffset), current, sizeof(Frame::Time));
+        current += sizeof(Frame::Time);
+        memcpy(&(header.size), current, sizeof(FrameSize));
+        current += sizeof(FrameSize);
+        header.fileOffset = current - start;
+        if (end - current < header.size) {
+            current = end;
+            break;
+        }
+        current += header.size;
+        results.push_back(header);
+    }
+    qDebug() << "Parsed source data into " << results.size() << " frames";
+//    int i = 0;
+//    for (const auto& frameHeader : results) {
+//        qDebug() << "Frame " << i++ << " time " << frameHeader.timeOffset << " Type " << frameHeader.type;
+//    }
+    return results;
+}
+
+void PointerClip::reset() {
+    _frames.clear();
+    _data = nullptr;
+    _size = 0;
+    _header = QJsonDocument();
+}
+
+void PointerClip::init(uchar* data, size_t size) {
+    reset();
+
+    _data = data;
+    _size = size;
+
+    auto parsedFrameHeaders = parseFrameHeaders(data, size);
+    // Verify that at least one frame exists and that the first frame is a header
+    if (0 == parsedFrameHeaders.size()) {
+        qWarning() << "No frames found, invalid file";
+        reset();
+        return;
+    }
+
+    // Grab the file header
+    {
+        auto fileHeaderFrameHeader = *parsedFrameHeaders.begin();
+        parsedFrameHeaders.pop_front();
+        if (fileHeaderFrameHeader.type != Frame::TYPE_HEADER) {
+            qWarning() << "Missing header frame, invalid file";
+            reset();
+            return;
+        }
+
+        QByteArray fileHeaderData((char*)_data + fileHeaderFrameHeader.fileOffset, fileHeaderFrameHeader.size);
+        _header = QJsonDocument::fromBinaryData(fileHeaderData);
+    }
+
+    // Check for compression
+    {
+        _compressed = _header.object()[FRAME_COMREPSSION_FLAG].toBool();
+    }
+
+    // Find the type enum translation map and fix up the frame headers
+    {
+        FrameTranslationMap translationMap = parseTranslationMap(_header);
+        if (translationMap.empty()) {
+            qWarning() << "Header missing frame type map, invalid file";
+            reset();
+            return;
+        }
+
+        // Update the loaded headers with the frame data
+        _frames.reserve(parsedFrameHeaders.size());
+        for (auto& frameHeader : parsedFrameHeaders) {
+            if (!translationMap.contains(frameHeader.type)) {
+                continue;
+            }
+            frameHeader.type = translationMap[frameHeader.type];
+            _frames.push_back(frameHeader);
+        }
+    }
+
+}
+
+// Internal only function, needs no locking
+FrameConstPointer PointerClip::readFrame(size_t frameIndex) const {
+    FramePointer result;
+    if (frameIndex < _frames.size()) {
+        result = std::make_shared<Frame>();
+        const auto& header = _frames[frameIndex];
+        result->type = header.type;
+        result->timeOffset = header.timeOffset;
+        if (header.size) {
+            result->data.insert(0, reinterpret_cast<char*>(_data)+header.fileOffset, header.size);
+            if (_compressed) {
+                result->data = qUncompress(result->data);
+            }
+        }
+    }
+    return result;
+}
+
+void PointerClip::addFrame(FrameConstPointer) {
+    throw std::runtime_error("Pointer clips are read only, use duplicate to create a read/write clip");
+}

libraries/recording/src/recording/impl/PointerClip.h

@@ -0,0 +1,58 @@
+//
+//  Created by Bradley Austin Davis 2015/11/05
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#pragma once
+#ifndef hifi_Recording_Impl_PointerClip_h
+#define hifi_Recording_Impl_PointerClip_h
+
+#include "ArrayClip.h"
+
+#include <mutex>
+
+#include <QtCore/QJsonDocument>
+
+#include "../Frame.h"
+
+namespace recording {
+
+struct PointerFrameHeader : public FrameHeader {
+    FrameType type;
+    Frame::Time timeOffset;
+    uint16_t size;
+    quint64 fileOffset;
+};
+
+using PointerFrameHeaderList = std::list<PointerFrameHeader>;
+
+class PointerClip : public ArrayClip<PointerFrameHeader> {
+public:
+    using Pointer = std::shared_ptr<PointerClip>;
+
+    PointerClip() {};
+    PointerClip(uchar* data, size_t size) { init(data, size); }
+
+    void init(uchar* data, size_t size);
+    virtual void addFrame(FrameConstPointer) override;
+    const QJsonDocument& getHeader() const {
+        return _header;
+    }
+
+    // FIXME move to frame?
+    static const qint64 MINIMUM_FRAME_SIZE = sizeof(FrameType) + sizeof(Frame::Time) + sizeof(FrameSize);
+protected:
+    void reset();
+    virtual FrameConstPointer readFrame(size_t index) const override;
+    QJsonDocument _header;
+    uchar* _data { nullptr };
+    size_t _size { 0 };
+    bool _compressed { true };
+};
+
+}
+
+#endif

libraries/script-engine/src/RecordingScriptingInterface.cpp

@@ -8,50 +8,24 @@
 
 #include "RecordingScriptingInterface.h"
 
-#include <QThread>
+#include <QtCore/QThread>
 
+#include <NumericalConstants.h>
+#include <Transform.h>
 #include <recording/Deck.h>
 #include <recording/Recorder.h>
 #include <recording/Clip.h>
 #include <recording/Frame.h>
-#include <NumericalConstants.h>
-// FiXME
-//#include <AudioClient.h>
-#include <AudioConstants.h>
-#include <Transform.h>
+#include <recording/ClipCache.h>
 
 #include "ScriptEngineLogging.h"
 
-typedef int16_t AudioSample;
-
-
 using namespace recording;
 
-// FIXME move to somewhere audio related?
-static const QString AUDIO_FRAME_NAME = "com.highfidelity.recording.Audio";
 
 RecordingScriptingInterface::RecordingScriptingInterface() {
-    static const recording::FrameType AVATAR_FRAME_TYPE = recording::Frame::registerFrameType(AvatarData::FRAME_NAME);
-    // FIXME how to deal with driving multiple avatars locally?  
-    Frame::registerFrameHandler(AVATAR_FRAME_TYPE, [this](Frame::ConstPointer frame) {
-        processAvatarFrame(frame);
-    });
-
-    static const recording::FrameType AUDIO_FRAME_TYPE = recording::Frame::registerFrameType(AUDIO_FRAME_NAME);
-    Frame::registerFrameHandler(AUDIO_FRAME_TYPE, [this](Frame::ConstPointer frame) {
-        processAudioFrame(frame);
-    });
-
     _player = DependencyManager::get<Deck>();
     _recorder = DependencyManager::get<Recorder>();
-
-    // FIXME : Disabling Sound
-//    auto audioClient = DependencyManager::get<AudioClient>();
- //   connect(audioClient.data(), &AudioClient::inputReceived, this, &RecordingScriptingInterface::processAudioInput);
-}
-
-void RecordingScriptingInterface::setControlledAvatar(AvatarData* avatar) {
-    _controlledAvatar = avatar;
 }
 
 bool RecordingScriptingInterface::isPlaying() const {
@@ -70,20 +44,17 @@ float RecordingScriptingInterface::playerLength() const {
     return _player->length();
 }
 
-void RecordingScriptingInterface::loadRecording(const QString& filename) {
+void RecordingScriptingInterface::loadRecording(const QString& url) {
     using namespace recording;
 
     if (QThread::currentThread() != thread()) {
         QMetaObject::invokeMethod(this, "loadRecording", Qt::BlockingQueuedConnection,
-            Q_ARG(QString, filename));
+            Q_ARG(QString, url));
         return;
     }
 
-    ClipPointer clip = Clip::fromFile(filename);
-    if (!clip) {
-        qWarning() << "Unable to load clip data from " << filename;
-    }
-    _player->queueClip(clip);
+    // FIXME make blocking and force off main thread?
+    _player->queueClip(ClipCache::instance().getClipLoader(url)->getClip());
 }
 
 void RecordingScriptingInterface::startPlaying() {
@@ -92,12 +63,6 @@ void RecordingScriptingInterface::startPlaying() {
         return;
     }
 
-    // Playback from the current position
-    if (_playFromCurrentLocation && _controlledAvatar) {
-        _dummyAvatar.setRecordingBasis(std::make_shared<Transform>(_controlledAvatar->getTransform()));
-    } else {
-        _dummyAvatar.clearRecordingBasis();
-    }
     _player->play();
 }
 
@@ -176,12 +141,6 @@ void RecordingScriptingInterface::startRecording() {
         return;
     }
 
-    _recordingEpoch = Frame::epochForFrameTime(0);
-
-    if (_controlledAvatar) {
-        _controlledAvatar->setRecordingBasis();
-    }
-
     _recorder->start();
 }
 
@@ -189,10 +148,6 @@ void RecordingScriptingInterface::stopRecording() {
     _recorder->stop();
     _lastClip = _recorder->getClip();
     _lastClip->seek(0);
-
-    if (_controlledAvatar) {
-        _controlledAvatar->clearRecordingBasis();
-    }
 }
 
 void RecordingScriptingInterface::saveRecording(const QString& filename) {
@@ -225,50 +180,3 @@ void RecordingScriptingInterface::loadLastRecording() {
     _player->play();
 }
 
-void RecordingScriptingInterface::processAvatarFrame(const Frame::ConstPointer& frame) {
-    Q_ASSERT(QThread::currentThread() == thread());
-
-    if (!_controlledAvatar) {
-        return;
-    }
-
-    AvatarData::fromFrame(frame->data, _dummyAvatar);
-
-
-
-    if (_useHeadModel && _dummyAvatar.getFaceModelURL().isValid() && 
-        (_dummyAvatar.getFaceModelURL() != _controlledAvatar->getFaceModelURL())) {
-        // FIXME
-        //myAvatar->setFaceModelURL(_dummyAvatar.getFaceModelURL());
-    }
-
-    if (_useSkeletonModel && _dummyAvatar.getSkeletonModelURL().isValid() &&
-        (_dummyAvatar.getSkeletonModelURL() != _controlledAvatar->getSkeletonModelURL())) {
-        // FIXME
-        //myAvatar->useFullAvatarURL()
-    }
-
-    if (_useDisplayName && _dummyAvatar.getDisplayName() != _controlledAvatar->getDisplayName()) {
-        _controlledAvatar->setDisplayName(_dummyAvatar.getDisplayName());
-    }
-
-    _controlledAvatar->setPosition(_dummyAvatar.getPosition());
-    _controlledAvatar->setOrientation(_dummyAvatar.getOrientation());
-
-    // FIXME attachments
-    // FIXME joints
-    // FIXME head lean
-    // FIXME head orientation
-}
-
-void RecordingScriptingInterface::processAudioInput(const QByteArray& audio) {
-    if (_recorder->isRecording()) {
-        static const recording::FrameType AUDIO_FRAME_TYPE = recording::Frame::registerFrameType(AUDIO_FRAME_NAME);
-        _recorder->recordFrame(AUDIO_FRAME_TYPE, audio);
-    }
-}
-
-void RecordingScriptingInterface::processAudioFrame(const recording::FrameConstPointer& frame) {
-   // auto audioClient = DependencyManager::get<AudioClient>();
-   // audioClient->handleRecordedAudioInput(frame->data);
-}

libraries/script-engine/src/RecordingScriptingInterface.h

@@ -10,13 +10,13 @@
 #define hifi_RecordingScriptingInterface_h
 
 #include <atomic>
+#include <mutex>
 
-#include <QObject>
+#include <QtCore/QObject>
 
 #include <DependencyManager.h>
 #include <recording/Forward.h>
 #include <recording/Frame.h>
-#include <AvatarData.h>
 
 class RecordingScriptingInterface : public QObject, public Dependency {
     Q_OBJECT
@@ -24,10 +24,8 @@ class RecordingScriptingInterface : public QObject, public Dependency {
 public:
     RecordingScriptingInterface();
 
-    void setControlledAvatar(AvatarData* avatar);
-
 public slots:
-    void loadRecording(const QString& filename);
+    void loadRecording(const QString& url);
 
     void startPlaying();
     void pausePlayer();
@@ -41,12 +39,19 @@ public slots:
     void setPlayerVolume(float volume);
     void setPlayerAudioOffset(float audioOffset);
     void setPlayerTime(float time);
-    void setPlayFromCurrentLocation(bool playFromCurrentLocation);
     void setPlayerLoop(bool loop);
+
     void setPlayerUseDisplayName(bool useDisplayName);
     void setPlayerUseAttachments(bool useAttachments);
     void setPlayerUseHeadModel(bool useHeadModel);
     void setPlayerUseSkeletonModel(bool useSkeletonModel);
+    void setPlayFromCurrentLocation(bool playFromCurrentLocation);
+
+    bool getPlayerUseDisplayName() { return _useDisplayName; }
+    bool getPlayerUseAttachments() { return _useAttachments; }
+    bool getPlayerUseHeadModel() { return _useHeadModel; }
+    bool getPlayerUseSkeletonModel() { return _useSkeletonModel; }
+    bool getPlayFromCurrentLocation() { return _playFromCurrentLocation; }
 
     void startRecording();
     void stopRecording();
@@ -57,22 +62,13 @@ public slots:
     void saveRecording(const QString& filename);
     void loadLastRecording();
 
-signals:
-    void playbackStateChanged();
-    // Should this occur for any frame or just for seek calls?
-    void playbackPositionChanged();
-    void looped();
-
-private:
+protected:
     using Mutex = std::recursive_mutex;
     using Locker = std::unique_lock<Mutex>;
     using Flag = std::atomic<bool>;
-    void processAvatarFrame(const recording::FrameConstPointer& frame);
-    void processAudioFrame(const recording::FrameConstPointer& frame);
-    void processAudioInput(const QByteArray& audioData);
+
     QSharedPointer<recording::Deck> _player;
     QSharedPointer<recording::Recorder> _recorder;
-    quint64 _recordingEpoch { 0 };
     
     Flag _playFromCurrentLocation { true };
     Flag _useDisplayName { false };
@@ -80,8 +76,6 @@ private:
     Flag _useAttachments { false };
     Flag _useSkeletonModel { false };
     recording::ClipPointer _lastClip;
-    AvatarData _dummyAvatar;
-    AvatarData* _controlledAvatar;
 };
 
 #endif // hifi_RecordingScriptingInterface_h

libraries/script-engine/src/ScriptEngine.cpp

@@ -381,6 +381,9 @@ void ScriptEngine::init() {
 
     auto recordingInterface = DependencyManager::get<RecordingScriptingInterface>();
     registerGlobalObject("Recording", recordingInterface.data());
+
+    registerGlobalObject("Assets", &_assetScriptingInterface);
+    
 }
 
 void ScriptEngine::registerValue(const QString& valueName, QScriptValue value) {

libraries/script-engine/src/ScriptEngine.h

@@ -23,6 +23,7 @@
 
 #include <AnimationCache.h>
 #include <AnimVariant.h>
+#include <AssetClient.h>
 #include <AvatarData.h>
 #include <AvatarHashMap.h>
 #include <LimitedNodeList.h>
@@ -195,6 +196,8 @@ private:
 
     ArrayBufferClass* _arrayBufferClass;
 
+    AssetScriptingInterface _assetScriptingInterface;
+
     QHash<EntityItemID, RegisteredEventHandlers> _registeredHandlers;
     void forwardHandlerCall(const EntityItemID& entityID, const QString& eventName, QScriptValueList eventHanderArgs);
     Q_INVOKABLE void entityScriptContentAvailable(const EntityItemID& entityID, const QString& scriptOrURL, const QString& contents, bool isURL, bool success);

libraries/shared/src/Transform.cpp

@@ -117,7 +117,7 @@ Transform Transform::fromJson(const QJsonValue& json) {
         result.setTranslation(vec3FromJsonValue(obj[JSON_TRANSLATION]));
     }
     if (obj.contains(JSON_SCALE)) {
-        result.setScale(vec3FromJsonValue(obj[JSON_TRANSLATION]));
+        result.setScale(vec3FromJsonValue(obj[JSON_SCALE]));
     }
     return result;
 }

plugins/oculus/src/OculusBaseDisplayPlugin.cpp

@@ -29,6 +29,7 @@ glm::mat4 OculusBaseDisplayPlugin::getProjection(Eye eye, const glm::mat4& baseP
 void OculusBaseDisplayPlugin::resetSensors() {
 #if (OVR_MAJOR_VERSION >= 6)
     ovr_RecenterPose(_hmd);
+    preRender();
 #endif
 }