merge upstream/master into physics project

Conflicts:
	interface/src/avatar/Hand.cpp
	interface/src/avatar/Hand.h
	interface/src/avatar/SkeletonModel.cpp
	interface/src/avatar/SkeletonModel.h
	interface/src/renderer/Model.h

BUILD.md

@@ -38,7 +38,7 @@ Any variables that need to be set for CMake to find dependencies can be set as E
 
 For example, to pass the QT_CMAKE_PREFIX_PATH variable during build file generation:
 
-    cmake .. -DQT_CMAKE_PREFIX_PATH=/usr/local/qt/5.2.0/clang_64/lib/cmake
+    cmake .. -DQT_CMAKE_PREFIX_PATH=/usr/local/qt/5.2.0/lib/cmake
 
 
 UNIX

CMakeLists.txt

@@ -16,7 +16,11 @@ elseif (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
 endif(WIN32)
 
-set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} $ENV{QT_CMAKE_PREFIX_PATH})
+if (NOT QT_CMAKE_PREFIX_PATH)
+  set(QT_CMAKE_PREFIX_PATH $ENV{QT_CMAKE_PREFIX_PATH})
+endif ()
+
+set(CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${QT_CMAKE_PREFIX_PATH})
 
 # set our Base SDK to 10.8
 set(CMAKE_OSX_SYSROOT /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.8.sdk)

README.md

@@ -63,4 +63,5 @@ To test things out you'll want to run the Interface client.
 
 To access your local domain in Interface, open your Preferences -- on OS X this is available in the Interface menu, on Linux you'll find it in the File menu. Enter "localhost" in the "Domain server" field.
 
-If everything worked you should see that you are connected to at least one server. Nice work!
+If everything worked you should see that you are connected to at least one server.
+Nice work!

assignment-client/src/Agent.cpp

@@ -26,8 +26,7 @@
 Agent::Agent(const QByteArray& packet) :
     ThreadedAssignment(packet),
     _voxelEditSender(),
-    _particleEditSender(),
-    _avatarAudioStream(NULL)
+    _particleEditSender()
 {
     // be the parent of the script engine so it gets moved when we do
     _scriptEngine.setParent(this);
@@ -36,30 +35,6 @@ Agent::Agent(const QByteArray& packet) :
     _scriptEngine.getParticlesScriptingInterface()->setPacketSender(&_particleEditSender);
 }
 
-Agent::~Agent() {
-    delete _avatarAudioStream;
-}
-
-const int SCRIPT_AUDIO_BUFFER_SAMPLES = floor(((SCRIPT_DATA_CALLBACK_USECS * SAMPLE_RATE) / (1000 * 1000)) + 0.5);
-
-void Agent::setSendAvatarAudioStream(bool sendAvatarAudioStream) {
-    if (sendAvatarAudioStream) {
-        // the agentAudioStream number of samples is related to the ScriptEngine callback rate
-        _avatarAudioStream = new int16_t[SCRIPT_AUDIO_BUFFER_SAMPLES];
-        
-        // fill the _audioStream with zeroes to start
-        memset(_avatarAudioStream, 0, SCRIPT_AUDIO_BUFFER_SAMPLES * sizeof(int16_t));
-        
-        _scriptEngine.setNumAvatarAudioBufferSamples(SCRIPT_AUDIO_BUFFER_SAMPLES);
-        _scriptEngine.setAvatarAudioBuffer(_avatarAudioStream);
-    } else {
-        delete _avatarAudioStream;
-        _avatarAudioStream = NULL;
-        
-        _scriptEngine.setAvatarAudioBuffer(NULL);
-    }
-}
-
 void Agent::readPendingDatagrams() {
     QByteArray receivedPacket;
     HifiSockAddr senderSockAddr;
@@ -95,12 +70,19 @@ void Agent::readPendingDatagrams() {
                 // also give our local particle tree a chance to remap any internal locally created particles
                 _particleViewer.getTree()->handleAddParticleResponse(receivedPacket);
 
+                // Make sure our Node and NodeList knows we've heard from this node.
+                SharedNodePointer sourceNode = nodeList->sendingNodeForPacket(receivedPacket);
+                sourceNode->setLastHeardMicrostamp(usecTimestampNow());
+
             } else if (datagramPacketType == PacketTypeParticleData
                         || datagramPacketType == PacketTypeParticleErase
                         || datagramPacketType == PacketTypeOctreeStats
                         || datagramPacketType == PacketTypeVoxelData
             ) {
+                // Make sure our Node and NodeList knows we've heard from this node.
                 SharedNodePointer sourceNode = nodeList->sendingNodeForPacket(receivedPacket);
+                sourceNode->setLastHeardMicrostamp(usecTimestampNow());
+
                 QByteArray mutablePacket = receivedPacket;
                 ssize_t messageLength = mutablePacket.size();
 
@@ -138,10 +120,12 @@ void Agent::readPendingDatagrams() {
     }
 }
 
+const QString AGENT_LOGGING_NAME = "agent";
+
 void Agent::run() {
-    NodeList* nodeList = NodeList::getInstance();
-    nodeList->setOwnerType(NodeType::Agent);
+    ThreadedAssignment::commonInit(AGENT_LOGGING_NAME, NodeType::Agent);
     
+    NodeList* nodeList = NodeList::getInstance();
     nodeList->addSetOfNodeTypesToNodeInterestSet(NodeSet() << NodeType::AudioMixer << NodeType::AvatarMixer);
     
     // figure out the URL for the script for this agent assignment
@@ -166,17 +150,6 @@ void Agent::run() {
     
     qDebug() << "Downloaded script:" << scriptContents;
     
-    timeval startTime;
-    gettimeofday(&startTime, NULL);
-    
-    QTimer* domainServerTimer = new QTimer(this);
-    connect(domainServerTimer, SIGNAL(timeout()), this, SLOT(checkInWithDomainServerOrExit()));
-    domainServerTimer->start(DOMAIN_SERVER_CHECK_IN_USECS / 1000);
-    
-    QTimer* silentNodeTimer = new QTimer(this);
-    connect(silentNodeTimer, SIGNAL(timeout()), nodeList, SLOT(removeSilentNodes()));
-    silentNodeTimer->start(NODE_SILENCE_THRESHOLD_USECS / 1000);
-    
     // setup an Avatar for the script to use
     AvatarData scriptedAvatar;
     
@@ -207,4 +180,9 @@ void Agent::run() {
 
     _scriptEngine.setScriptContents(scriptContents);
     _scriptEngine.run();
+    setFinished(true);
+}
+
+void Agent::aboutToFinish() {
+    _scriptEngine.stop();
 }

assignment-client/src/Agent.h

@@ -28,20 +28,26 @@ class Agent : public ThreadedAssignment {
     Q_OBJECT
     
     Q_PROPERTY(bool isAvatar READ isAvatar WRITE setIsAvatar)
-    Q_PROPERTY(bool sendAvatarAudioStream READ isSendingAvatarAudioStream WRITE setSendAvatarAudioStream)
+    Q_PROPERTY(bool isPlayingAvatarSound READ isPlayingAvatarSound)
+    Q_PROPERTY(bool isListeningToAudioStream READ isListeningToAudioStream WRITE setIsListeningToAudioStream)
 public:
     Agent(const QByteArray& packet);
-    ~Agent();
     
     void setIsAvatar(bool isAvatar) { QMetaObject::invokeMethod(&_scriptEngine, "setIsAvatar", Q_ARG(bool, isAvatar)); }
     bool isAvatar() const { return _scriptEngine.isAvatar(); }
     
-    void setSendAvatarAudioStream(bool sendAvatarAudioStream);
-    bool isSendingAvatarAudioStream() const { return (bool) _scriptEngine.sendsAvatarAudioStream(); }
+    bool isPlayingAvatarSound() const  { return _scriptEngine.isPlayingAvatarSound(); }
+    
+    bool isListeningToAudioStream() const { return _scriptEngine.isListeningToAudioStream(); }
+    void setIsListeningToAudioStream(bool isListeningToAudioStream)
+        { _scriptEngine.setIsListeningToAudioStream(isListeningToAudioStream); }
+
+    virtual void aboutToFinish();
     
 public slots:
     void run();
     void readPendingDatagrams();
+    void playAvatarSound(Sound* avatarSound) { _scriptEngine.setAvatarSound(avatarSound); }
 
 private:
     ScriptEngine _scriptEngine;
@@ -50,8 +56,6 @@ private:
 
     ParticleTreeHeadlessViewer _particleViewer;
     VoxelTreeHeadlessViewer _voxelViewer;
-    
-    int16_t* _avatarAudioStream;
 };
 
 #endif /* defined(__hifi__Agent__) */

assignment-client/src/AssignmentClient.cpp

@@ -200,13 +200,13 @@ void AssignmentClient::assignmentCompleted() {
     qDebug("Assignment finished or never started - waiting for new assignment.");
     
     NodeList* nodeList = NodeList::getInstance();
-    
+
     // have us handle incoming NodeList datagrams again
     disconnect(&nodeList->getNodeSocket(), 0, _currentAssignment, 0);
     connect(&nodeList->getNodeSocket(), &QUdpSocket::readyRead, this, &AssignmentClient::readPendingDatagrams);
     
     _currentAssignment = NULL;
-    
+
     // reset our NodeList by switching back to unassigned and clearing the list
     nodeList->setOwnerType(NodeType::Unassigned);
     nodeList->reset();

assignment-client/src/audio/AudioMixer.cpp

@@ -33,6 +33,7 @@
 #include <glm/gtx/vector_angle.hpp>
 
 #include <QtCore/QCoreApplication>
+#include <QtCore/QJsonObject>
 #include <QtCore/QTimer>
 
 #include <Logging.h>
@@ -53,6 +54,8 @@
 const short JITTER_BUFFER_MSECS = 12;
 const short JITTER_BUFFER_SAMPLES = JITTER_BUFFER_MSECS * (SAMPLE_RATE / 1000.0);
 
+const float LOUDNESS_TO_DISTANCE_RATIO = 0.00305f;
+
 const QString AUDIO_MIXER_LOGGING_TARGET_NAME = "audio-mixer";
 
 void attachNewBufferToNode(Node *newNode) {
@@ -62,7 +65,13 @@ void attachNewBufferToNode(Node *newNode) {
 }
 
 AudioMixer::AudioMixer(const QByteArray& packet) :
-    ThreadedAssignment(packet)
+    ThreadedAssignment(packet),
+    _trailingSleepRatio(1.0f),
+    _minAudibilityThreshold(LOUDNESS_TO_DISTANCE_RATIO / 2.0f),
+    _performanceThrottlingRatio(0.0f),
+    _numStatFrames(0),
+    _sumListeners(0),
+    _sumMixes(0)
 {
     
 }
@@ -76,10 +85,24 @@ void AudioMixer::addBufferToMixForListeningNodeWithBuffer(PositionalAudioRingBuf
     
     if (bufferToAdd != listeningNodeBuffer) {
         // if the two buffer pointers do not match then these are different buffers
-
         glm::vec3 relativePosition = bufferToAdd->getPosition() - listeningNodeBuffer->getPosition();
+        
+        float distanceBetween = glm::length(relativePosition);
+       
+        if (distanceBetween < EPSILON) {
+            distanceBetween = EPSILON;
+        }
+        
+        if (bufferToAdd->getAverageLoudness() / distanceBetween <= _minAudibilityThreshold) {
+            // according to mixer performance we have decided this does not get to be mixed in
+            // bail out
+            return;
+        }
+        
+        ++_sumMixes;
+        
         glm::quat inverseOrientation = glm::inverse(listeningNodeBuffer->getOrientation());
-
+        
         float distanceSquareToSource = glm::dot(relativePosition, relativePosition);
         float radius = 0.0f;
 
@@ -301,7 +324,7 @@ void AudioMixer::prepareMixForListeningNode(Node* node) {
                 if ((*otherNode != *node
                      || otherNodeBuffer->shouldLoopbackForNode())
                     && otherNodeBuffer->willBeAddedToMix()
-                    && otherNodeClientData->getNextOutputLoudness() > 0) {
+                    && otherNodeBuffer->getAverageLoudness() > 0) {
                     addBufferToMixForListeningNodeWithBuffer(otherNodeBuffer, nodeRingBuffer);
                 }
             }
@@ -333,9 +356,29 @@ void AudioMixer::readPendingDatagrams() {
     }
 }
 
+void AudioMixer::sendStatsPacket() {
+    static QJsonObject statsObject;
+    statsObject["trailing_sleep_percentage"] = _trailingSleepRatio * 100.0f;
+    statsObject["performance_throttling_ratio"] = _performanceThrottlingRatio;
+
+    statsObject["average_listeners_per_frame"] = (float) _sumListeners / (float) _numStatFrames;
+    
+    if (_sumListeners > 0) {
+        statsObject["average_mixes_per_listener"] = (float) _sumMixes / (float) _sumListeners;
+    } else {
+        statsObject["average_mixes_per_listener"] = 0.0;
+    }
+    
+    ThreadedAssignment::addPacketStatsAndSendStatsPacket(statsObject);
+    
+    _sumListeners = 0;
+    _sumMixes = 0;
+    _numStatFrames = 0;
+}
+
 void AudioMixer::run() {
 
-    commonInit(AUDIO_MIXER_LOGGING_TARGET_NAME, NodeType::AudioMixer);
+    ThreadedAssignment::commonInit(AUDIO_MIXER_LOGGING_TARGET_NAME, NodeType::AudioMixer);
 
     NodeList* nodeList = NodeList::getInstance();
 
@@ -350,15 +393,72 @@ void AudioMixer::run() {
     
     char* clientMixBuffer = new char[NETWORK_BUFFER_LENGTH_BYTES_STEREO
                                      + numBytesForPacketHeaderGivenPacketType(PacketTypeMixedAudio)];
+    
+    int usecToSleep = BUFFER_SEND_INTERVAL_USECS;
+    
+    const int TRAILING_AVERAGE_FRAMES = 100;
+    int framesSinceCutoffEvent = TRAILING_AVERAGE_FRAMES;
 
     while (!_isFinished) {
-
+        
         foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
             if (node->getLinkedData()) {
                 ((AudioMixerClientData*) node->getLinkedData())->checkBuffersBeforeFrameSend(JITTER_BUFFER_SAMPLES);
             }
         }
-
+        
+        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) BUFFER_SEND_INTERVAL_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;
+        }
+        
         foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
             if (node->getType() == NodeType::Agent && node->getActiveSocket() && node->getLinkedData()
                 && ((AudioMixerClientData*) node->getLinkedData())->getAvatarAudioRingBuffer()) {
@@ -368,6 +468,8 @@ void AudioMixer::run() {
 
                 memcpy(clientMixBuffer + numBytesPacketHeader, _clientSamples, NETWORK_BUFFER_LENGTH_BYTES_STEREO);
                 nodeList->writeDatagram(clientMixBuffer, NETWORK_BUFFER_LENGTH_BYTES_STEREO + numBytesPacketHeader, node);
+                
+                ++_sumListeners;
             }
         }
 
@@ -378,20 +480,19 @@ void AudioMixer::run() {
             }
         }
         
+        ++_numStatFrames;
+        
         QCoreApplication::processEvents();
         
         if (_isFinished) {
             break;
         }
 
-        int usecToSleep = usecTimestamp(&startTime) + (++nextFrame * BUFFER_SEND_INTERVAL_USECS) - usecTimestampNow();
+        usecToSleep = usecTimestamp(&startTime) + (++nextFrame * BUFFER_SEND_INTERVAL_USECS) - usecTimestampNow();
 
         if (usecToSleep > 0) {
             usleep(usecToSleep);
-        } else {
-            qDebug() << "AudioMixer loop took" << -usecToSleep << "of extra time. Not sleeping.";
         }
-
     }
     
     delete[] clientMixBuffer;

assignment-client/src/audio/AudioMixer.h

@@ -28,6 +28,8 @@ public slots:
     void run();
     
     void readPendingDatagrams();
+    
+    void sendStatsPacket();
 private:
     /// adds one buffer to the mix for a listening node
     void addBufferToMixForListeningNodeWithBuffer(PositionalAudioRingBuffer* bufferToAdd,
@@ -37,7 +39,15 @@ private:
     void prepareMixForListeningNode(Node* node);
     
     // client samples capacity is larger than what will be sent to optimize mixing
-    int16_t _clientSamples[NETWORK_BUFFER_LENGTH_SAMPLES_STEREO + SAMPLE_PHASE_DELAY_AT_90];
+    // we are MMX adding 4 samples at a time so we need client samples to have an extra 4
+    int16_t _clientSamples[NETWORK_BUFFER_LENGTH_SAMPLES_STEREO + (SAMPLE_PHASE_DELAY_AT_90 * 2)];
+    
+    float _trailingSleepRatio;
+    float _minAudibilityThreshold;
+    float _performanceThrottlingRatio;
+    int _numStatFrames;
+    int _sumListeners;
+    int _sumMixes;
 };
 
 #endif /* defined(__hifi__AudioMixer__) */

assignment-client/src/audio/AudioMixerClientData.cpp

@@ -6,6 +6,8 @@
 //  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
 //
 
+#include <QDebug>
+
 #include <PacketHeaders.h>
 #include <UUID.h>
 
@@ -14,8 +16,7 @@
 #include "AudioMixerClientData.h"
 
 AudioMixerClientData::AudioMixerClientData() :
-    _ringBuffers(),
-    _nextOutputLoudness(0)
+    _ringBuffers()
 {
     
 }
@@ -91,7 +92,7 @@ void AudioMixerClientData::checkBuffersBeforeFrameSend(int jitterBufferLengthSam
             
             // calculate the average loudness for the next NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL
             // that would be mixed in
-            _nextOutputLoudness = _ringBuffers[i]->averageLoudnessForBoundarySamples(NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL);
+            _ringBuffers[i]->updateAverageLoudnessForBoundarySamples(NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL);
         }
     }
 }

assignment-client/src/audio/AudioMixerClientData.h

@@ -24,14 +24,11 @@ public:
     const std::vector<PositionalAudioRingBuffer*> getRingBuffers() const { return _ringBuffers; }
     AvatarAudioRingBuffer* getAvatarAudioRingBuffer() const;
     
-    float getNextOutputLoudness() const { return _nextOutputLoudness; }
-    
     int parseData(const QByteArray& packet);
     void checkBuffersBeforeFrameSend(int jitterBufferLengthSamples);
     void pushBuffersAfterFrameSend();
 private:
     std::vector<PositionalAudioRingBuffer*> _ringBuffers;
-    float _nextOutputLoudness;
 };
 
 #endif /* defined(__hifi__AudioMixerClientData__) */

assignment-client/src/avatars/AvatarMixer.cpp

@@ -11,8 +11,10 @@
 //  nodes, and broadcasts that data back to them, every BROADCAST_INTERVAL ms.
 
 #include <QtCore/QCoreApplication>
-#include <QtCore/QElapsedTimer>
+#include <QtCore/QDateTime>
+#include <QtCore/QJsonObject>
 #include <QtCore/QTimer>
+#include <QtCore/QThread>
 
 #include <Logging.h>
 #include <NodeList.h>
@@ -26,10 +28,17 @@
 
 const QString AVATAR_MIXER_LOGGING_NAME = "avatar-mixer";
 
-const unsigned int AVATAR_DATA_SEND_INTERVAL_USECS = (1 / 60.0) * 1000 * 1000;
+const unsigned int AVATAR_DATA_SEND_INTERVAL_MSECS = (1.0f / 60.0f) * 1000;
 
 AvatarMixer::AvatarMixer(const QByteArray& packet) :
-    ThreadedAssignment(packet)
+    ThreadedAssignment(packet),
+    _lastFrameTimestamp(QDateTime::currentMSecsSinceEpoch()),
+    _trailingSleepRatio(1.0f),
+    _performanceThrottlingRatio(0.0f),
+    _sumListeners(0),
+    _numStatFrames(0),
+    _sumBillboardPackets(0),
+    _sumIdentityPackets(0)
 {
     // make sure we hear about node kills so we can tell the other nodes
     connect(NodeList::getInstance(), &NodeList::nodeKilled, this, &AvatarMixer::nodeKilled);
@@ -41,14 +50,64 @@ void attachAvatarDataToNode(Node* newNode) {
     }
 }
 
+const float BILLBOARD_AND_IDENTITY_SEND_PROBABILITY = 1.0f / 300.0f;
+
 // NOTE: some additional optimizations to consider.
 //    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.
-//    2) after culling for view frustum, sort order the avatars by distance, send the closest ones first.
-//    3) if we need to rate limit the amount of data we send, we can use a distance weighted "semi-random" function to
-//       determine which avatars are included in the packet stream
-//    4) we should optimize the avatar data format to be more compact (100 bytes is pretty wasteful).
-void broadcastAvatarData() {
+void AvatarMixer::broadcastAvatarData() {
+    
+    int idleTime = QDateTime::currentMSecsSinceEpoch() - _lastFrameTimestamp;
+    
+    ++_numStatFrames;
+    
+    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 int TRAILING_AVERAGE_FRAMES = 100;
+    int framesSinceCutoffEvent = TRAILING_AVERAGE_FRAMES;
+    
+    const float CURRENT_FRAME_RATIO = 1.0f / TRAILING_AVERAGE_FRAMES;
+    const float PREVIOUS_FRAMES_RATIO = 1.0f - CURRENT_FRAME_RATIO;
+    
+    _trailingSleepRatio = (PREVIOUS_FRAMES_RATIO * _trailingSleepRatio)
+        + (idleTime * CURRENT_FRAME_RATIO / (float) AVATAR_DATA_SEND_INTERVAL_MSECS);
+    
+    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) {
+            framesSinceCutoffEvent = 0;
+        }
+    }
+    
+    if (!hasRatioChanged) {
+        ++framesSinceCutoffEvent;
+    }
+    
     static QByteArray mixedAvatarByteArray;
     
     int numPacketHeaderBytes = populatePacketHeader(mixedAvatarByteArray, PacketTypeBulkAvatarData);
@@ -57,6 +116,7 @@ void broadcastAvatarData() {
     
     foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
         if (node->getLinkedData() && node->getType() == NodeType::Agent && node->getActiveSocket()) {
+            ++_sumListeners;
             
             // reset packet pointers for this node
             mixedAvatarByteArray.resize(numPacketHeaderBytes);
@@ -73,12 +133,9 @@ void broadcastAvatarData() {
                     AvatarMixerClientData* otherNodeData = reinterpret_cast<AvatarMixerClientData*>(otherNode->getLinkedData());
                     AvatarData& otherAvatar = otherNodeData->getAvatar();
                     glm::vec3 otherPosition = otherAvatar.getPosition();
-                    float distanceToAvatar = glm::length(myPosition - otherPosition);
-                    //  The full rate distance is the distance at which EVERY update will be sent for this avatar
-                    //  at a distance of twice the full rate distance, there will be a 50% chance of sending this avatar's update
-                    const float FULL_RATE_DISTANCE = 2.f;
-                    //  Decide whether to send this avatar's data based on it's distance from us
-                    if ((distanceToAvatar == 0.f) || (randFloat() < FULL_RATE_DISTANCE / distanceToAvatar)) {
+            
+                    //  Decide whether to send this avatar's data based on current performance throttling
+                    if (_performanceThrottlingRatio == 0 || randFloat() < (1.0f - _performanceThrottlingRatio)) {
                         QByteArray avatarByteArray;
                         avatarByteArray.append(otherNode->getUUID().toRfc4122());
                         avatarByteArray.append(otherAvatar.toByteArray());
@@ -92,6 +149,41 @@ void broadcastAvatarData() {
                         
                         // copy the avatar into the mixedAvatarByteArray packet
                         mixedAvatarByteArray.append(avatarByteArray);
+                        
+                        // if the receiving avatar has just connected make sure we send out the mesh and billboard
+                        // for this avatar (assuming they exist)
+                        bool forceSend = !myData->checkAndSetHasReceivedFirstPackets();
+                        
+                        // we will also force a send of billboard or identity packet
+                        // if either has changed in the last frame
+                        
+                        if (otherNodeData->getBillboardChangeTimestamp() > 0
+                            && (forceSend
+                                || otherNodeData->getBillboardChangeTimestamp() > _lastFrameTimestamp
+                                || randFloat() < BILLBOARD_AND_IDENTITY_SEND_PROBABILITY)) {
+                            QByteArray billboardPacket = byteArrayWithPopulatedHeader(PacketTypeAvatarBillboard);
+                            billboardPacket.append(otherNode->getUUID().toRfc4122());
+                            billboardPacket.append(otherNodeData->getAvatar().getBillboard());
+                            nodeList->writeDatagram(billboardPacket, node);
+                            
+                            ++_sumBillboardPackets;
+                        }
+                        
+                        if (otherNodeData->getIdentityChangeTimestamp() > 0
+                            && (forceSend
+                                || otherNodeData->getIdentityChangeTimestamp() > _lastFrameTimestamp
+                                || randFloat() < BILLBOARD_AND_IDENTITY_SEND_PROBABILITY)) {
+                                
+                            QByteArray identityPacket = byteArrayWithPopulatedHeader(PacketTypeAvatarIdentity);
+                            
+                            QByteArray individualData = otherNodeData->getAvatar().identityByteArray();
+                            individualData.replace(0, NUM_BYTES_RFC4122_UUID, otherNode->getUUID().toRfc4122());
+                            identityPacket.append(individualData);
+                            
+                            nodeList->writeDatagram(identityPacket, node);
+                                
+                            ++_sumIdentityPackets;
+                        }
                     }
                 }
             }
@@ -99,66 +191,8 @@ void broadcastAvatarData() {
             nodeList->writeDatagram(mixedAvatarByteArray, node);
         }
     }
-}
-
-void broadcastIdentityPacket() {
-   
-    NodeList* nodeList = NodeList::getInstance();
     
-    QByteArray avatarIdentityPacket = byteArrayWithPopulatedHeader(PacketTypeAvatarIdentity);
-    int numPacketHeaderBytes = avatarIdentityPacket.size();
-    
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
-        if (node->getLinkedData() && node->getType() == NodeType::Agent) {
-            
-            AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(node->getLinkedData());
-            AvatarData& avatar = nodeData->getAvatar();
-            QByteArray individualData = avatar.identityByteArray();
-            individualData.replace(0, NUM_BYTES_RFC4122_UUID, node->getUUID().toRfc4122());
-            
-            if (avatarIdentityPacket.size() + individualData.size() > MAX_PACKET_SIZE) {
-                // we've hit MTU, send out the current packet before appending
-                nodeList->broadcastToNodes(avatarIdentityPacket, NodeSet() << NodeType::Agent);
-                avatarIdentityPacket.resize(numPacketHeaderBytes);
-            }
-            
-            // append the individual data to the current the avatarIdentityPacket
-            avatarIdentityPacket.append(individualData);
-            
-            // re-set the bool in AvatarMixerClientData so a change between key frames gets sent out
-            nodeData->setHasSentIdentityBetweenKeyFrames(false);
-        }
-    }
-    
-    // send out the final packet
-    if (avatarIdentityPacket.size() > numPacketHeaderBytes) {
-        nodeList->broadcastToNodes(avatarIdentityPacket, NodeSet() << NodeType::Agent);
-    }
-}
-
-void broadcastBillboardPacket(const SharedNodePointer& sendingNode) {
-    AvatarMixerClientData* nodeData = static_cast<AvatarMixerClientData*>(sendingNode->getLinkedData());
-    AvatarData& avatar = nodeData->getAvatar();
-    QByteArray packet = byteArrayWithPopulatedHeader(PacketTypeAvatarBillboard);
-    packet.append(sendingNode->getUUID().toRfc4122());
-    packet.append(avatar.getBillboard());
-    
-    NodeList* nodeList = NodeList::getInstance();
-    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
-        if (node->getType() == NodeType::Agent && node != sendingNode) {       
-            nodeList->writeDatagram(packet, node);
-        }
-    }
-}
-
-void broadcastBillboardPackets() {
-    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
-        if (node->getLinkedData() && node->getType() == NodeType::Agent) {       
-            AvatarMixerClientData* nodeData = static_cast<AvatarMixerClientData*>(node->getLinkedData());
-            broadcastBillboardPacket(node);
-            nodeData->setHasSentBillboardBetweenKeyFrames(false);
-        }
-    }
+    _lastFrameTimestamp = QDateTime::currentMSecsSinceEpoch();
 }
 
 void AvatarMixer::nodeKilled(SharedNodePointer killedNode) {
@@ -195,18 +229,10 @@ void AvatarMixer::readPendingDatagrams() {
                     if (avatarNode && avatarNode->getLinkedData()) {
                         AvatarMixerClientData* nodeData = reinterpret_cast<AvatarMixerClientData*>(avatarNode->getLinkedData());
                         AvatarData& avatar = nodeData->getAvatar();
-                        if (avatar.hasIdentityChangedAfterParsing(receivedPacket)
-                            && !nodeData->hasSentIdentityBetweenKeyFrames()) {
-                            // this avatar changed their identity in some way and we haven't sent a packet in this keyframe
-                            QByteArray identityPacket = byteArrayWithPopulatedHeader(PacketTypeAvatarIdentity);
-                            
-                            QByteArray individualByteArray = avatar.identityByteArray();
-                            individualByteArray.replace(0, NUM_BYTES_RFC4122_UUID, avatarNode->getUUID().toRfc4122());
-                            
-                            identityPacket.append(individualByteArray);
-                            
-                            nodeData->setHasSentIdentityBetweenKeyFrames(true);
-                            nodeList->broadcastToNodes(identityPacket, NodeSet() << NodeType::Agent);
+                        
+                        // parse the identity packet and update the change timestamp if appropriate
+                        if (avatar.hasIdentityChangedAfterParsing(receivedPacket)) {
+                            nodeData->setIdentityChangeTimestamp(QDateTime::currentMSecsSinceEpoch());
                         }
                     }
                     break;
@@ -219,12 +245,12 @@ void AvatarMixer::readPendingDatagrams() {
                     if (avatarNode && avatarNode->getLinkedData()) {
                         AvatarMixerClientData* nodeData = static_cast<AvatarMixerClientData*>(avatarNode->getLinkedData());
                         AvatarData& avatar = nodeData->getAvatar();
-                        if (avatar.hasBillboardChangedAfterParsing(receivedPacket)
-                                && !nodeData->hasSentBillboardBetweenKeyFrames()) {
-                            // this avatar changed their billboard and we haven't sent a packet in this keyframe
-                            broadcastBillboardPacket(avatarNode);
-                            nodeData->setHasSentBillboardBetweenKeyFrames(true);
+                        
+                        // parse the billboard packet and update the change timestamp if appropriate
+                        if (avatar.hasBillboardChangedAfterParsing(receivedPacket)) {
+                            nodeData->setBillboardChangeTimestamp(QDateTime::currentMSecsSinceEpoch());
                         }
+                        
                     }
                     break;
                 }
@@ -241,57 +267,44 @@ void AvatarMixer::readPendingDatagrams() {
     }
 }
 
-const qint64 AVATAR_IDENTITY_KEYFRAME_MSECS = 5000;
-const qint64 AVATAR_BILLBOARD_KEYFRAME_MSECS = 5000;
+void AvatarMixer::sendStatsPacket() {
+    QJsonObject statsObject;
+    statsObject["average_listeners_last_second"] = (float) _sumListeners / (float) _numStatFrames;
+    
+    statsObject["average_billboard_packets_per_frame"] = (float) _sumBillboardPackets / (float) _numStatFrames;
+    statsObject["average_identity_packets_per_frame"] = (float) _sumIdentityPackets / (float) _numStatFrames;
+    
+    statsObject["trailing_sleep_percentage"] = _trailingSleepRatio * 100;
+    statsObject["performance_throttling_ratio"] = _performanceThrottlingRatio;
+    
+    ThreadedAssignment::addPacketStatsAndSendStatsPacket(statsObject);
+    
+    _sumListeners = 0;
+    _sumBillboardPackets = 0;
+    _sumIdentityPackets = 0;
+    _numStatFrames = 0;
+}
 
 void AvatarMixer::run() {
-    commonInit(AVATAR_MIXER_LOGGING_NAME, NodeType::AvatarMixer);
+    ThreadedAssignment::commonInit(AVATAR_MIXER_LOGGING_NAME, NodeType::AvatarMixer);
     
     NodeList* nodeList = NodeList::getInstance();
     nodeList->addNodeTypeToInterestSet(NodeType::Agent);
     
     nodeList->linkedDataCreateCallback = attachAvatarDataToNode;
     
-    int nextFrame = 0;
-    timeval startTime;
+    // create a thead for broadcast of avatar data
+    QThread* broadcastThread = new QThread(this);
     
-    gettimeofday(&startTime, NULL);
+    // setup the timer that will be fired on the broadcast thread
+    QTimer* broadcastTimer = new QTimer();
+    broadcastTimer->setInterval(AVATAR_DATA_SEND_INTERVAL_MSECS);
+    broadcastTimer->moveToThread(broadcastThread);
     
-    QElapsedTimer identityTimer;
-    identityTimer.start();
+    // connect appropriate signals and slots
+    connect(broadcastTimer, &QTimer::timeout, this, &AvatarMixer::broadcastAvatarData, Qt::DirectConnection);
+    connect(broadcastThread, SIGNAL(started()), broadcastTimer, SLOT(start()));
     
-    QElapsedTimer billboardTimer;
-    billboardTimer.start();
-    
-    while (!_isFinished) {
-        
-        QCoreApplication::processEvents();
-        
-        if (_isFinished) {
-            break;
-        }
-        
-        broadcastAvatarData();
-        
-        if (identityTimer.elapsed() >= AVATAR_IDENTITY_KEYFRAME_MSECS) {
-            // it's time to broadcast the keyframe identity packets
-            broadcastIdentityPacket();
-            
-            // restart the timer so we do it again in AVATAR_IDENTITY_KEYFRAME_MSECS
-            identityTimer.restart();
-        }
- 
-        if (billboardTimer.elapsed() >= AVATAR_BILLBOARD_KEYFRAME_MSECS) {
-            broadcastBillboardPackets();
-            billboardTimer.restart();
-        }
-        
-        int usecToSleep = usecTimestamp(&startTime) + (++nextFrame * AVATAR_DATA_SEND_INTERVAL_USECS) - usecTimestampNow();
-        
-        if (usecToSleep > 0) {
-            usleep(usecToSleep);
-        } else {
-            qDebug() << "AvatarMixer loop took too" << -usecToSleep << "of extra time. Won't sleep.";
-        }
-    }
+    // start the broadcastThread
+    broadcastThread->start();
 }

assignment-client/src/avatars/AvatarMixer.h

@@ -24,6 +24,21 @@ public slots:
     void nodeKilled(SharedNodePointer killedNode);
     
     void readPendingDatagrams();
+    
+    void sendStatsPacket();
+    
+private:
+    void broadcastAvatarData();
+    
+    quint64 _lastFrameTimestamp;
+    
+    float _trailingSleepRatio;
+    float _performanceThrottlingRatio;
+    
+    int _sumListeners;
+    int _numStatFrames;
+    int _sumBillboardPackets;
+    int _sumIdentityPackets;
 };
 
 #endif /* defined(__hifi__AvatarMixer__) */

assignment-client/src/avatars/AvatarMixerClientData.cpp

@@ -10,8 +10,9 @@
 
 AvatarMixerClientData::AvatarMixerClientData() :
     NodeData(),
-    _hasSentIdentityBetweenKeyFrames(false),
-    _hasSentBillboardBetweenKeyFrames(false)
+    _hasReceivedFirstPackets(false),
+    _billboardChangeTimestamp(0),
+    _identityChangeTimestamp(0)
 {
     
 }
@@ -21,3 +22,9 @@ int AvatarMixerClientData::parseData(const QByteArray& packet) {
     int offset = numBytesForPacketHeader(packet);
     return _avatar.parseDataAtOffset(packet, offset);
 }
+
+bool AvatarMixerClientData::checkAndSetHasReceivedFirstPackets() {
+    bool oldValue = _hasReceivedFirstPackets;
+    _hasReceivedFirstPackets = true;
+    return oldValue;
+}

assignment-client/src/avatars/AvatarMixerClientData.h

@@ -20,22 +20,21 @@ public:
     AvatarMixerClientData();
 
     int parseData(const QByteArray& packet);
-    
-    bool hasSentIdentityBetweenKeyFrames() const { return _hasSentIdentityBetweenKeyFrames; }
-    void setHasSentIdentityBetweenKeyFrames(bool hasSentIdentityBetweenKeyFrames)
-        { _hasSentIdentityBetweenKeyFrames = hasSentIdentityBetweenKeyFrames; }
-    
-    bool hasSentBillboardBetweenKeyFrames() const { return _hasSentBillboardBetweenKeyFrames; }
-    void setHasSentBillboardBetweenKeyFrames(bool hasSentBillboardBetweenKeyFrames)
-        { _hasSentBillboardBetweenKeyFrames = hasSentBillboardBetweenKeyFrames; }
-
     AvatarData& getAvatar() { return _avatar; }
-        
+    
+    bool checkAndSetHasReceivedFirstPackets();
+    
+    quint64 getBillboardChangeTimestamp() const { return _billboardChangeTimestamp; }
+    void setBillboardChangeTimestamp(quint64 billboardChangeTimestamp) { _billboardChangeTimestamp = billboardChangeTimestamp; }
+    
+    quint64 getIdentityChangeTimestamp() const { return _identityChangeTimestamp; }
+    void setIdentityChangeTimestamp(quint64 identityChangeTimestamp) { _identityChangeTimestamp = identityChangeTimestamp; }
+    
 private:
-   
-    bool _hasSentIdentityBetweenKeyFrames;
-    bool _hasSentBillboardBetweenKeyFrames;
     AvatarData _avatar;
+    bool _hasReceivedFirstPackets;
+    quint64 _billboardChangeTimestamp;
+    quint64 _identityChangeTimestamp;
 };
 
 #endif /* defined(__hifi__AvatarMixerClientData__) */

assignment-client/src/main.cpp

@@ -15,8 +15,10 @@
 
 int main(int argc, char* argv[]) {
     
+#ifndef WIN32
     setvbuf(stdout, NULL, _IOLBF, 0);
-    
+#endif
+
     // use the verbose message handler in Logging
     qInstallMessageHandler(Logging::verboseMessageHandler);
     

assignment-client/src/metavoxels/MetavoxelServer.h

@@ -35,7 +35,7 @@ public:
     virtual void run();
     
     virtual void readPendingDatagrams();
-
+    
 private slots:
 
     void maybeAttachSession(const SharedNodePointer& node);

assignment-client/src/octree/OctreeInboundPacketProcessor.h

@@ -44,7 +44,7 @@ typedef std::map<QUuid, SingleSenderStats>::iterator NodeToSenderStatsMapIterato
 /// Handles processing of incoming network packets for the voxel-server. As with other ReceivedPacketProcessor classes 
 /// the user is responsible for reading inbound packets and adding them to the processing queue by calling queueReceivedPacket()
 class OctreeInboundPacketProcessor : public ReceivedPacketProcessor {
-
+    Q_OBJECT
 public:
     OctreeInboundPacketProcessor(OctreeServer* myServer);
 

assignment-client/src/octree/OctreeQueryNode.cpp

@@ -35,21 +35,46 @@ OctreeQueryNode::OctreeQueryNode() :
     _lastClientOctreeSizeScale(DEFAULT_OCTREE_SIZE_SCALE),
     _lodChanged(false),
     _lodInitialized(false),
-    _sequenceNumber(0)
+    _sequenceNumber(0),
+    _lastRootTimestamp(0),
+    _myPacketType(PacketTypeUnknown),
+    _isShuttingDown(false)
 {
 }
 
 OctreeQueryNode::~OctreeQueryNode() {
+    _isShuttingDown = true;
+    const bool extraDebugging = false;
+    if (extraDebugging) {
+        qDebug() << "OctreeQueryNode::~OctreeQueryNode()";
+    }
     if (_octreeSendThread) {
+        if (extraDebugging) {
+            qDebug() << "OctreeQueryNode::~OctreeQueryNode()... calling _octreeSendThread->terminate()";
+        }
         _octreeSendThread->terminate();
+        if (extraDebugging) {
+            qDebug() << "OctreeQueryNode::~OctreeQueryNode()... calling delete _octreeSendThread";
+        }
         delete _octreeSendThread;
     }
 
     delete[] _octreePacket;
     delete[] _lastOctreePacket;
+    if (extraDebugging) {
+        qDebug() << "OctreeQueryNode::~OctreeQueryNode()... DONE...";
+    }
 }
 
 
+void OctreeQueryNode::deleteLater() {
+    _isShuttingDown = true;
+    if (_octreeSendThread) {
+        _octreeSendThread->setIsShuttingDown();
+    }
+    OctreeQuery::deleteLater();
+}
+
 
 void OctreeQueryNode::initializeOctreeSendThread(OctreeServer* octreeServer, const QUuid& nodeUUID) {
     // Create octree sending thread...
@@ -58,9 +83,13 @@ void OctreeQueryNode::initializeOctreeSendThread(OctreeServer* octreeServer, con
 }
 
 bool OctreeQueryNode::packetIsDuplicate() const {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return false;
+    }
     // since our packets now include header information, like sequence number, and createTime, we can't just do a memcmp
     // of the entire packet, we need to compare only the packet content...
-    int numBytesPacketHeader = numBytesForPacketHeaderGivenPacketType(getMyPacketType());
+    int numBytesPacketHeader = numBytesForPacketHeaderGivenPacketType(_myPacketType);
     
     if (_lastOctreePacketLength == getPacketLength()) {
         if (memcmp(_lastOctreePacket + (numBytesPacketHeader + OCTREE_PACKET_EXTRA_HEADERS_SIZE),
@@ -73,6 +102,11 @@ bool OctreeQueryNode::packetIsDuplicate() const {
 }
 
 bool OctreeQueryNode::shouldSuppressDuplicatePacket() {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return true;
+    }
+
     bool shouldSuppress = false; // assume we won't suppress
 
     // only consider duplicate packets
@@ -106,7 +140,17 @@ bool OctreeQueryNode::shouldSuppressDuplicatePacket() {
     return shouldSuppress;
 }
 
+void OctreeQueryNode::init() {
+    _myPacketType = getMyPacketType();
+    resetOctreePacket(true); // don't bump sequence
+}
+
 void OctreeQueryNode::resetOctreePacket(bool lastWasSurpressed) {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return;
+    }
+
     // Whenever we call this, we will keep a copy of the last packet, so we can determine if the last packet has
     // changed since we last reset it. Since we know that no two packets can ever be identical without being the same
     // scene information, (e.g. the root node packet of a static scene), we can use this as a strategy for reducing
@@ -127,7 +171,7 @@ void OctreeQueryNode::resetOctreePacket(bool lastWasSurpressed) {
     }
 
     _octreePacketAvailableBytes = MAX_PACKET_SIZE;
-    int numBytesPacketHeader = populatePacketHeader(reinterpret_cast<char*>(_octreePacket), getMyPacketType());
+    int numBytesPacketHeader = populatePacketHeader(reinterpret_cast<char*>(_octreePacket), _myPacketType);
     _octreePacketAt = _octreePacket + numBytesPacketHeader;
     _octreePacketAvailableBytes -= numBytesPacketHeader;
 
@@ -157,6 +201,11 @@ void OctreeQueryNode::resetOctreePacket(bool lastWasSurpressed) {
 }
 
 void OctreeQueryNode::writeToPacket(const unsigned char* buffer, unsigned int bytes) {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return;
+    }
+
     // compressed packets include lead bytes which contain compressed size, this allows packing of
     // multiple compressed portions together
     if (_currentPacketIsCompressed) {
@@ -173,6 +222,11 @@ void OctreeQueryNode::writeToPacket(const unsigned char* buffer, unsigned int by
 }
 
 bool OctreeQueryNode::updateCurrentViewFrustum() {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return false;
+    }
+
     bool currentViewFrustumChanged = false;
     ViewFrustum newestViewFrustum;
     // get position and orientation details from the camera
@@ -232,6 +286,11 @@ void OctreeQueryNode::setViewSent(bool viewSent) {
 }
 
 void OctreeQueryNode::updateLastKnownViewFrustum() {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return;
+    }
+
     bool frustumChanges = !_lastKnownViewFrustum.isVerySimilar(_currentViewFrustum);
 
     if (frustumChanges) {
@@ -246,6 +305,11 @@ void OctreeQueryNode::updateLastKnownViewFrustum() {
 
 
 bool OctreeQueryNode::moveShouldDump() const {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return false;
+    }
+
     glm::vec3 oldPosition = _lastKnownViewFrustum.getPosition();
     glm::vec3 newPosition = _currentViewFrustum.getPosition();
 
@@ -258,6 +322,11 @@ bool OctreeQueryNode::moveShouldDump() const {
 }
 
 void OctreeQueryNode::dumpOutOfView() {
+    // if shutting down, return immediately
+    if (_isShuttingDown) {
+        return;
+    }
+    
     int stillInView = 0;
     int outOfView = 0;
     OctreeElementBag tempBag;

assignment-client/src/octree/OctreeQueryNode.h

@@ -23,10 +23,13 @@ class OctreeSendThread;
 class OctreeServer;
 
 class OctreeQueryNode : public OctreeQuery {
+    Q_OBJECT
 public:
     OctreeQueryNode();
     virtual ~OctreeQueryNode();
+    virtual void deleteLater();
     
+    void init(); // called after creation to set up some virtual items
     virtual PacketType getMyPacketType() const = 0;
 
     void resetOctreePacket(bool lastWasSurpressed = false);  // resets octree packet to after "V" header
@@ -85,6 +88,13 @@ public:
     
     void dumpOutOfView();
     
+    quint64 getLastRootTimestamp() const { return _lastRootTimestamp; }
+    void setLastRootTimestamp(quint64 timestamp) { _lastRootTimestamp = timestamp; }
+    unsigned int getlastOctreePacketLength() const { return _lastOctreePacketLength; }
+    int getDuplicatePacketCount() const { return _duplicatePacketCount; }
+    
+    bool isShuttingDown() const { return _isShuttingDown; }
+    
 private:
     OctreeQueryNode(const OctreeQueryNode &);
     OctreeQueryNode& operator= (const OctreeQueryNode&);
@@ -119,6 +129,10 @@ private:
     bool _lodInitialized;
     
     OCTREE_PACKET_SEQUENCE _sequenceNumber;
+    quint64 _lastRootTimestamp;
+    
+    PacketType _myPacketType;
+    bool _isShuttingDown;
 };
 
 #endif /* defined(__hifi__OctreeQueryNode__) */

assignment-client/src/octree/OctreeSendThread.cpp

@@ -5,6 +5,8 @@
 //  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
 //
 
+#include <QMutexLocker>
+
 #include <NodeList.h>
 #include <PacketHeaders.h>
 #include <PerfStat.h>
@@ -21,20 +23,43 @@ OctreeSendThread::OctreeSendThread(const QUuid& nodeUUID, OctreeServer* myServer
     _nodeUUID(nodeUUID),
     _myServer(myServer),
     _packetData(),
-    _nodeMissingCount(0)
+    _nodeMissingCount(0),
+    _processLock(),
+    _isShuttingDown(false)
 {
-    qDebug() << "client connected - starting sending thread";
+    QString safeServerName("Octree");
+    if (_myServer) {
+        safeServerName = _myServer->getMyServerName();
+    }
+    qDebug() << qPrintable(safeServerName)  << "server [" << _myServer << "]: client connected "
+                                            "- starting sending thread [" << this << "]";
+
     OctreeServer::clientConnected();
 }
 
 OctreeSendThread::~OctreeSendThread() { 
-    qDebug() << "client disconnected - ending sending thread";
+    QString safeServerName("Octree");
+    if (_myServer) {
+        safeServerName = _myServer->getMyServerName();
+    }
+    qDebug() << qPrintable(safeServerName)  << "server [" << _myServer << "]: client disconnected "
+                                            "- ending sending thread [" << this << "]";
     OctreeServer::clientDisconnected(); 
 }
 
+void OctreeSendThread::setIsShuttingDown() {
+    QMutexLocker locker(&_processLock); // this will cause us to wait till the process loop is complete
+    _isShuttingDown = true;
+}
+
 
 bool OctreeSendThread::process() {
-
+    QMutexLocker locker(&_processLock);
+    
+    if (_isShuttingDown) {
+        return false; // exit early if we're shutting down
+    }
+    
     const int MAX_NODE_MISSING_CHECKS = 10;
     if (_nodeMissingCount > MAX_NODE_MISSING_CHECKS) {
         qDebug() << "our target node:" << _nodeUUID << "has been missing the last" << _nodeMissingCount 
@@ -46,7 +71,10 @@ bool OctreeSendThread::process() {
 
     // don't do any send processing until the initial load of the octree is complete...
     if (_myServer->isInitialLoadComplete()) {
-        SharedNodePointer node = NodeList::getInstance()->nodeWithUUID(_nodeUUID);
+    
+        // see if we can get access to our node, but don't wait on the lock, if the nodeList is busy
+        // it might not return a node that is known, but that's ok we can handle that case.
+        SharedNodePointer node = NodeList::getInstance()->nodeWithUUID(_nodeUUID, false);
 
         if (node) {
             _nodeMissingCount = 0;
@@ -55,20 +83,13 @@ bool OctreeSendThread::process() {
             nodeData = (OctreeQueryNode*) node->getLinkedData();
 
             // Sometimes the node data has not yet been linked, in which case we can't really do anything
-            if (nodeData) {
+            if (nodeData && !nodeData->isShuttingDown()) {
                 bool viewFrustumChanged = nodeData->updateCurrentViewFrustum();
-                if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-                    printf("nodeData->updateCurrentViewFrustum() changed=%s\n", debug::valueOf(viewFrustumChanged));
-                }
                 packetDistributor(node, nodeData, viewFrustumChanged);
             }
         } else {
             _nodeMissingCount++;
         }
-    } else {
-        if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-            qDebug("OctreeSendThread::process() waiting for isInitialLoadComplete()");
-        }
     }
 
     // Only sleep if we're still running and we got the lock last time we tried, otherwise try to get the lock asap
@@ -81,10 +102,6 @@ bool OctreeSendThread::process() {
             PerformanceWarning warn(false,"OctreeSendThread... usleep()",false,&_usleepTime,&_usleepCalls);
             usleep(usecToSleep);
         } else {
-            if (true || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-                qDebug() << "Last send took too much time (" << (elapsed / USECS_PER_MSEC) 
-                                <<" msecs), barely sleeping 1 usec!\n";
-            }
             const int MIN_USEC_TO_SLEEP = 1;
             usleep(MIN_USEC_TO_SLEEP);
         }
@@ -100,26 +117,20 @@ quint64 OctreeSendThread::_totalBytes = 0;
 quint64 OctreeSendThread::_totalWastedBytes = 0;
 quint64 OctreeSendThread::_totalPackets = 0;
 
-int OctreeSendThread::handlePacketSend(const SharedNodePointer& node, OctreeQueryNode* nodeData, int& trueBytesSent, int& truePacketsSent) {
+int OctreeSendThread::handlePacketSend(const SharedNodePointer& node, 
+                        OctreeQueryNode* nodeData, int& trueBytesSent, int& truePacketsSent) {
+                 
+    // if we're shutting down, then exit early       
+    if (nodeData->isShuttingDown()) {
+        return 0;
+    }
+    
     bool debug = _myServer->wantsDebugSending();
     quint64 now = usecTimestampNow();
 
     bool packetSent = false; // did we send a packet?
     int packetsSent = 0;
     
-    // double check that the node has an active socket, otherwise, don't send...
-
-    quint64 lockWaitStart = usecTimestampNow();
-    QMutexLocker locker(&node->getMutex());
-    quint64 lockWaitEnd = usecTimestampNow();
-    float lockWaitElapsedUsec = (float)(lockWaitEnd - lockWaitStart);
-    OctreeServer::trackNodeWaitTime(lockWaitElapsedUsec);
-
-    const HifiSockAddr* nodeAddress = node->getActiveSocket();
-    if (!nodeAddress) {
-        return packetsSent; // without sending...
-    }
-    
     // Here's where we check to see if this packet is a duplicate of the last packet. If it is, we will silently
     // obscure the packet and not send it. This allows the callers and upper level logic to not need to know about
     // this rate control savings.
@@ -137,7 +148,7 @@ int OctreeSendThread::handlePacketSend(const SharedNodePointer& node, OctreeQuer
 
 
     // If we've got a stats message ready to send, then see if we can piggyback them together
-    if (nodeData->stats.isReadyToSend()) {
+    if (nodeData->stats.isReadyToSend() && !nodeData->isShuttingDown()) {
         // Send the stats message to the client
         unsigned char* statsMessage = nodeData->stats.getStatsMessage();
         int statsMessageLength = nodeData->stats.getStatsMessageLength();
@@ -204,7 +215,7 @@ int OctreeSendThread::handlePacketSend(const SharedNodePointer& node, OctreeQuer
         nodeData->stats.markAsSent();
     } else {
         // If there's actually a packet waiting, then send it.
-        if (nodeData->isPacketWaiting()) {
+        if (nodeData->isPacketWaiting() && !nodeData->isShuttingDown()) {
             // just send the voxel packet
             NodeList::getInstance()->writeDatagram((char*) nodeData->getPacket(), nodeData->getPacketLength(),
                                                    SharedNodePointer(node));
@@ -235,8 +246,12 @@ int OctreeSendThread::handlePacketSend(const SharedNodePointer& node, OctreeQuer
 
 /// Version of voxel distributor that sends the deepest LOD level at once
 int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQueryNode* nodeData, bool viewFrustumChanged) {
-    bool forceDebugging = false;
 
+    // if shutting down, exit early
+    if (nodeData->isShuttingDown()) {
+        return 0;
+    }
+    
     int truePacketsSent = 0;
     int trueBytesSent = 0;
     int packetsSentThisInterval = 0;
@@ -259,72 +274,22 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
     // then let's just send that waiting packet.
     if (!nodeData->getCurrentPacketFormatMatches()) {
         if (nodeData->isPacketWaiting()) {
-            if (forceDebugging || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-                qDebug("about to call handlePacketSend() .... line: %d -- format change "
-                        "wantColor=%s wantCompression=%s SENDING PARTIAL PACKET! currentPacketIsColor=%s "
-                        "currentPacketIsCompressed=%s",
-                        __LINE__,
-                        debug::valueOf(wantColor), debug::valueOf(wantCompression),
-                        debug::valueOf(nodeData->getCurrentPacketIsColor()),
-                        debug::valueOf(nodeData->getCurrentPacketIsCompressed()) );
-            }
             packetsSentThisInterval += handlePacketSend(node, nodeData, trueBytesSent, truePacketsSent);
         } else {
-            if (forceDebugging || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-                qDebug("wantColor=%s wantCompression=%s FIXING HEADER! currentPacketIsColor=%s currentPacketIsCompressed=%s",
-                        debug::valueOf(wantColor), debug::valueOf(wantCompression),
-                        debug::valueOf(nodeData->getCurrentPacketIsColor()),
-                        debug::valueOf(nodeData->getCurrentPacketIsCompressed()) );
-            }
             nodeData->resetOctreePacket();
         }
         int targetSize = MAX_OCTREE_PACKET_DATA_SIZE;
         if (wantCompression) {
             targetSize = nodeData->getAvailable() - sizeof(OCTREE_PACKET_INTERNAL_SECTION_SIZE);
         }
-        if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-            qDebug("line:%d _packetData.changeSettings() wantCompression=%s targetSize=%d", __LINE__,
-                debug::valueOf(wantCompression), targetSize);
-        }
-
         _packetData.changeSettings(wantCompression, targetSize);
     }
 
-    if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-        qDebug("wantColor/isColor=%s/%s wantCompression/isCompressed=%s/%s viewFrustumChanged=%s, getWantLowResMoving()=%s",
-                debug::valueOf(wantColor), debug::valueOf(nodeData->getCurrentPacketIsColor()),
-                debug::valueOf(wantCompression), debug::valueOf(nodeData->getCurrentPacketIsCompressed()),
-                debug::valueOf(viewFrustumChanged), debug::valueOf(nodeData->getWantLowResMoving()));
-    }
-
     const ViewFrustum* lastViewFrustum =  wantDelta ? &nodeData->getLastKnownViewFrustum() : NULL;
 
-    if (forceDebugging || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-        qDebug("packetDistributor() viewFrustumChanged=%s, nodeBag.isEmpty=%s, viewSent=%s",
-                debug::valueOf(viewFrustumChanged), debug::valueOf(nodeData->nodeBag.isEmpty()),
-                debug::valueOf(nodeData->getViewSent())
-            );
-    }
-
     // If the current view frustum has changed OR we have nothing to send, then search against
     // the current view frustum for things to send.
     if (viewFrustumChanged || nodeData->nodeBag.isEmpty()) {
-        quint64 now = usecTimestampNow();
-        if (forceDebugging || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-            qDebug("(viewFrustumChanged=%s || nodeData->nodeBag.isEmpty() =%s)...",
-                   debug::valueOf(viewFrustumChanged), debug::valueOf(nodeData->nodeBag.isEmpty()));
-            if (nodeData->getLastTimeBagEmpty() > 0) {
-                float elapsedSceneSend = (now - nodeData->getLastTimeBagEmpty()) / 1000000.0f;
-                if (viewFrustumChanged) {
-                    qDebug("viewFrustumChanged resetting after elapsed time to send scene = %f seconds", elapsedSceneSend);
-                } else {
-                    qDebug("elapsed time to send scene = %f seconds", elapsedSceneSend);
-                }
-                qDebug("[ occlusionCulling:%s, wantDelta:%s, wantColor:%s ]",
-                       debug::valueOf(nodeData->getWantOcclusionCulling()), debug::valueOf(wantDelta),
-                       debug::valueOf(wantColor));
-            }
-        }
 
         // if our view has changed, we need to reset these things...
         if (viewFrustumChanged) {
@@ -342,44 +307,25 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
 
         // track completed scenes and send out the stats packet accordingly
         nodeData->stats.sceneCompleted();
-        ::endSceneSleepTime = _usleepTime;
-        unsigned long sleepTime = ::endSceneSleepTime - ::startSceneSleepTime;
+        nodeData->setLastRootTimestamp(_myServer->getOctree()->getRoot()->getLastChanged());
 
-        unsigned long encodeTime = nodeData->stats.getTotalEncodeTime();
-        unsigned long elapsedTime = nodeData->stats.getElapsedTime();
+        // TODO: add these to stats page
+        //::endSceneSleepTime = _usleepTime;
+        //unsigned long sleepTime = ::endSceneSleepTime - ::startSceneSleepTime;
+        //unsigned long encodeTime = nodeData->stats.getTotalEncodeTime();
+        //unsigned long elapsedTime = nodeData->stats.getElapsedTime();
 
-        if (forceDebugging || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-            qDebug("about to call handlePacketSend() .... line: %d -- completed scene", __LINE__ );
-        }
         int packetsJustSent = handlePacketSend(node, nodeData, trueBytesSent, truePacketsSent);
         packetsSentThisInterval += packetsJustSent;
-        if (forceDebugging) {
-            qDebug("packetsJustSent=%d packetsSentThisInterval=%d", packetsJustSent, packetsSentThisInterval);
-        }
-
-        if (forceDebugging || _myServer->wantsDebugSending()) {
-            qDebug() << "Scene completed at " << usecTimestampNow()
-                << "encodeTime:" << encodeTime
-                << " sleepTime:" << sleepTime
-                << " elapsed:" << elapsedTime
-                << " Packets:" << _totalPackets
-                << " Bytes:" << _totalBytes
-                << " Wasted:" << _totalWastedBytes;
-        }
 
         // If we're starting a full scene, then definitely we want to empty the nodeBag
         if (isFullScene) {
             nodeData->nodeBag.deleteAll();
         }
 
-        if (forceDebugging || _myServer->wantsDebugSending()) {
-            qDebug() << "Scene started at " << usecTimestampNow()
-                << " Packets:" << _totalPackets
-                << " Bytes:" << _totalBytes
-                << " Wasted:" << _totalWastedBytes;
-        }
-
-        ::startSceneSleepTime = _usleepTime;
+        // TODO: add these to stats page
+        //::startSceneSleepTime = _usleepTime;
+        
         // start tracking our stats
         nodeData->stats.sceneStarted(isFullScene, viewFrustumChanged, _myServer->getOctree()->getRoot(), _myServer->getJurisdiction());
 
@@ -398,60 +344,79 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
     if (!nodeData->nodeBag.isEmpty()) {
         int bytesWritten = 0;
         quint64 start = usecTimestampNow();
-        quint64 startCompressTimeMsecs = OctreePacketData::getCompressContentTime() / 1000;
-        quint64 startCompressCalls = OctreePacketData::getCompressContentCalls();
+
+        // TODO: add these to stats page
+        //quint64 startCompressTimeMsecs = OctreePacketData::getCompressContentTime() / 1000;
+        //quint64 startCompressCalls = OctreePacketData::getCompressContentCalls();
 
         int clientMaxPacketsPerInterval = std::max(1,(nodeData->getMaxOctreePacketsPerSecond() / INTERVALS_PER_SECOND));
         int maxPacketsPerInterval = std::min(clientMaxPacketsPerInterval, _myServer->getPacketsPerClientPerInterval());
 
-        if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-            qDebug("truePacketsSent=%d packetsSentThisInterval=%d maxPacketsPerInterval=%d server PPI=%d nodePPS=%d nodePPI=%d",
-                truePacketsSent, packetsSentThisInterval, maxPacketsPerInterval, _myServer->getPacketsPerClientPerInterval(),
-                nodeData->getMaxOctreePacketsPerSecond(), clientMaxPacketsPerInterval);
-        }
-
         int extraPackingAttempts = 0;
         bool completedScene = false;
-        while (somethingToSend && packetsSentThisInterval < maxPacketsPerInterval) {
-            if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-                qDebug("truePacketsSent=%d packetsSentThisInterval=%d maxPacketsPerInterval=%d server PPI=%d nodePPS=%d nodePPI=%d",
-                    truePacketsSent, packetsSentThisInterval, maxPacketsPerInterval, _myServer->getPacketsPerClientPerInterval(),
-                    nodeData->getMaxOctreePacketsPerSecond(), clientMaxPacketsPerInterval);
-            }
+        while (somethingToSend && packetsSentThisInterval < maxPacketsPerInterval && !nodeData->isShuttingDown()) {
+            float lockWaitElapsedUsec = OctreeServer::SKIP_TIME;
+            float encodeElapsedUsec = OctreeServer::SKIP_TIME;
+            float compressAndWriteElapsedUsec = OctreeServer::SKIP_TIME;
+            float packetSendingElapsedUsec = OctreeServer::SKIP_TIME;
+            
+            quint64 startInside = usecTimestampNow();            
 
             bool lastNodeDidntFit = false; // assume each node fits
             if (!nodeData->nodeBag.isEmpty()) {
                 OctreeElement* subTree = nodeData->nodeBag.extract();
+                
+                /* TODO: Looking for a way to prevent locking and encoding a tree that is not
+                // going to result in any packets being sent...
+                //
+                // If our node is root, and the root hasn't changed, and our view hasn't changed,
+                // and we've already seen at least one duplicate packet, then we probably don't need 
+                // to lock the tree and encode, because the result should be that no bytes will be 
+                // encoded, and this will be a duplicate packet from the  last one we sent...
+                OctreeElement* root = _myServer->getOctree()->getRoot();
+                bool skipEncode = false;
+                if (
+                        (subTree == root)
+                        && (nodeData->getLastRootTimestamp() == root->getLastChanged())
+                        && !viewFrustumChanged 
+                        && (nodeData->getDuplicatePacketCount() > 0)
+                ) {
+                    qDebug() << "is root, root not changed, view not changed, already seen a duplicate!"
+                        << "Can we skip it?";
+                    skipEncode = true;
+                }
+                */
+
                 bool wantOcclusionCulling = nodeData->getWantOcclusionCulling();
                 CoverageMap* coverageMap = wantOcclusionCulling ? &nodeData->map : IGNORE_COVERAGE_MAP;
-
+                
                 float voxelSizeScale = nodeData->getOctreeSizeScale();
                 int boundaryLevelAdjustClient = nodeData->getBoundaryLevelAdjust();
-
+                
                 int boundaryLevelAdjust = boundaryLevelAdjustClient + (viewFrustumChanged && nodeData->getWantLowResMoving()
-                                                                              ? LOW_RES_MOVING_ADJUST : NO_BOUNDARY_ADJUST);
-
+                                                                       ? LOW_RES_MOVING_ADJUST : NO_BOUNDARY_ADJUST);
+                
                 EncodeBitstreamParams params(INT_MAX, &nodeData->getCurrentViewFrustum(), wantColor,
                                              WANT_EXISTS_BITS, DONT_CHOP, wantDelta, lastViewFrustum,
                                              wantOcclusionCulling, coverageMap, boundaryLevelAdjust, voxelSizeScale,
                                              nodeData->getLastTimeBagEmpty(),
                                              isFullScene, &nodeData->stats, _myServer->getJurisdiction());
 
-
+                // TODO: should this include the lock time or not? This stat is sent down to the client,
+                // it seems like it may be a good idea to include the lock time as part of the encode time
+                // are reported to client. Since you can encode without the lock
+                nodeData->stats.encodeStarted();
+                
                 quint64 lockWaitStart = usecTimestampNow();
                 _myServer->getOctree()->lockForRead();
                 quint64 lockWaitEnd = usecTimestampNow();
-                float lockWaitElapsedUsec = (float)(lockWaitEnd - lockWaitStart);
-                OctreeServer::trackTreeWaitTime(lockWaitElapsedUsec);
-                
-                nodeData->stats.encodeStarted();
+                lockWaitElapsedUsec = (float)(lockWaitEnd - lockWaitStart);
 
                 quint64 encodeStart = usecTimestampNow();
                 bytesWritten = _myServer->getOctree()->encodeTreeBitstream(subTree, &_packetData, nodeData->nodeBag, params);
                 quint64 encodeEnd = usecTimestampNow();
-                int encodeElapsedMsec = (encodeEnd - encodeStart)/USECS_PER_MSEC;
-                OctreeServer::trackEncodeTime(encodeElapsedMsec);
-
+                encodeElapsedUsec = (float)(encodeEnd - encodeStart);
+                
                 // If after calling encodeTreeBitstream() there are no nodes left to send, then we know we've
                 // sent the entire scene. We want to know this below so we'll actually write this content into
                 // the packet and send it
@@ -490,6 +455,9 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
             // mean we should send the previous packet contents and reset it.
             if (completedScene || lastNodeDidntFit) {
                 if (_packetData.hasContent()) {
+                
+                    quint64 compressAndWriteStart = usecTimestampNow();
+                    
                     // if for some reason the finalized size is greater than our available size, then probably the "compressed"
                     // form actually inflated beyond our padding, and in this case we will send the current packet, then
                     // write to out new packet...
@@ -498,27 +466,19 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
 
 
                     if (writtenSize > nodeData->getAvailable()) {
-                        if (forceDebugging || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-                            qDebug("about to call handlePacketSend() .... line: %d -- "
-                                   "writtenSize[%d] > available[%d] too big, sending packet as is.",
-                                    __LINE__, writtenSize, nodeData->getAvailable());
-                        }
                         packetsSentThisInterval += handlePacketSend(node, nodeData, trueBytesSent, truePacketsSent);
                     }
 
-                    if (forceDebugging || (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug())) {
-                        qDebug(">>>>>> calling writeToPacket() available=%d compressedSize=%d uncompressedSize=%d target=%u",
-                                nodeData->getAvailable(), _packetData.getFinalizedSize(),
-                                _packetData.getUncompressedSize(), _packetData.getTargetSize());
-                    }
                     nodeData->writeToPacket(_packetData.getFinalizedData(), _packetData.getFinalizedSize());
                     extraPackingAttempts = 0;
+                    quint64 compressAndWriteEnd = usecTimestampNow();
+                    compressAndWriteElapsedUsec = (float)(compressAndWriteEnd - compressAndWriteStart);
                 }
 
                 // If we're not running compressed, then we know we can just send now. Or if we're running compressed, but
                 // the packet doesn't have enough space to bother attempting to pack more...
                 bool sendNow = true;
-
+                
                 if (nodeData->getCurrentPacketIsCompressed() &&
                     nodeData->getAvailable() >= MINIMUM_ATTEMPT_MORE_PACKING &&
                     extraPackingAttempts <= REASONABLE_NUMBER_OF_PACKING_ATTEMPTS) {
@@ -527,10 +487,11 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
 
                 int targetSize = MAX_OCTREE_PACKET_DATA_SIZE;
                 if (sendNow) {
-                    if (forceDebugging) {
-                        qDebug("about to call handlePacketSend() .... line: %d -- sendNow = TRUE", __LINE__);
-                    }
+                    quint64 packetSendingStart = usecTimestampNow();
                     packetsSentThisInterval += handlePacketSend(node, nodeData, trueBytesSent, truePacketsSent);
+                    quint64 packetSendingEnd = usecTimestampNow();
+                    packetSendingElapsedUsec = (float)(packetSendingEnd - packetSendingStart);
+
                     if (wantCompression) {
                         targetSize = nodeData->getAvailable() - sizeof(OCTREE_PACKET_INTERNAL_SECTION_SIZE);
                     }
@@ -543,19 +504,24 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
                     // a larger compressed size then uncompressed size
                     targetSize = nodeData->getAvailable() - sizeof(OCTREE_PACKET_INTERNAL_SECTION_SIZE) - COMPRESS_PADDING;
                 }
-                if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-                    qDebug("line:%d _packetData.changeSettings() wantCompression=%s targetSize=%d",__LINE__,
-                        debug::valueOf(nodeData->getWantCompression()), targetSize);
-                }
                 _packetData.changeSettings(nodeData->getWantCompression(), targetSize); // will do reset
+
             }
+            OctreeServer::trackTreeWaitTime(lockWaitElapsedUsec);
+            OctreeServer::trackEncodeTime(encodeElapsedUsec);
+            OctreeServer::trackCompressAndWriteTime(compressAndWriteElapsedUsec);
+            OctreeServer::trackPacketSendingTime(packetSendingElapsedUsec);
+            
+            quint64 endInside = usecTimestampNow();
+            quint64 elapsedInsideUsecs = endInside - startInside;
+            OctreeServer::trackInsideTime((float)elapsedInsideUsecs);
         }
 
 
         // Here's where we can/should allow the server to send other data...
         // send the environment packet
         // TODO: should we turn this into a while loop to better handle sending multiple special packets
-        if (_myServer->hasSpecialPacketToSend(node)) {
+        if (_myServer->hasSpecialPacketToSend(node) && !nodeData->isShuttingDown()) {
             trueBytesSent += _myServer->sendSpecialPacket(node);
             truePacketsSent++;
             packetsSentThisInterval++;
@@ -566,53 +532,21 @@ int OctreeSendThread::packetDistributor(const SharedNodePointer& node, OctreeQue
         int elapsedmsec = (end - start)/USECS_PER_MSEC;
         OctreeServer::trackLoopTime(elapsedmsec);
 
-        quint64 endCompressCalls = OctreePacketData::getCompressContentCalls();
-        int elapsedCompressCalls = endCompressCalls - startCompressCalls;
-
-        quint64 endCompressTimeMsecs = OctreePacketData::getCompressContentTime() / 1000;
-        int elapsedCompressTimeMsecs = endCompressTimeMsecs - startCompressTimeMsecs;
-
-        if (elapsedmsec > 100) {
-            if (elapsedmsec > 1000) {
-                int elapsedsec = (end - start)/1000000;
-                qDebug("WARNING! packetLoop() took %d seconds [%d milliseconds %d calls in compress] "
-                        "to generate %d bytes in %d packets %d nodes still to send",
-                        elapsedsec, elapsedCompressTimeMsecs, elapsedCompressCalls,
-                        trueBytesSent, truePacketsSent, nodeData->nodeBag.count());
-            } else {
-                qDebug("WARNING! packetLoop() took %d milliseconds [%d milliseconds %d calls in compress] "
-                        "to generate %d bytes in %d packets, %d nodes still to send",
-                        elapsedmsec, elapsedCompressTimeMsecs, elapsedCompressCalls,
-                        trueBytesSent, truePacketsSent, nodeData->nodeBag.count());
-            }
-        } else if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-            qDebug("packetLoop() took %d milliseconds [%d milliseconds %d calls in compress] "
-                    "to generate %d bytes in %d packets, %d nodes still to send",
-                    elapsedmsec, elapsedCompressTimeMsecs, elapsedCompressCalls,
-                    trueBytesSent, truePacketsSent, nodeData->nodeBag.count());
-        }
+        // TODO: add these to stats page
+        //quint64 endCompressCalls = OctreePacketData::getCompressContentCalls();
+        //int elapsedCompressCalls = endCompressCalls - startCompressCalls;
+        //quint64 endCompressTimeMsecs = OctreePacketData::getCompressContentTime() / 1000;
+        //int elapsedCompressTimeMsecs = endCompressTimeMsecs - startCompressTimeMsecs;
 
         // if after sending packets we've emptied our bag, then we want to remember that we've sent all
         // the voxels from the current view frustum
         if (nodeData->nodeBag.isEmpty()) {
             nodeData->updateLastKnownViewFrustum();
             nodeData->setViewSent(true);
-            if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-                nodeData->map.printStats();
-            }
             nodeData->map.erase(); // It would be nice if we could save this, and only reset it when the view frustum changes
         }
 
-        if (_myServer->wantsDebugSending() && _myServer->wantsVerboseDebug()) {
-            qDebug("truePacketsSent=%d packetsSentThisInterval=%d maxPacketsPerInterval=%d "
-                    "server PPI=%d nodePPS=%d nodePPI=%d",
-                    truePacketsSent, packetsSentThisInterval, maxPacketsPerInterval,
-                    _myServer->getPacketsPerClientPerInterval(), nodeData->getMaxOctreePacketsPerSecond(),
-                    clientMaxPacketsPerInterval);
-        }
-
     } // end if bag wasn't empty, and so we sent stuff...
 
     return truePacketsSent;
 }
-

assignment-client/src/octree/OctreeSendThread.h

@@ -19,9 +19,12 @@
 
 /// Threaded processor for sending voxel packets to a single client
 class OctreeSendThread : public GenericThread {
+    Q_OBJECT
 public:
     OctreeSendThread(const QUuid& nodeUUID, OctreeServer* myServer);
     virtual ~OctreeSendThread();
+    
+    void setIsShuttingDown();
 
     static quint64 _totalBytes;
     static quint64 _totalWastedBytes;
@@ -44,6 +47,8 @@ private:
     OctreePacketData _packetData;
     
     int _nodeMissingCount;
+    QMutex _processLock; // don't allow us to have our nodeData, or our thread to be deleted while we're processing
+    bool _isShuttingDown;
 };
 
 #endif // __octree_server__OctreeSendThread__

assignment-client/src/octree/OctreeServer.cpp

@@ -20,15 +20,155 @@
 
 OctreeServer* OctreeServer::_instance = NULL;
 int OctreeServer::_clientCount = 0;
-SimpleMovingAverage OctreeServer::_averageLoopTime(10000);
-SimpleMovingAverage OctreeServer::_averageEncodeTime(10000);
-SimpleMovingAverage OctreeServer::_averageTreeWaitTime(10000);
-SimpleMovingAverage OctreeServer::_averageNodeWaitTime(10000);
+const int MOVING_AVERAGE_SAMPLE_COUNTS = 1000000;
+
+float OctreeServer::SKIP_TIME = -1.0f; // use this for trackXXXTime() calls for non-times
+
+SimpleMovingAverage OctreeServer::_averageLoopTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageInsideTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+
+SimpleMovingAverage OctreeServer::_averageEncodeTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageShortEncodeTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageLongEncodeTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageExtraLongEncodeTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+int OctreeServer::_extraLongEncode = 0;
+int OctreeServer::_longEncode = 0;
+int OctreeServer::_shortEncode = 0;
+int OctreeServer::_noEncode = 0;
+
+SimpleMovingAverage OctreeServer::_averageTreeWaitTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageTreeShortWaitTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageTreeLongWaitTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageTreeExtraLongWaitTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+int OctreeServer::_extraLongTreeWait = 0;
+int OctreeServer::_longTreeWait = 0;
+int OctreeServer::_shortTreeWait = 0;
+int OctreeServer::_noTreeWait = 0;
+
+SimpleMovingAverage OctreeServer::_averageNodeWaitTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+
+SimpleMovingAverage OctreeServer::_averageCompressAndWriteTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageShortCompressTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageLongCompressTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+SimpleMovingAverage OctreeServer::_averageExtraLongCompressTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+int OctreeServer::_extraLongCompress = 0;
+int OctreeServer::_longCompress = 0;
+int OctreeServer::_shortCompress = 0;
+int OctreeServer::_noCompress = 0;
+
+SimpleMovingAverage OctreeServer::_averagePacketSendingTime(MOVING_AVERAGE_SAMPLE_COUNTS);
+int OctreeServer::_noSend = 0;
+
+
+void OctreeServer::resetSendingStats() {
+    _averageLoopTime.reset();
+
+    _averageEncodeTime.reset();
+    _averageShortEncodeTime.reset();
+    _averageLongEncodeTime.reset();
+    _averageExtraLongEncodeTime.reset();
+    _extraLongEncode = 0;
+    _longEncode = 0;
+    _shortEncode = 0;
+    _noEncode = 0;
+
+    _averageInsideTime.reset();
+    _averageTreeWaitTime.reset();
+    _averageTreeShortWaitTime.reset();
+    _averageTreeLongWaitTime.reset();
+    _averageTreeExtraLongWaitTime.reset();
+    _extraLongTreeWait = 0;
+    _longTreeWait = 0;
+    _shortTreeWait = 0;
+    _noTreeWait = 0;
+
+    _averageNodeWaitTime.reset();
+
+    _averageCompressAndWriteTime.reset();
+    _averageShortCompressTime.reset();
+    _averageLongCompressTime.reset();
+    _averageExtraLongCompressTime.reset();
+    _extraLongCompress = 0;
+    _longCompress = 0;
+    _shortCompress = 0;
+    _noCompress = 0;
+
+    _averagePacketSendingTime.reset();
+    _noSend = 0;
+}
+
+void OctreeServer::trackEncodeTime(float time) { 
+    const float MAX_SHORT_TIME = 10.0f;
+    const float MAX_LONG_TIME = 100.0f;
+
+    if (time == SKIP_TIME) {
+        _noEncode++;
+        time = 0.0f;
+    } else if (time <= MAX_SHORT_TIME) {
+        _shortEncode++;
+        _averageShortEncodeTime.updateAverage(time);
+    } else if (time <= MAX_LONG_TIME) {
+        _longEncode++;
+        _averageLongEncodeTime.updateAverage(time);
+    } else {
+        _extraLongEncode++;
+        _averageExtraLongEncodeTime.updateAverage(time);
+    }
+    _averageEncodeTime.updateAverage(time); 
+}
+
+void OctreeServer::trackTreeWaitTime(float time) { 
+    const float MAX_SHORT_TIME = 10.0f;
+    const float MAX_LONG_TIME = 100.0f;
+    if (time == SKIP_TIME) {
+        _noTreeWait++;
+        time = 0.0f;
+    } else if (time <= MAX_SHORT_TIME) {
+        _shortTreeWait++;
+        _averageTreeShortWaitTime.updateAverage(time);
+    } else if (time <= MAX_LONG_TIME) {
+        _longTreeWait++;
+        _averageTreeLongWaitTime.updateAverage(time);
+    } else {
+        _extraLongTreeWait++;
+        _averageTreeExtraLongWaitTime.updateAverage(time);
+    }
+    _averageTreeWaitTime.updateAverage(time);
+}
+
+void OctreeServer::trackCompressAndWriteTime(float time) { 
+    const float MAX_SHORT_TIME = 10.0f;
+    const float MAX_LONG_TIME = 100.0f;
+    if (time == SKIP_TIME) {
+        _noCompress++;
+        time = 0.0f;
+    } else if (time <= MAX_SHORT_TIME) {
+        _shortCompress++;
+        _averageShortCompressTime.updateAverage(time);
+    } else if (time <= MAX_LONG_TIME) {
+        _longCompress++;
+        _averageLongCompressTime.updateAverage(time);
+    } else {
+        _extraLongCompress++;
+        _averageExtraLongCompressTime.updateAverage(time);
+    }
+    _averageCompressAndWriteTime.updateAverage(time); 
+}
+
+void OctreeServer::trackPacketSendingTime(float time) { 
+    if (time == SKIP_TIME) {
+        _noSend++;
+        time = 0.0f;
+    }
+    _averagePacketSendingTime.updateAverage(time); 
+}
+
+
 
 void OctreeServer::attachQueryNodeToNode(Node* newNode) {
     if (!newNode->getLinkedData()) {
         OctreeQueryNode* newQueryNodeData = _instance->createOctreeQueryNode();
-        newQueryNodeData->resetOctreePacket(true); // don't bump sequence
+        newQueryNodeData->init();
         newNode->setLinkedData(newQueryNodeData);
     }
 }
@@ -55,9 +195,11 @@ OctreeServer::OctreeServer(const QByteArray& packet) :
 {
     _instance = this;
     _averageLoopTime.updateAverage(0);
+    qDebug() << "Octree server starting... [" << this << "]";
 }
 
 OctreeServer::~OctreeServer() {
+    qDebug() << qPrintable(_safeServerName) << "server shutting down... [" << this << "]";
     if (_parsedArgV) {
         for (int i = 0; i < _argc; i++) {
             delete[] _parsedArgV[i];
@@ -82,7 +224,7 @@ OctreeServer::~OctreeServer() {
 
     delete _jurisdiction;
     _jurisdiction = NULL;
-    qDebug() << "OctreeServer::~OctreeServer()... DONE";
+    qDebug() << qPrintable(_safeServerName) << "server DONE shutting down... [" << this << "]";
 }
 
 void OctreeServer::initHTTPManager(int port) {
@@ -94,7 +236,7 @@ void OctreeServer::initHTTPManager(int port) {
     _httpManager = new HTTPManager(port, documentRoot, this, this);
 }
 
-bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QString& path) {
+bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url) {
 
 #ifdef FORCE_CRASH
     if (connection->requestOperation() == QNetworkAccessManager::GetOperation
@@ -117,10 +259,11 @@ bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QString&
     bool showStats = false;
 
     if (connection->requestOperation() == QNetworkAccessManager::GetOperation) {
-        if (path == "/") {
+        if (url.path() == "/") {
             showStats = true;
-        } else if (path == "/resetStats") {
+        } else if (url.path() == "/resetStats") {
             _octreeInboundPacketProcessor->resetStats();
+            resetSendingStats();
             showStats = true;
         }
     }
@@ -255,7 +398,9 @@ bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QString&
         statsString += "\r\n";
 
         // display outbound packet stats
-        statsString += QString("<b>%1 Outbound Packet Statistics...</b>\r\n").arg(getMyServerName());
+        statsString += QString("<b>%1 Outbound Packet Statistics... "
+                                "<a href='/resetStats'>[RESET]</a></b>\r\n").arg(getMyServerName());
+
         quint64 totalOutboundPackets = OctreeSendThread::_totalPackets;
         quint64 totalOutboundBytes = OctreeSendThread::_totalBytes;
         quint64 totalWastedBytes = OctreeSendThread::_totalWastedBytes;
@@ -263,7 +408,7 @@ bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QString&
         quint64 totalBytesOfBitMasks = OctreePacketData::getTotalBytesOfBitMasks();
         quint64 totalBytesOfColor = OctreePacketData::getTotalBytesOfColor();
 
-        const int COLUMN_WIDTH = 10;
+        const int COLUMN_WIDTH = 19;
         statsString += QString("        Configured Max PPS/Client: %1 pps/client\r\n")
             .arg(locale.toString((uint)getPacketsPerClientPerSecond()).rightJustified(COLUMN_WIDTH, ' '));
         statsString += QString("        Configured Max PPS/Server: %1 pps/server\r\n\r\n")
@@ -272,21 +417,130 @@ bool OctreeServer::handleHTTPRequest(HTTPConnection* connection, const QString&
             .arg(locale.toString((uint)getCurrentClientCount()).rightJustified(COLUMN_WIDTH, ' '));
 
         float averageLoopTime = getAverageLoopTime();
-        statsString += QString().sprintf("        Average packetLoop() time:      %5.2f msecs\r\n", averageLoopTime);
-        qDebug() << "averageLoopTime=" << averageLoopTime;
+        statsString += QString().sprintf("           Average packetLoop() time:      %7.2f msecs\r\n", averageLoopTime);
 
-        float averageEncodeTime = getAverageEncodeTime();
-        statsString += QString().sprintf("              Average encode time:      %5.2f msecs\r\n", averageEncodeTime);
-        qDebug() << "averageEncodeTime=" << averageEncodeTime;
+        float averageInsideTime = getAverageInsideTime();
+        statsString += QString().sprintf("               Average 'inside' time:    %9.2f usecs\r\n\r\n", averageInsideTime);
 
+        int allWaitTimes = _extraLongTreeWait +_longTreeWait + _shortTreeWait + _noTreeWait;
 
         float averageTreeWaitTime = getAverageTreeWaitTime();
-        statsString += QString().sprintf("      Average tree lock wait time:    %7.2f usecs\r\n", averageTreeWaitTime);
-        qDebug() << "averageTreeWaitTime=" << averageTreeWaitTime;
+        statsString += QString().sprintf("         Average tree lock wait time:"
+                                         "    %9.2f usecs                 samples: %12d \r\n",
+                                         averageTreeWaitTime, allWaitTimes);
 
+        float zeroVsTotal = (allWaitTimes > 0) ? ((float)_noTreeWait / (float)allWaitTimes) : 0.0f;
+        statsString += QString().sprintf("                        No Lock Wait:"
+                                         "                          (%6.2f%%) samples: %12d \r\n",
+                                         zeroVsTotal * AS_PERCENT, _noTreeWait);
+
+        float shortVsTotal = (allWaitTimes > 0) ? ((float)_shortTreeWait / (float)allWaitTimes) : 0.0f;
+        statsString += QString().sprintf("       Avg tree lock short wait time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n",
+                                         _averageTreeShortWaitTime.getAverage(), 
+                                         shortVsTotal * AS_PERCENT, _shortTreeWait);
+
+        float longVsTotal = (allWaitTimes > 0) ? ((float)_longTreeWait / (float)allWaitTimes) : 0.0f;
+        statsString += QString().sprintf("        Avg tree lock long wait time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n",
+                                         _averageTreeLongWaitTime.getAverage(), 
+                                         longVsTotal * AS_PERCENT, _longTreeWait);
+
+        float extraLongVsTotal = (allWaitTimes > 0) ? ((float)_extraLongTreeWait / (float)allWaitTimes) : 0.0f;
+        statsString += QString().sprintf("  Avg tree lock extra long wait time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n\r\n",
+                                         _averageTreeExtraLongWaitTime.getAverage(), 
+                                         extraLongVsTotal * AS_PERCENT, _extraLongTreeWait);
+
+        float averageEncodeTime = getAverageEncodeTime();
+        statsString += QString().sprintf("                 Average encode time:    %9.2f usecs\r\n", averageEncodeTime);
+        
+        int allEncodeTimes = _noEncode + _shortEncode + _longEncode + _extraLongEncode;
+
+        float zeroVsTotalEncode = (allEncodeTimes > 0) ? ((float)_noEncode / (float)allEncodeTimes) : 0.0f;
+        statsString += QString().sprintf("                           No Encode:"
+                                         "                          (%6.2f%%) samples: %12d \r\n",
+                                         zeroVsTotalEncode * AS_PERCENT, _noEncode);
+
+        float shortVsTotalEncode = (allEncodeTimes > 0) ? ((float)_shortEncode / (float)allEncodeTimes) : 0.0f;
+        statsString += QString().sprintf("               Avg short encode time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n",
+                                         _averageShortEncodeTime.getAverage(), 
+                                         shortVsTotalEncode * AS_PERCENT, _shortEncode);
+
+        float longVsTotalEncode = (allEncodeTimes > 0) ? ((float)_longEncode / (float)allEncodeTimes) : 0.0f;
+        statsString += QString().sprintf("                Avg long encode time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n",
+                                         _averageLongEncodeTime.getAverage(), 
+                                         longVsTotalEncode * AS_PERCENT, _longEncode);
+
+        float extraLongVsTotalEncode = (allEncodeTimes > 0) ? ((float)_extraLongEncode / (float)allEncodeTimes) : 0.0f;
+        statsString += QString().sprintf("          Avg extra long encode time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n\r\n",
+                                         _averageExtraLongEncodeTime.getAverage(), 
+                                         extraLongVsTotalEncode * AS_PERCENT, _extraLongEncode);
+
+
+        float averageCompressAndWriteTime = getAverageCompressAndWriteTime();
+        statsString += QString().sprintf("     Average compress and write time:    %9.2f usecs\r\n", averageCompressAndWriteTime);
+
+        int allCompressTimes = _noCompress + _shortCompress + _longCompress + _extraLongCompress;
+
+        float zeroVsTotalCompress = (allCompressTimes > 0) ? ((float)_noCompress / (float)allCompressTimes) : 0.0f;
+        statsString += QString().sprintf("                      No compression:"
+                                         "                          (%6.2f%%) samples: %12d \r\n",
+                                         zeroVsTotalCompress * AS_PERCENT, _noCompress);
+
+        float shortVsTotalCompress = (allCompressTimes > 0) ? ((float)_shortCompress / (float)allCompressTimes) : 0.0f;
+        statsString += QString().sprintf("             Avg short compress time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n",
+                                         _averageShortCompressTime.getAverage(), 
+                                         shortVsTotalCompress * AS_PERCENT, _shortCompress);
+
+        float longVsTotalCompress = (allCompressTimes > 0) ? ((float)_longCompress / (float)allCompressTimes) : 0.0f;
+        statsString += QString().sprintf("              Avg long compress time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n",
+                                         _averageLongCompressTime.getAverage(), 
+                                         longVsTotalCompress * AS_PERCENT, _longCompress);
+
+        float extraLongVsTotalCompress = (allCompressTimes > 0) ? ((float)_extraLongCompress / (float)allCompressTimes) : 0.0f;
+        statsString += QString().sprintf("        Avg extra long compress time:"
+                                         "          %9.2f usecs (%6.2f%%) samples: %12d \r\n\r\n",
+                                         _averageExtraLongCompressTime.getAverage(), 
+                                         extraLongVsTotalCompress * AS_PERCENT, _extraLongCompress);
+
+        float averagePacketSendingTime = getAveragePacketSendingTime();
+        statsString += QString().sprintf("         Average packet sending time:    %9.2f usecs (includes node lock)\r\n", 
+                                        averagePacketSendingTime);
+
+        float noVsTotalSend = (_averagePacketSendingTime.getSampleCount() > 0) ? 
+                                        ((float)_noSend / (float)_averagePacketSendingTime.getSampleCount()) : 0.0f;
+        statsString += QString().sprintf("                         Not sending:"
+                                         "                          (%6.2f%%) samples: %12d \r\n",
+                                         noVsTotalSend * AS_PERCENT, _noSend);
+                                        
         float averageNodeWaitTime = getAverageNodeWaitTime();
-        statsString += QString().sprintf("      Average node lock wait time:    %7.2f usecs\r\n", averageNodeWaitTime);
-        qDebug() << "averageNodeWaitTime=" << averageNodeWaitTime;
+        statsString += QString().sprintf("         Average node lock wait time:    %9.2f usecs\r\n", averageNodeWaitTime);
+
+        statsString += QString().sprintf("--------------------------------------------------------------\r\n");
+
+        float encodeToInsidePercent = averageInsideTime == 0.0f ? 0.0f : (averageEncodeTime / averageInsideTime) * AS_PERCENT;
+        statsString += QString().sprintf("                          encode ratio:      %5.2f%%\r\n", 
+                                        encodeToInsidePercent);
+
+        float waitToInsidePercent = averageInsideTime == 0.0f ? 0.0f 
+                    : ((averageTreeWaitTime + averageNodeWaitTime) / averageInsideTime) * AS_PERCENT;
+        statsString += QString().sprintf("                         waiting ratio:      %5.2f%%\r\n", waitToInsidePercent);
+
+        float compressAndWriteToInsidePercent = averageInsideTime == 0.0f ? 0.0f 
+                    : (averageCompressAndWriteTime / averageInsideTime) * AS_PERCENT;
+        statsString += QString().sprintf("              compress and write ratio:      %5.2f%%\r\n", 
+                    compressAndWriteToInsidePercent);
+
+        float sendingToInsidePercent = averageInsideTime == 0.0f ? 0.0f 
+                    : (averagePacketSendingTime / averageInsideTime) * AS_PERCENT;
+        statsString += QString().sprintf("                         sending ratio:      %5.2f%%\r\n", sendingToInsidePercent);
+        
 
 
         statsString += QString("\r\n");
@@ -530,16 +784,26 @@ void OctreeServer::readPendingDatagrams() {
             if (packetType == getMyQueryMessageType()) {
                 bool debug = false;
                 if (debug) {
-                    qDebug() << "Got PacketTypeVoxelQuery at" << usecTimestampNow();
+                    if (matchingNode) {
+                        qDebug() << "Got PacketTypeVoxelQuery at" << usecTimestampNow() << "node:" << *matchingNode;
+                    } else {
+                        qDebug() << "Got PacketTypeVoxelQuery at" << usecTimestampNow() << "node: ??????";
+                    }
                 }
                 
                 // If we got a PacketType_VOXEL_QUERY, then we're talking to an NodeType_t_AVATAR, and we
                 // need to make sure we have it in our nodeList.
                 if (matchingNode) {
+                    if (debug) {
+                        qDebug() << "calling updateNodeWithDataFromPacket()... node:" << *matchingNode;
+                    }
                     nodeList->updateNodeWithDataFromPacket(matchingNode, receivedPacket);
                     
                     OctreeQueryNode* nodeData = (OctreeQueryNode*) matchingNode->getLinkedData();
                     if (nodeData && !nodeData->isOctreeSendThreadInitalized()) {
+                        if (debug) {
+                            qDebug() << "calling initializeOctreeSendThread()... node:" << *matchingNode;
+                        }
                         nodeData->initializeOctreeSendThread(this, matchingNode->getUUID());
                     }
                 }
@@ -556,11 +820,12 @@ void OctreeServer::readPendingDatagrams() {
 }
 
 void OctreeServer::run() {
+    _safeServerName = getMyServerName();
     // Before we do anything else, create our tree...
     _tree = createTree();
-
-    // change the logging target name while this is running
-    Logging::setTargetName(getMyLoggingServerTargetName());
+    
+    // use common init to setup common timers and logging
+    commonInit(getMyLoggingServerTargetName(), getMyNodeType());
 
     // Now would be a good time to parse our arguments, if we got them as assignment
     if (getPayload().size() > 0) {
@@ -611,10 +876,13 @@ void OctreeServer::run() {
     connect(nodeList, SIGNAL(nodeAdded(SharedNodePointer)), SLOT(nodeAdded(SharedNodePointer)));
     connect(nodeList, SIGNAL(nodeKilled(SharedNodePointer)),SLOT(nodeKilled(SharedNodePointer)));
 
+
     // we need to ask the DS about agents so we can ping/reply with them
     nodeList->addNodeTypeToInterestSet(NodeType::Agent);
 
+#ifndef WIN32
     setvbuf(stdout, NULL, _IOLBF, 0);
+#endif
 
     nodeList->linkedDataCreateCallback = &OctreeServer::attachQueryNodeToNode;
 
@@ -720,29 +988,32 @@ void OctreeServer::run() {
         strftime(utcBuffer, MAX_TIME_LENGTH, " [%m/%d/%Y %X UTC]", gmtm);
     }
     qDebug() << "Now running... started at: " << localBuffer << utcBuffer;
-
-    QTimer* domainServerTimer = new QTimer(this);
-    connect(domainServerTimer, SIGNAL(timeout()), this, SLOT(checkInWithDomainServerOrExit()));
-    domainServerTimer->start(DOMAIN_SERVER_CHECK_IN_USECS / 1000);
-
-    QTimer* silentNodeTimer = new QTimer(this);
-    connect(silentNodeTimer, SIGNAL(timeout()), nodeList, SLOT(removeSilentNodes()));
-    silentNodeTimer->start(NODE_SILENCE_THRESHOLD_USECS / 1000);
 }
 
 void OctreeServer::nodeAdded(SharedNodePointer node) {
     // we might choose to use this notifier to track clients in a pending state
+    qDebug() << qPrintable(_safeServerName) << "server added node:" << *node;
 }
 
 void OctreeServer::nodeKilled(SharedNodePointer node) {
+    qDebug() << qPrintable(_safeServerName) << "server killed node:" << *node;
     OctreeQueryNode* nodeData = static_cast<OctreeQueryNode*>(node->getLinkedData());
     if (nodeData) {
-        // Note: It should be safe to do this without locking the node, because if any other threads
-        // are using the SharedNodePointer, then they have a reference to the SharedNodePointer and the deleteLater()
-        // won't actually delete it until all threads have released their references to the pointer. 
-        // But we can and should clear the linked data so that no one else tries to access it.
+        qDebug() << qPrintable(_safeServerName) << "server resetting Linked Data for node:" << *node;
+        node->setLinkedData(NULL); // set this first in case another thread comes through and tryes to acces this
+        qDebug() << qPrintable(_safeServerName) << "server deleting Linked Data for node:" << *node;
         nodeData->deleteLater();
-        node->setLinkedData(NULL);
+    } else {
+        qDebug() << qPrintable(_safeServerName) << "server node missing linked data node:" << *node;
     }
 }
 
+void OctreeServer::aboutToFinish() {
+    qDebug() << qPrintable(_safeServerName) << "server STARTING about to finish...";
+    foreach (const SharedNodePointer& node, NodeList::getInstance()->getNodeHash()) {
+        qDebug() << qPrintable(_safeServerName) << "server about to finish while node still connected node:" << *node;
+        nodeKilled(node);
+    }
+    qDebug() << qPrintable(_safeServerName) << "server ENDING about to finish...";
+}
+

assignment-client/src/octree/OctreeServer.h

@@ -73,19 +73,34 @@ public:
     virtual int sendSpecialPacket(const SharedNodePointer& node) { return 0; }
 
     static void attachQueryNodeToNode(Node* newNode);
+    
+    static float SKIP_TIME; // use this for trackXXXTime() calls for non-times
 
     static void trackLoopTime(float time) { _averageLoopTime.updateAverage(time); }
     static float getAverageLoopTime() { return _averageLoopTime.getAverage(); }
 
-    static void trackEncodeTime(float time) { _averageEncodeTime.updateAverage(time); }
+    static void trackEncodeTime(float time);
     static float getAverageEncodeTime() { return _averageEncodeTime.getAverage(); }
 
-    static void trackTreeWaitTime(float time) { _averageTreeWaitTime.updateAverage(time); }
+    static void trackInsideTime(float time) { _averageInsideTime.updateAverage(time); }
+    static float getAverageInsideTime() { return _averageInsideTime.getAverage(); }
+
+    static void trackTreeWaitTime(float time);
     static float getAverageTreeWaitTime() { return _averageTreeWaitTime.getAverage(); }
+
     static void trackNodeWaitTime(float time) { _averageNodeWaitTime.updateAverage(time); }
     static float getAverageNodeWaitTime() { return _averageNodeWaitTime.getAverage(); }
 
-    bool handleHTTPRequest(HTTPConnection* connection, const QString& path);
+    static void trackCompressAndWriteTime(float time);
+    static float getAverageCompressAndWriteTime() { return _averageCompressAndWriteTime.getAverage(); }
+
+    static void trackPacketSendingTime(float time);
+    static float getAveragePacketSendingTime() { return _averagePacketSendingTime.getAverage(); }
+
+    bool handleHTTPRequest(HTTPConnection* connection, const QUrl& url);
+
+    virtual void aboutToFinish();
+    
 public slots:
     /// runs the voxel server assignment
     void run();
@@ -96,6 +111,7 @@ public slots:
 protected:
     void parsePayload();
     void initHTTPManager(int port);
+    void resetSendingStats();
 
     int _argc;
     const char** _argv;
@@ -120,12 +136,44 @@ protected:
 
     time_t _started;
     quint64 _startedUSecs;
+    QString _safeServerName;
     
     static int _clientCount;
     static SimpleMovingAverage _averageLoopTime;
+
     static SimpleMovingAverage _averageEncodeTime;
+    static SimpleMovingAverage _averageShortEncodeTime;
+    static SimpleMovingAverage _averageLongEncodeTime;
+    static SimpleMovingAverage _averageExtraLongEncodeTime;
+    static int _extraLongEncode;
+    static int _longEncode;
+    static int _shortEncode;
+    static int _noEncode;
+
+    static SimpleMovingAverage _averageInsideTime;
     static SimpleMovingAverage _averageTreeWaitTime;
+    static SimpleMovingAverage _averageTreeShortWaitTime;
+    static SimpleMovingAverage _averageTreeLongWaitTime;
+    static SimpleMovingAverage _averageTreeExtraLongWaitTime;
+    static int _extraLongTreeWait;
+    static int _longTreeWait;
+    static int _shortTreeWait;
+    static int _noTreeWait;
+
     static SimpleMovingAverage _averageNodeWaitTime;
+
+    static SimpleMovingAverage _averageCompressAndWriteTime;
+    static SimpleMovingAverage _averageShortCompressTime;
+    static SimpleMovingAverage _averageLongCompressTime;
+    static SimpleMovingAverage _averageExtraLongCompressTime;
+    static int _extraLongCompress;
+    static int _longCompress;
+    static int _shortCompress;
+    static int _noCompress;
+
+    static SimpleMovingAverage _averagePacketSendingTime;
+    static int _noSend;
+
 };
 
 #endif // __octree_server__OctreeServer__

assignment-client/src/voxels/VoxelServer.h

@@ -46,7 +46,6 @@ public:
     virtual bool hasSpecialPacketToSend(const SharedNodePointer& node);
     virtual int sendSpecialPacket(const SharedNodePointer& node);
 
-
 private:
     bool _sendEnvironments;
     bool _sendMinimalEnvironment;

domain-server/resources/web/css/style.css

@@ -38,4 +38,12 @@
 
 span.port {
   color: #666666;
+}
+
+.stats-key {
+  width: 400px;
+}
+
+.stale {
+  color: red;
 }

domain-server/resources/web/footer.html

@@ -1,3 +1,3 @@
 </div>
-<script src='js/jquery-2.0.3.min.js'></script>
-<script src="js/bootstrap.min.js"></script>
+<script src='/js/jquery-2.0.3.min.js'></script>
+<script src='/js/bootstrap.min.js'></script>

domain-server/resources/web/header.html

@@ -4,8 +4,8 @@
     <title>domain-server</title>
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <!-- Bootstrap -->
-    <link href="css/bootstrap.min.css" rel="stylesheet" media="screen">
-    <link href="css/style.css" rel="stylesheet" media="screen">
+    <link href="/css/bootstrap.min.css" rel="stylesheet" media="screen">
+    <link href="/css/style.css" rel="stylesheet" media="screen">
   </head>
   <body>
     <div class="container">

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

@@ -7,7 +7,7 @@ $(document).ready(function(){
       $.each(json.nodes, function (uuid, data) {
         nodesTableBody += "<tr>";
         nodesTableBody += "<td>" + data.type + "</td>";
-        nodesTableBody += "<td>" + uuid + "</td>";
+        nodesTableBody += "<td><a href='stats/?uuid=" + uuid + "'>" + uuid + "</a></td>";
         nodesTableBody += "<td>" + (data.pool ? data.pool : "") + "</td>";
         nodesTableBody += "<td>" + data.public.ip + "<span class='port'>:" + data.public.port + "</span></td>";
         nodesTableBody += "<td>" + data.local.ip + "<span class='port'>:" + data.local.port + "</span></td>";
@@ -42,7 +42,7 @@ $(document).ready(function(){
   $(document.body).on('click', '.glyphicon-remove', function(){
     // fire off a delete for this node
     $.ajax({
-        url: "/node/" + $(this).data('uuid'),
+        url: "/nodes/" + $(this).data('uuid'),
         type: 'DELETE',
         success: function(result) {
           console.log("Succesful request to delete node.");

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

@@ -0,0 +1,6 @@
+<!--#include virtual="header.html"-->
+<div id="stats-lead" class="table-lead"><h3>Stats</h3><div class="lead-line"></div></div>
+<table id="stats-table" class="table"><tbody></tbody></table>
+<!--#include virtual="footer.html"-->
+<script src='js/stats.js'></script>
+<!--#include virtual="page-end.html"-->

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

@@ -0,0 +1,42 @@
+function qs(key) {
+    key = key.replace(/[*+?^$.\[\]{}()|\\\/]/g, "\\$&"); // escape RegEx meta chars
+    var match = location.search.match(new RegExp("[?&]"+key+"=([^&]+)(&|$)"));
+    return match && decodeURIComponent(match[1].replace(/\+/g, " "));
+}
+
+$(document).ready(function(){
+  // setup a function to grab the nodeStats
+  function getNodeStats() {
+    
+    var uuid = qs("uuid");
+    
+    var statsTableBody = "";
+    
+    $.getJSON("/nodes/" + uuid + ".json", function(json){
+      
+      // update the table header with the right node type
+      $('#stats-lead h3').html(json.node_type + " stats (" + uuid + ")");
+      
+      delete json.node_type;
+      
+      $.each(json, function(key, value) {
+        statsTableBody += "<tr>";
+        statsTableBody += "<td class='stats-key'>" + key + "</td>";
+        var formattedValue = (typeof value == 'number' ? value.toLocaleString() : value);
+        statsTableBody += "<td>" + formattedValue + "</td>";
+        statsTableBody += "</tr>";
+      });
+      
+      $('#stats-table tbody').html(statsTableBody);
+    }).fail(function(data) {
+      $('#stats-table td').each(function(){
+        $(this).addClass('stale');
+      });
+    });    
+  }
+  
+  // do the first GET on page load
+  getNodeStats();
+  // grab the new assignments JSON every second
+  var getNodeStatsInterval = setInterval(getNodeStats, 1000);
+});

domain-server/src/DomainServer.cpp

@@ -603,6 +603,11 @@ void DomainServer::readAvailableDatagrams() {
                 if (noisyMessage) {
                     lastNoisyMessage = timeNow;
                 }
+            } else if (requestType == PacketTypeNodeJsonStats) {
+                SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket);
+                if (matchingNode) {
+                    reinterpret_cast<DomainServerNodeData*>(matchingNode->getLinkedData())->parseJSONStatsPacket(receivedPacket);
+                }
             }
         }
     }
@@ -646,14 +651,14 @@ QJsonObject DomainServer::jsonObjectForNode(const SharedNodePointer& node) {
     return nodeJson;
 }
 
-bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString& path) {
+bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QUrl& url) {
     const QString JSON_MIME_TYPE = "application/json";
     
     const QString URI_ASSIGNMENT = "/assignment";
-    const QString URI_NODE = "/node";
+    const QString URI_NODES = "/nodes";
     
     if (connection->requestOperation() == QNetworkAccessManager::GetOperation) {
-        if (path == "/assignments.json") {
+        if (url.path() == "/assignments.json") {
             // user is asking for json list of assignments
             
             // setup the JSON
@@ -697,7 +702,7 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
             
             // we've processed this request
             return true;
-        } else if (path == "/nodes.json") {
+        } else if (url.path() == QString("%1.json").arg(URI_NODES)) {
             // setup the JSON
             QJsonObject rootJSON;
             QJsonObject nodesJSON;
@@ -718,14 +723,41 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
             
             // send the response
             connection->respond(HTTPConnection::StatusCode200, nodesDocument.toJson(), qPrintable(JSON_MIME_TYPE));
+            
+            return true;
+        } else {
+            const QString NODE_REGEX_STRING =
+                QString("\\%1\\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}).json\\/?$").arg(URI_NODES);
+            QRegExp nodeShowRegex(NODE_REGEX_STRING);
+            
+            if (nodeShowRegex.indexIn(url.path()) != -1) {
+                QUuid matchingUUID = QUuid(nodeShowRegex.cap(1));
+                
+                // see if we have a node that matches this ID
+                SharedNodePointer matchingNode = NodeList::getInstance()->nodeWithUUID(matchingUUID);
+                if (matchingNode) {
+                    // create a QJsonDocument with the stats QJsonObject
+                    QJsonObject statsObject =
+                        reinterpret_cast<DomainServerNodeData*>(matchingNode->getLinkedData())->getStatsJSONObject();
+                    
+                    // add the node type to the JSON data for output purposes
+                    statsObject["node_type"] = NodeType::getNodeTypeName(matchingNode->getType()).toLower().replace(' ', '-');
+                    
+                    QJsonDocument statsDocument(statsObject);
+                    
+                    // send the response
+                    connection->respond(HTTPConnection::StatusCode200, statsDocument.toJson(), qPrintable(JSON_MIME_TYPE));
+                    
+                    // tell the caller we processed the request
+                    return true;
+                }
+            }
         }
     } else if (connection->requestOperation() == QNetworkAccessManager::PostOperation) {
-        if (path == URI_ASSIGNMENT) {
+        if (url.path() == URI_ASSIGNMENT) {
             // this is a script upload - ask the HTTPConnection to parse the form data
             QList<FormData> formData = connection->parseFormData();
             
-            
-            
             // check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
             const QString ASSIGNMENT_INSTANCES_HEADER = "ASSIGNMENT-INSTANCES";
             
@@ -765,13 +797,15 @@ bool DomainServer::handleHTTPRequest(HTTPConnection* connection, const QString&
             
             // respond with a 200 code for successful upload
             connection->respond(HTTPConnection::StatusCode200);
+            
+            return true;
         }
     } else if (connection->requestOperation() == QNetworkAccessManager::DeleteOperation) {
-        if (path.startsWith(URI_NODE)) {
+        if (url.path().startsWith(URI_NODES)) {
             // this is a request to DELETE a node by UUID
             
             // pull the UUID from the url
-            QUuid deleteUUID = QUuid(path.mid(URI_NODE.size() + sizeof('/')));
+            QUuid deleteUUID = QUuid(url.path().mid(URI_NODES.size() + sizeof('/')));
             
             if (!deleteUUID.isNull()) {
                 SharedNodePointer nodeToKill = NodeList::getInstance()->nodeWithUUID(deleteUUID);

domain-server/src/DomainServer.h

@@ -30,7 +30,7 @@ public:
     
     bool requiresAuthentication() const { return !_nodeAuthenticationURL.isEmpty(); }
     
-    bool handleHTTPRequest(HTTPConnection* connection, const QString& path);
+    bool handleHTTPRequest(HTTPConnection* connection, const QUrl& url);
     
     void exit(int retCode = 0);
     

domain-server/src/DomainServerNodeData.cpp

@@ -6,11 +6,43 @@
 //  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
 //
 
+#include <QtCore/QDataStream>
+#include <QtCore/QJsonObject>
+#include <QtCore/QVariant>
+
+#include <PacketHeaders.h>
+
 #include "DomainServerNodeData.h"
 
 DomainServerNodeData::DomainServerNodeData() :
     _sessionSecretHash(),
-    _staticAssignmentUUID()
+    _staticAssignmentUUID(),
+    _statsJSONObject()
 {
     
+}
+
+void DomainServerNodeData::parseJSONStatsPacket(const QByteArray& statsPacket) {
+    // push past the packet header
+    QDataStream packetStream(statsPacket);
+    packetStream.skipRawData(numBytesForPacketHeader(statsPacket));
+    
+    QVariantMap unpackedVariantMap;
+    
+    packetStream >> unpackedVariantMap;
+    
+    QJsonObject unpackedStatsJSON = QJsonObject::fromVariantMap(unpackedVariantMap);
+    _statsJSONObject = mergeJSONStatsFromNewObject(unpackedStatsJSON, _statsJSONObject);
+}
+
+QJsonObject DomainServerNodeData::mergeJSONStatsFromNewObject(const QJsonObject& newObject, QJsonObject destinationObject) {
+    foreach(const QString& key, newObject.keys()) {
+        if (newObject[key].isObject() && destinationObject.contains(key)) {
+            destinationObject[key] = mergeJSONStatsFromNewObject(newObject[key].toObject(), destinationObject[key].toObject());
+        } else {
+            destinationObject[key] = newObject[key];
+        }
+    }
+    
+    return destinationObject;
 }

domain-server/src/DomainServerNodeData.h

@@ -19,13 +19,20 @@ public:
     DomainServerNodeData();
     int parseData(const QByteArray& packet) { return 0; }
     
+    const QJsonObject& getStatsJSONObject() const { return _statsJSONObject; }
+    
+    void parseJSONStatsPacket(const QByteArray& statsPacket);
+    
     void setStaticAssignmentUUID(const QUuid& staticAssignmentUUID) { _staticAssignmentUUID = staticAssignmentUUID; }
     const QUuid& getStaticAssignmentUUID() const { return _staticAssignmentUUID; }
     
     QHash<QUuid, QUuid>& getSessionSecretHash() { return _sessionSecretHash; }
 private:
+    QJsonObject mergeJSONStatsFromNewObject(const QJsonObject& newObject, QJsonObject destinationObject);
+    
     QHash<QUuid, QUuid> _sessionSecretHash;
     QUuid _staticAssignmentUUID;
+    QJsonObject _statsJSONObject;
 };
 
 #endif /* defined(__hifi__DomainServerNodeData__) */

domain-server/src/main.cpp

@@ -20,10 +20,11 @@
 
 int main(int argc, char* argv[]) {
     
+#ifndef WIN32
     setvbuf(stdout, NULL, _IOLBF, 0);
-    
+#endif
+
     qInstallMessageHandler(Logging::verboseMessageHandler);
-    
     DomainServer domainServer(argc, argv);
     
     return domainServer.exec();

examples/audioDeviceExample.js

@@ -0,0 +1,52 @@
+//
+//  audioDeviceExample.js
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 3/22/14
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+//  This is an example script that demonstrates use of the Menu object
+//
+
+
+var outputDevices = AudioDevice.getOutputDevices();
+var defaultOutputDevice = AudioDevice.getDefaultOutputDevice();
+var selectOutputDevice = outputDevices[0];
+print("Output Devices:");
+for(var i = 0; i < outputDevices.length; i++) {
+    if (outputDevices[i] == defaultOutputDevice) {
+        print("    " + outputDevices[i] + " << default");
+    } else {
+        print("    " + outputDevices[i]);
+    }
+}
+
+print("Default Output Device:" + defaultOutputDevice);
+print("Selected Output Device:" + selectOutputDevice);
+print("Current Audio Output Device: " + AudioDevice.getOutputDevice());
+AudioDevice.setOutputDevice(selectOutputDevice);
+print("Audio Output Device: " + AudioDevice.getOutputDevice());
+
+var inputDevices = AudioDevice.getInputDevices();
+var selectInputDevice = inputDevices[0];
+var defaultInputDevice = AudioDevice.getDefaultInputDevice();
+print("Input Devices:");
+for(var i = 0; i < inputDevices.length; i++) {
+    if (inputDevices[i] == defaultInputDevice) {
+        print("    " + inputDevices[i] + " << default");
+    } else {
+        print("    " + inputDevices[i]);
+    }
+}
+
+print("Default Input Device:" + defaultInputDevice);
+print("Selected Input Device:" + selectInputDevice);
+print("Current Audio Input Device: " + AudioDevice.getInputDevice());
+AudioDevice.setInputDevice(selectInputDevice);
+print("Audio Input Device: " + AudioDevice.getInputDevice());
+
+print("Audio Input Device Level: " + AudioDevice.getInputVolume());
+AudioDevice.setInputVolume(AudioDevice.getInputVolume() * 2); // twice as loud!
+print("Audio Input Device Level: " + AudioDevice.getInputVolume());
+
+Script.stop();

examples/bot.js

@@ -26,16 +26,25 @@ var CHANCE_OF_MOVING = 0.005;
 var CHANCE_OF_SOUND = 0.005;
 var CHANCE_OF_HEAD_TURNING = 0.05;
 var CHANCE_OF_BIG_MOVE = 0.1;
+var CHANCE_OF_WAVING = 0.005;     //  Currently this isn't working
+
+var shouldReceiveVoxels = true; 
+var VOXEL_FPS = 60.0;
+var lastVoxelQueryTime = 0.0;
 
 var isMoving = false;
 var isTurningHead = false;
 var isPlayingAudio = false; 
+var isWaving = false;
+var waveFrequency = 0.0;
+var waveAmplitude = 0.0; 
 
 var X_MIN = 0.0;
 var X_MAX = 5.0;
 var Z_MIN = 0.0;
 var Z_MAX = 5.0;
 var Y_PELVIS = 2.5;
+var SHOULDER_JOINT_NUMBER = 15; 
 
 var MOVE_RANGE_SMALL = 0.5;
 var MOVE_RANGE_BIG = Math.max(X_MAX - X_MIN, Z_MAX - Z_MIN) / 2.0;
@@ -52,6 +61,8 @@ var targetDirection = { x: 0, y: 0, z: 0, w: 0 };
 var currentDirection = { x: 0, y: 0, z: 0, w: 0 };
 var targetHeadPitch = 0.0;
 
+var cumulativeTime = 0.0;
+
 var sounds = [];
 loadSounds();
 
@@ -60,20 +71,11 @@ function clamp(val, min, max){
 }
 
 //  Play a random sound from a list of conversational audio clips
-function audioDone() {
-  isPlayingAudio = false;
-}
-
 var AVERAGE_AUDIO_LENGTH = 8000;
-function playRandomSound(position) {
-  if (!isPlayingAudio) {
+function playRandomSound() {
+  if (!Agent.isPlayingAvatarSound) {
     var whichSound = Math.floor((Math.random() * sounds.length) % sounds.length);
-    var audioOptions = new AudioInjectionOptions();
-    audioOptions.volume = 0.25 + (Math.random() * 0.75);
-    audioOptions.position = position;
-    Audio.playSound(sounds[whichSound], audioOptions);
-    isPlayingAudio = true;
-    Script.setTimeout(audioDone, AVERAGE_AUDIO_LENGTH);
+    Agent.playAvatarSound(sounds[whichSound]);
   }
 }
 
@@ -104,18 +106,43 @@ Avatar.skeletonModelURL = "https://s3-us-west-1.amazonaws.com/highfidelity-publi
 Avatar.billboardURL = "https://s3-us-west-1.amazonaws.com/highfidelity-public/meshes/billboards/bot" + botNumber + ".png";
 
 Agent.isAvatar = true;
+Agent.isListeningToAudioStream = true;
 
 // change the avatar's position to the random one
 Avatar.position = firstPosition;  
 printVector("New bot, position = ", Avatar.position);
 
+function stopWaving() {
+  isWaving = false; 
+  Avatar.clearJointData(SHOULDER_JOINT_NUMBER);
+}
+
 function updateBehavior(deltaTime) {
-  if (Math.random() < CHANCE_OF_SOUND) {
-    playRandomSound(Avatar.position);
+  
+  cumulativeTime += deltaTime;
+
+  if (shouldReceiveVoxels && ((cumulativeTime - lastVoxelQueryTime) > (1.0 / VOXEL_FPS))) {
+    VoxelViewer.setPosition(Avatar.position);
+    VoxelViewer.setOrientation(Avatar.orientation);
+    VoxelViewer.queryOctree();
+    lastVoxelQueryTime = cumulativeTime;
+    /*
+    if (Math.random() < (1.0 / VOXEL_FPS)) {
+      print("Voxels in view = " + VoxelViewer.getOctreeElementsCount());
+    }*/
   }
 
-  if (isPlayingAudio) {
-    Avatar.handPosition = Vec3.sum(Avatar.position, Quat.getFront(Avatar.orientation));
+  if (!isWaving && (Math.random() < CHANCE_OF_WAVING)) {
+    isWaving = true;
+    waveFrequency = 1.0 + Math.random() * 5.0;
+    waveAmplitude = 5.0 + Math.random() * 60.0;
+    Script.setTimeout(stopWaving, 1000 + Math.random() * 2000);
+  } else if (isWaving) {
+    Avatar.setJointData(SHOULDER_JOINT_NUMBER, Quat.fromPitchYawRollDegrees(0.0, 0.0,  waveAmplitude * Math.sin(cumulativeTime * waveFrequency)));
+  }
+
+  if (Math.random() < CHANCE_OF_SOUND) {
+    playRandomSound();
   }
 
   if (!isTurningHead && (Math.random() < CHANCE_OF_HEAD_TURNING)) {

examples/crazylegs.js

@@ -12,6 +12,10 @@ var AMPLITUDE = 45.0;
 
 var cumulativeTime = 0.0;
 
+print("Joint List:");
+var jointList = MyAvatar.getJointNames(); 
+print(jointList);
+
 Script.update.connect(function(deltaTime) {
     cumulativeTime += deltaTime;
     MyAvatar.setJointData("joint_R_hip", Quat.fromPitchYawRollDegrees(0.0, 0.0, AMPLITUDE * Math.sin(cumulativeTime * FREQUENCY)));

examples/defaultScripts.js

@@ -0,0 +1,7 @@
+//  defaultScripts.js
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+Script.include("lookWithTouch.js");
+Script.include("editVoxels.js");
+Script.include("selectAudioDevice.js");
+Script.include("hydraMove.js");
+Script.include("inspect.js");

examples/editVoxels.js

@@ -20,8 +20,6 @@ var windowDimensions = Controller.getViewportDimensions();
 
 var NEW_VOXEL_SIZE = 1.0;
 var NEW_VOXEL_DISTANCE_FROM_CAMERA = 3.0;
-var ORBIT_RATE_ALTITUDE = 200.0;
-var ORBIT_RATE_AZIMUTH = 90.0;
 var PIXELS_PER_EXTRUDE_VOXEL = 16;
 var WHEEL_PIXELS_PER_SCALE_CHANGE = 100;
 var MAX_VOXEL_SCALE = 1.0;
@@ -34,22 +32,8 @@ var MIN_PASTE_VOXEL_SCALE = .256;
 var zFightingSizeAdjust = 0.002; // used to adjust preview voxels to prevent z fighting
 var previewLineWidth = 1.5;
 
-var oldMode = Camera.getMode();
-
 var isAdding = false; 
-var isExtruding = false; 
-var isOrbiting = false;
-var isOrbitingFromTouch = false;
-var isPanning = false;
-var isPanningFromTouch = false;
-var touchPointsToOrbit = 2; // you can change these, but be mindful that on some track pads 2 touch points = right click+drag
-var touchPointsToPan = 3; 
-var orbitAzimuth = 0.0;
-var orbitAltitude = 0.0;
-var orbitCenter = { x: 0, y: 0, z: 0 };
-var orbitPosition = { x: 0, y: 0, z: 0 };
-var torsoToEyeVector = { x: 0, y: 0, z: 0 }; 
-var orbitRadius = 0.0;
+var isExtruding = false;
 var extrudeDirection = { x: 0, y: 0, z: 0 };
 var extrudeScale = 0.0;
 var lastVoxelPosition = { x: 0, y: 0, z: 0 };
@@ -416,9 +400,9 @@ function calcScaleFromThumb(newThumbX) {
 }
 
 function setAudioPosition() {
-    var camera = Camera.getPosition();
+    var position = MyAvatar.position;
     var forwardVector = Quat.getFront(MyAvatar.orientation);
-    audioOptions.position = Vec3.sum(camera, forwardVector);
+    audioOptions.position = Vec3.sum(position, forwardVector);
 }
 
 function getNewPasteVoxel(pickRay) {
@@ -444,24 +428,11 @@ function getNewVoxelPosition() {
     return newPosition;
 }
 
-function fixEulerAngles(eulers) {
-    var rVal = { x: 0, y: 0, z: eulers.z };
-    if (eulers.x >= 90.0) {
-        rVal.x = 180.0 - eulers.x;
-        rVal.y = eulers.y - 180.0;
-    } else if (eulers.x <= -90.0) {
-        rVal.x = 180.0 - eulers.x;
-        rVal.y = eulers.y - 180.0;
-    }
-    return rVal;
-}
-
 var trackLastMouseX = 0;
 var trackLastMouseY = 0;
 var trackAsDelete = false;
 var trackAsRecolor = false;
 var trackAsEyedropper = false;
-var trackAsOrbitOrPan = false;
 
 var voxelToolSelected = true;
 var recolorToolSelected = false;
@@ -641,8 +612,6 @@ function showPreviewVoxel() {
     var guidePosition;
     if (trackAsRecolor || recolorToolSelected || trackAsEyedropper || eyedropperToolSelected) {
         Overlays.editOverlay(voxelPreview, { visible: true });
-    } else if (trackAsOrbitOrPan) {
-        Overlays.editOverlay(voxelPreview, { visible: false });
     } else if (voxelToolSelected && !isExtruding) {
         Overlays.editOverlay(voxelPreview, { visible: true });
     } else if (isExtruding) {
@@ -733,15 +702,12 @@ function showPreviewGuides() {
 }
 
 function trackMouseEvent(event) {
-    if (!trackAsOrbitOrPan) {
-        trackLastMouseX = event.x;
-        trackLastMouseY = event.y;
-        trackAsDelete = event.isControl;
-        trackAsRecolor = event.isShifted;
-        trackAsEyedropper = event.isMeta;
-        trackAsOrbitOrPan = event.isAlt; // TODO: double check this...??
-        showPreviewGuides();
-    }
+    trackLastMouseX = event.x;
+    trackLastMouseY = event.y;
+    trackAsDelete = event.isControl;
+    trackAsRecolor = event.isShifted;
+    trackAsEyedropper = event.isMeta;
+    showPreviewGuides();
 }
 
 function trackKeyPressEvent(event) {
@@ -761,10 +727,6 @@ function trackKeyPressEvent(event) {
         trackAsEyedropper = true;
         moveTools();
     }
-    if (event.text == "ALT") {
-        trackAsOrbitOrPan = true;
-        moveTools();
-    }
     showPreviewGuides();
 }
 
@@ -773,6 +735,8 @@ function trackKeyReleaseEvent(event) {
     if (event.text == "TAB") {
         editToolsOn = !editToolsOn;
         moveTools();
+        setAudioPosition(); // make sure we set the audio position before playing sounds
+        showPreviewGuides();
         Audio.playSound(clickSound, audioOptions);
     }
 
@@ -802,10 +766,6 @@ function trackKeyReleaseEvent(event) {
             trackAsEyedropper = false;
             moveTools();
         }
-        if (event.text == "ALT") {
-            trackAsOrbitOrPan = false;
-            moveTools();
-        }
         
         // on F1 toggle the preview mode between cubes and lines
         if (event.text == "F1") {
@@ -816,74 +776,6 @@ function trackKeyReleaseEvent(event) {
     }    
 }
 
-function startOrbitMode(event) {
-    mouseX = event.x;
-    mouseY = event.y;
-    var pickRay = Camera.computePickRay(event.x, event.y);
-    var intersection = Voxels.findRayIntersection(pickRay);
-
-    // start orbit camera! 
-    var cameraPosition = Camera.getPosition();
-    torsoToEyeVector = Vec3.subtract(cameraPosition, MyAvatar.position);
-    torsoToEyeVector.x = 0.0;
-    torsoToEyeVector.z = 0.0;
-    oldMode = Camera.getMode();
-    Camera.setMode("independent");
-    Camera.keepLookingAt(intersection.intersection);
-    // get position for initial azimuth, elevation
-    orbitCenter = intersection.intersection; 
-    var orbitVector = Vec3.subtract(cameraPosition, orbitCenter);
-    orbitRadius = Vec3.length(orbitVector); 
-    orbitAzimuth = Math.atan2(orbitVector.z, orbitVector.x);
-    orbitAltitude = Math.asin(orbitVector.y / Vec3.length(orbitVector));
-    
-    //print("startOrbitMode...");
-}
-
-function handleOrbitingMove(event) {
-    var cameraOrientation = Camera.getOrientation();
-    var origEulers = Quat.safeEulerAngles(cameraOrientation);
-    var newEulers = fixEulerAngles(Quat.safeEulerAngles(cameraOrientation));
-    var dx = event.x - mouseX; 
-    var dy = event.y - mouseY;
-    orbitAzimuth += dx / ORBIT_RATE_AZIMUTH;
-    orbitAltitude += dy / ORBIT_RATE_ALTITUDE;
-     var orbitVector = { x:(Math.cos(orbitAltitude) * Math.cos(orbitAzimuth)) * orbitRadius, 
-                        y:Math.sin(orbitAltitude) * orbitRadius,
-                        z:(Math.cos(orbitAltitude) * Math.sin(orbitAzimuth)) * orbitRadius }; 
-    orbitPosition = Vec3.sum(orbitCenter, orbitVector);
-    Camera.setPosition(orbitPosition);
-
-    mouseX = event.x; 
-    mouseY = event.y;
-    //print("handleOrbitingMove...");
-}
-
-function endOrbitMode(event) {
-    var cameraOrientation = Camera.getOrientation();
-    MyAvatar.position = Vec3.subtract(Camera.getPosition(), torsoToEyeVector);
-    MyAvatar.headOrientation = cameraOrientation;
-    Camera.stopLooking();
-    Camera.setMode(oldMode);
-    Camera.setOrientation(cameraOrientation);
-    //print("endOrbitMode...");
-}
-
-function startPanMode(event, intersection) {
-    // start pan camera! 
-    print("handle PAN mode!!!");
-}
-
-function handlePanMove(event) {
-    print("PANNING mode!!! ");
-    //print("isPanning="+isPanning + " inPanningFromTouch="+isPanningFromTouch + " trackAsOrbitOrPan="+trackAsOrbitOrPan);
-}
-
-function endPanMode(event) {
-    print("ending PAN mode!!!");
-}
-
-
 function mousePressEvent(event) {
 
     // if our tools are off, then don't do anything
@@ -891,93 +783,64 @@ function mousePressEvent(event) {
         return; 
     }
     
-    // Normally, if we're panning or orbiting from touch, ignore these... because our touch takes precedence. 
-    // but In the case of a button="RIGHT" click, we may get some touch messages first, and we actually want to 
-    // cancel any touch mode, and then let the right-click through
-    if (isOrbitingFromTouch || isPanningFromTouch) {
+    var clickedOnSomething = false;
+    var clickedOverlay = Overlays.getOverlayAtPoint({x: event.x, y: event.y});
     
-        // if the user is holding the ALT key AND they are clicking the RIGHT button (or on multi-touch doing a two
-        // finger touch, then we want to let the new panning behavior take over.
-        // if it's any other case we still want to bail
-        if (event.button == "RIGHT" && trackAsOrbitOrPan) {
-            // cancel our current multitouch operation...
-            if (isOrbitingFromTouch) {
-                endOrbitMode(event);
-                isOrbitingFromTouch = false;
+    // If the user clicked on the thumb, handle the slider logic
+    if (clickedOverlay == thumb) {
+        isMovingSlider = true;
+        thumbClickOffsetX = event.x - (sliderX + thumbX); // this should be the position of the mouse relative to the thumb
+        clickedOnSomething = true;
+        
+        Overlays.editOverlay(thumb, { imageURL: toolIconUrl + "voxel-size-slider-handle.svg", });
+        
+    } else if (clickedOverlay == voxelTool) {
+        voxelToolSelected = true;
+        recolorToolSelected = false;
+        eyedropperToolSelected = false;
+        moveTools();
+        clickedOnSomething = true;
+    } else if (clickedOverlay == recolorTool) {
+        voxelToolSelected = false;
+        recolorToolSelected = true;
+        eyedropperToolSelected = false;
+        moveTools();
+        clickedOnSomething = true;
+    } else if (clickedOverlay == eyedropperTool) {
+        voxelToolSelected = false;
+        recolorToolSelected = false;
+        eyedropperToolSelected = true;
+        moveTools();
+        clickedOnSomething = true;
+    } else if (clickedOverlay == slider) {
+        
+        if (event.x < sliderX + minThumbX) {
+            thumbX -= thumbDeltaPerStep;
+            calcScaleFromThumb(thumbX);
+        }
+        
+        if (event.x > sliderX + maxThumbX) {
+            thumbX += thumbDeltaPerStep;
+            calcScaleFromThumb(thumbX);
+        }
+        
+        moveTools();
+        clickedOnSomething = true;
+    } else {
+        // if the user clicked on one of the color swatches, update the selectedSwatch
+        for (s = 0; s < numColors; s++) {
+            if (clickedOverlay == swatches[s]) {
+                whichColor = s;
+                moveTools();
+                clickedOnSomething = true;
+                break;
             }
-            if (isPanningFromTouch) {
-                //print("mousePressEvent... calling endPanMode()");
-                endPanMode(event);
-                isPanningFromTouch = false;
-            }
-            // let things fall through
-        } else {
-            return; 
         }
     }
-    
-    // no clicking on overlays while in panning mode
-    if (!trackAsOrbitOrPan) {
-        var clickedOnSomething = false;
-        var clickedOverlay = Overlays.getOverlayAtPoint({x: event.x, y: event.y});
-      
-
-        // If the user clicked on the thumb, handle the slider logic
-        if (clickedOverlay == thumb) {
-            isMovingSlider = true;
-            thumbClickOffsetX = event.x - (sliderX + thumbX); // this should be the position of the mouse relative to the thumb
-            clickedOnSomething = true;
-
-            Overlays.editOverlay(thumb, { imageURL: toolIconUrl + "voxel-size-slider-handle.svg", });
-
-        } else if (clickedOverlay == voxelTool) {
-            voxelToolSelected = true;
-            recolorToolSelected = false;
-            eyedropperToolSelected = false;
-            moveTools();
-            clickedOnSomething = true;
-        } else if (clickedOverlay == recolorTool) {
-            voxelToolSelected = false;
-            recolorToolSelected = true;
-            eyedropperToolSelected = false;
-            moveTools();
-            clickedOnSomething = true;
-        } else if (clickedOverlay == eyedropperTool) {
-            voxelToolSelected = false;
-            recolorToolSelected = false;
-            eyedropperToolSelected = true;
-            moveTools();
-            clickedOnSomething = true;
-        } else if (clickedOverlay == slider) {
-
-            if (event.x < sliderX + minThumbX) {
-                thumbX -= thumbDeltaPerStep;
-                calcScaleFromThumb(thumbX);
-            }
-
-            if (event.x > sliderX + maxThumbX) {
-                thumbX += thumbDeltaPerStep;
-                calcScaleFromThumb(thumbX);
-            }
-
-            moveTools();
-            clickedOnSomething = true;
-        } else {
-            // if the user clicked on one of the color swatches, update the selectedSwatch
-            for (s = 0; s < numColors; s++) {
-                if (clickedOverlay == swatches[s]) {
-                    whichColor = s;
-                    moveTools();
-                    clickedOnSomething = true;
-                    break;
-                }
-            }
-        }
-        if (clickedOnSomething) {
-            return; // no further processing
-        }
+    if (clickedOnSomething) {
+        return; // no further processing
     }
-    
+
     // TODO: does any of this stuff need to execute if we're panning or orbiting?
     trackMouseEvent(event); // used by preview support
     mouseX = event.x;
@@ -1008,17 +871,7 @@ function mousePressEvent(event) {
             calcThumbFromScale(intersection.voxel.s);
         }
         
-        // Note: touch and mouse events can cross paths, so we want to ignore any mouse events that would
-        // start a pan or orbit if we're already doing a pan or orbit via touch...
-        if ((event.isAlt || trackAsOrbitOrPan) && !(isOrbitingFromTouch || isPanningFromTouch)) {
-            if (event.isLeftButton && !event.isRightButton) {
-                startOrbitMode(event);
-                isOrbiting = true;
-            } else if (event.isRightButton && !event.isLeftButton) {
-                startPanMode(event);
-                isPanning = true;
-            }
-        } else if (trackAsDelete || event.isRightButton && !trackAsEyedropper) {
+        if (trackAsDelete || event.isRightButton && !trackAsEyedropper) {
             //  Delete voxel
             voxelDetails = calculateVoxelFromIntersection(intersection,"delete");
             Voxels.eraseVoxel(voxelDetails.x, voxelDetails.y, voxelDetails.z, voxelDetails.s);
@@ -1209,24 +1062,8 @@ function mouseMoveEvent(event) {
         return;
     }
 
-    // if we're panning or orbiting from touch, ignore these... because our touch takes precedence. 
-    if (isOrbitingFromTouch || isPanningFromTouch) {
-        return; 
-    }
     
-    // double check that we didn't accidentally miss a pan or orbit click request
-    if (trackAsOrbitOrPan && !isPanning && !isOrbiting) {
-        if (event.isLeftButton && !event.isRightButton) {
-            startOrbitMode(event);
-            isOrbiting = true;
-        }
-        if (!event.isLeftButton && event.isRightButton) {
-            startPanMode(event);
-            isPanning = true;
-        }
-    }
-
-    if (!trackAsOrbitOrPan && isMovingSlider) {
+    if (isMovingSlider) {
         thumbX = (event.x - thumbClickOffsetX) - sliderX;
         if (thumbX < minThumbX) {
             thumbX = minThumbX;
@@ -1236,11 +1073,7 @@ function mouseMoveEvent(event) {
         }
         calcScaleFromThumb(thumbX);
         
-    } else if (isOrbiting) {
-        handleOrbitingMove(event);
-    } else if (isPanning) {
-        handlePanMove(event);
-    } else if (!trackAsOrbitOrPan && isAdding) {
+    } else if (isAdding) {
         //  Watch the drag direction to tell which way to 'extrude' this voxel
         if (!isExtruding) {
             var pickRay = Camera.computePickRay(event.x, event.y);
@@ -1271,7 +1104,6 @@ function mouseMoveEvent(event) {
             var dy = event.y - mouseY;
             if (Math.sqrt(dx*dx + dy*dy) > PIXELS_PER_EXTRUDE_VOXEL)  {
                 lastVoxelPosition = Vec3.sum(lastVoxelPosition, extrudeDirection);
-                Voxels.eraseVoxel(voxelDetails.x, voxelDetails.y, voxelDetails.z, voxelDetails.s);
                 Voxels.setVoxel(lastVoxelPosition.x, lastVoxelPosition.y, lastVoxelPosition.z, 
                             extrudeScale, lastVoxelColor.red, lastVoxelColor.green, lastVoxelColor.blue);
                 mouseX = event.x;
@@ -1293,16 +1125,6 @@ function mouseReleaseEvent(event) {
     if (isMovingSlider) {
         isMovingSlider = false;
     }
-    
-    if (isOrbiting) {
-        endOrbitMode(event);
-        isOrbiting = false;
-    }
-    if (isPanning) {
-        print("mouseReleaseEvent... calling endPanMode()");
-        endPanMode(event);
-        isPanning = false;
-    }
     isAdding = false;
     isExtruding = false; 
 }
@@ -1396,96 +1218,18 @@ function touchBeginEvent(event) {
     if (!editToolsOn) {
         return;
     }
-    
-    // if we're already in the middle of orbiting or panning, then ignore these multi-touch events...
-    if (isOrbiting || isPanning) {
-        return;
-    }    
-    
-    if (event.isAlt || trackAsOrbitOrPan) {
-        if (event.touchPoints == touchPointsToOrbit) {
-            // we need to double check that we didn't start an orbit, because the touch events will sometimes
-            // come in as 2 then 3 touches... 
-            if (isPanningFromTouch) {
-                print("touchBeginEvent... calling endPanMode()");
-                endPanMode(event);
-                isPanningFromTouch = false;
-            }
-            startOrbitMode(event);
-            isOrbitingFromTouch = true;
-        } else if (event.touchPoints == touchPointsToPan) {
-            // we need to double check that we didn't start an orbit, because the touch events will sometimes
-            // come in as 2 then 3 touches... 
-            if (isOrbitingFromTouch) {
-                endOrbitMode(event);
-                isOrbitingFromTouch = false;
-            }
-            startPanMode(event);
-            isPanningFromTouch = true;
-        }
-    }
 }
 
 function touchUpdateEvent(event) {
     if (!editToolsOn) {
         return;
     }
-
-    // if we're already in the middle of orbiting or panning, then ignore these multi-touch events...
-    if (isOrbiting || isPanning) {
-        return;
-    }    
-    
-    if (isOrbitingFromTouch) {
-        // we need to double check that we didn't start an orbit, because the touch events will sometimes
-        // come in as 2 then 3 touches... 
-        if (event.touchPoints == touchPointsToPan) {
-            //print("we now have touchPointsToPan touches... switch to pan...");
-            endOrbitMode(event);
-            isOrbitingFromTouch = false;
-            startPanMode(event);
-            isPanningFromTouch = true;
-        } else {
-            handleOrbitingMove(event);
-        }
-    }
-    if (isPanningFromTouch) {
-        //print("touchUpdateEvent... isPanningFromTouch... event.touchPoints=" + event.touchPoints);
-        // we need to double check that we didn't start an orbit, because the touch events will sometimes
-        // come in as 2 then 3 touches... 
-        if (event.touchPoints == touchPointsToOrbit) {
-            //print("we now have touchPointsToOrbit touches... switch to orbit...");
-            //print("touchUpdateEvent... calling endPanMode()");
-            endPanMode(event);
-            isPanningFromTouch = false;
-            startOrbitMode(event);
-            isOrbitingFromTouch = true;
-            handleOrbitingMove(event);
-        } else {
-            handlePanMove(event);
-        }
-    }
 }
 
 function touchEndEvent(event) {
     if (!editToolsOn) {
         return;
     }
-
-    // if we're already in the middle of orbiting or panning, then ignore these multi-touch events...
-    if (isOrbiting || isPanning) {
-        return;
-    }    
-    
-    if (isOrbitingFromTouch) {
-        endOrbitMode(event);
-        isOrbitingFromTouch = false;
-    }
-    if (isPanningFromTouch) {
-        print("touchEndEvent... calling endPanMode()");
-        endPanMode(event);
-        isPanningFromTouch = false;
-    }
 }
 
 var lastFingerAddVoxel = { x: -1, y: -1, z: -1}; // off of the build-able area

examples/gun.js

@@ -12,6 +12,11 @@
 //
 //
 
+
+function getRandomFloat(min, max) {
+    return Math.random() * (max - min) + min;
+}
+
 var lastX = 0;
 var lastY = 0;
 var yawFromMouse = 0;
@@ -19,17 +24,22 @@ var pitchFromMouse = 0;
 var isMouseDown = false; 
 
 var BULLET_VELOCITY = 5.0;
+var MIN_THROWER_DELAY = 1000;
+var MAX_THROWER_DELAY = 1000;
 var LEFT_BUTTON_3 = 3;
 
 // Load some sound to use for loading and firing 
 var fireSound = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Guns/GUN-SHOT2.raw");
 var loadSound = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Guns/Gun_Reload_Weapon22.raw");
 var impactSound = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Guns/BulletImpact2.raw");
-var targetLaunchSound = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Guns/GUN-SHOT2.raw");
+var targetHitSound = new Sound("http://highfidelity-public.s3-us-west-1.amazonaws.com/sounds/Space%20Invaders/hit.raw");
+var targetLaunchSound = new Sound("http://highfidelity-public.s3-us-west-1.amazonaws.com/sounds/Space%20Invaders/shoot.raw");
 
 var audioOptions = new AudioInjectionOptions();
 audioOptions.volume = 0.9;
 
+var shotTime = new Date(); 
+
 // initialize our triggers
 var triggerPulled = new Array();
 var numberOfTriggers = Controller.getNumberOfTriggers();
@@ -94,7 +104,9 @@ function shootTarget() {
     var DISTANCE_TO_LAUNCH_FROM = 3.0;
     var camera = Camera.getPosition();
     //printVector("camera", camera);
-    var forwardVector = Quat.getFront(Camera.getOrientation());
+    var targetDirection = Quat.angleAxis(getRandomFloat(-20.0, 20.0), { x:0, y:1, z:0 });
+    targetDirection = Quat.multiply(Camera.getOrientation(), targetDirection);
+    var forwardVector = Quat.getFront(targetDirection);
     //printVector("forwardVector", forwardVector);
     var newPosition = Vec3.sum(camera, Vec3.multiply(forwardVector, DISTANCE_TO_LAUNCH_FROM));
     //printVector("newPosition", newPosition);
@@ -111,6 +123,9 @@ function shootTarget() {
           lifetime: 1000.0,
           damping: 0.99 });
 
+    // Record start time 
+    shotTime = new Date();
+
     // Play target shoot sound
     audioOptions.position = newPosition;   
     Audio.playSound(targetLaunchSound, audioOptions);
@@ -119,31 +134,43 @@ function shootTarget() {
 
 
 function particleCollisionWithVoxel(particle, voxel, penetration) {
-    Vec3.print('particleCollisionWithVoxel() ... penetration=', penetration);
-
     var HOLE_SIZE = 0.125;
     var particleProperties = Particles.getParticleProperties(particle);
     var position = particleProperties.position; 
     Particles.deleteParticle(particle);
     //  Make a hole in this voxel 
+    Vec3.print("penetration", penetration);
+    Vec3.print("position", position);
+    var pointOfEntry = Vec3.subtract(position, penetration);
+    Vec3.print("pointOfEntry", pointOfEntry);
+    Voxels.eraseVoxel(pointOfEntry.x, pointOfEntry.y, pointOfEntry.z, HOLE_SIZE);
     Voxels.eraseVoxel(position.x, position.y, position.z, HOLE_SIZE);
     //audioOptions.position = position; 
     audioOptions.position = Vec3.sum(Camera.getPosition(), Quat.getFront(Camera.getOrientation()));
-    Audio.playSound(impactSound, audioOptions); 
+    Audio.playSound(targetHitSound, audioOptions); 
 }
 
 function particleCollisionWithParticle(particle1, particle2) {
-    print("Particle/Particle!");
     score++;
     Overlays.editOverlay(text, { text: "Score: " + score } );
+    //  Sort out which particle is which 
+
+    //  Record shot time 
+    var endTime = new Date(); 
+    var msecs = endTime.valueOf() - shotTime.valueOf();
+    print("hit, msecs = " + msecs);
     Particles.deleteParticle(particle1);
     Particles.deleteParticle(particle2);
+    audioOptions.position = newPosition;
+    audioOptions.position = Vec3.sum(Camera.getPosition(), Quat.getFront(Camera.getOrientation()));   
+    Audio.playSound(targetHitSound, audioOptions);
 }
 
 function keyPressEvent(event) {
     // if our tools are off, then don't do anything
     if (event.text == "t") {
-        shootTarget();
+        var time = MIN_THROWER_DELAY + Math.random() * MAX_THROWER_DELAY;
+        Script.setTimeout(shootTarget, time); 
     }
 }
 
@@ -164,7 +191,8 @@ function update(deltaTime) {
     //  Check hydra controller for launch button press 
     if (!isLaunchButtonPressed && Controller.isButtonPressed(LEFT_BUTTON_3)) {
         isLaunchButtonPressed = true; 
-        shootTarget();
+        var time = MIN_THROWER_DELAY + Math.random() * MAX_THROWER_DELAY;
+        Script.setTimeout(shootTarget, time);
     } else if (isLaunchButtonPressed && !Controller.isButtonPressed(LEFT_BUTTON_3)) {
         isLaunchButtonPressed = false;   
         

examples/includeExample.js

@@ -0,0 +1,16 @@
+//
+//  includeExample.js
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 3/24/14
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+//  This is an example script that demonstrates use of the Script.include() feature
+//
+
+// You can include scripts from URLs
+Script.include("http://public.highfidelity.io/scripts/lookWithTouch.js");
+
+// You can also include scripts that are relative to the current script
+Script.include("editVoxels.js");
+Script.include("../examples/selectAudioDevice.js");

examples/inspect.js

@@ -0,0 +1,248 @@
+//
+//  inspect.js
+//  hifi
+//
+//  Created by Clément Brisset on March 20, 2014
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+//  Allows you to inspect non moving objects (Voxels or Avatars) using Atl, Control (Command on Mac) and Shift
+//
+//  radial mode = hold ALT
+//  orbit mode  = hold ALT + CONTROL
+//  pan mode    = hold ALT + CONTROL + SHIFT
+//  Once you are in a mode left click on the object to inspect and hold the click
+//  Dragging the mouse will move your camera according to the mode you are in.
+//
+
+var PI = 3.14 // No need for something more precise
+
+var AZIMUTH_RATE = 90.0;
+var ALTITUDE_RATE = 200.0;
+var RADIUS_RATE = 1.0 / 100.0;
+var PAN_RATE = 50.0;
+
+var alt = false;
+var shift = false;
+var control = false;
+
+var isActive = false;
+
+var noMode = 0;
+var orbitMode = 1;
+var radialMode = 2;
+var panningMode = 3;
+
+var mode = noMode;
+
+var mouseLastX = 0;
+var mouseLastY = 0;
+
+
+var center = { x: 0, y: 0, z: 0 };
+var position = { x: 0, y: 0, z: 0 };
+var vector = { x: 0, y: 0, z: 0 };
+var radius = 0.0;
+var azimuth = 0.0;
+var altitude = 0.0;
+
+
+function handleRadialMode(dx, dy) {
+    azimuth += dx / AZIMUTH_RATE;
+    radius += radius * dy * RADIUS_RATE;
+    if (radius < 1) {
+        radius = 1;
+    }
+    
+    vector = { x: (Math.cos(altitude) * Math.cos(azimuth)) * radius,
+               y: Math.sin(altitude) * radius,
+               z: (Math.cos(altitude) * Math.sin(azimuth)) * radius };
+    position = Vec3.sum(center, vector);
+    Camera.setPosition(position);
+}
+
+function handleOrbitMode(dx, dy) {
+    azimuth += dx / AZIMUTH_RATE;
+    altitude += dy / ALTITUDE_RATE;
+    if (altitude > PI / 2.0) {
+        altitude = PI / 2.0;
+    }
+    if (altitude < -PI / 2.0) {
+        altitude = -PI / 2.0;
+    }
+    
+    vector = { x:(Math.cos(altitude) * Math.cos(azimuth)) * radius,
+               y:Math.sin(altitude) * radius,
+               z:(Math.cos(altitude) * Math.sin(azimuth)) * radius };
+    position = Vec3.sum(center, vector);
+    Camera.setPosition(position);
+}
+
+
+function handlePanMode(dx, dy) {
+    var up = Quat.getUp(Camera.getOrientation());
+    var right = Quat.getRight(Camera.getOrientation());
+    var distance = Vec3.length(vector);
+    
+    var dv = Vec3.sum(Vec3.multiply(up, - distance * dy / PAN_RATE), Vec3.multiply(right, distance * dx / PAN_RATE));
+    
+    center = Vec3.sum(center, dv);
+    position = Vec3.sum(position, dv);
+    
+    Camera.setPosition(position);
+    Camera.keepLookingAt(center);
+}
+
+function saveCameraState() {
+    oldMode = Camera.getMode();
+    var oldPosition = Camera.getPosition();
+    Camera.setMode("independent");
+    Camera.setPosition(oldPosition);
+}
+
+function restoreCameraState() {
+    Camera.stopLooking();
+    Camera.setMode(oldMode);
+}
+
+function handleModes() {
+    var newMode = noMode;
+    if (alt) {
+        if (control) {
+            if (shift) {
+                newMode = panningMode;
+            } else {
+                newMode = orbitMode;
+            }
+        } else {
+            newMode = radialMode;
+        }
+    }
+    
+    // if leaving noMode
+    if (mode == noMode && newMode != noMode) {
+        saveCameraState();
+    }
+    // if entering noMode
+    if (newMode == noMode && mode != noMode) {
+        restoreCameraState();
+    }
+    
+    mode = newMode;
+}
+
+function keyPressEvent(event) {
+    var changed = false;
+    
+    if (event.text == "ALT") {
+        alt = true;
+        changed = true;
+    }
+    if (event.text == "CONTROL") {
+        control = true;
+        changed = true;
+    }
+    if (event.text == "SHIFT") {
+        shift = true;
+        changed = true;
+    }
+    
+    if (changed) {
+        handleModes();
+    }
+}
+
+function keyReleaseEvent(event) {
+    var changed = false;
+   
+    if (event.text == "ALT") {
+        alt = false;
+        changed = true;
+    }
+    if (event.text == "CONTROL") {
+        control = false;
+        changed = true;
+    }
+    if (event.text == "SHIFT") {
+        shift = false;
+        changed = true;
+    }
+    
+    if (changed) {
+        handleModes();
+    }
+}
+
+function mousePressEvent(event) {
+    if (alt && !isActive) {
+        isActive = true;
+        mouseLastX = event.x;
+        mouseLastY = event.y;
+        
+        // Compute trajectories related values
+        var pickRay = Camera.computePickRay(mouseLastX, mouseLastY);
+        var intersection = Voxels.findRayIntersection(pickRay);
+        
+        position = Camera.getPosition();
+        
+        avatarTarget = MyAvatar.getTargetAvatarPosition();
+        voxelTarget = intersection.intersection;
+        if (Vec3.length(Vec3.subtract(avatarTarget, position)) < Vec3.length(Vec3.subtract(voxelTarget, position))) {
+            if (avatarTarget.x != 0 || avatarTarget.y != 0 || avatarTarget.z != 0) {
+                center  = avatarTarget;
+            } else {
+                center = voxelTarget;
+            }
+        } else {
+            if (voxelTarget.x != 0 || voxelTarget.y != 0 || voxelTarget.z != 0) {
+                center  = voxelTarget;
+            } else {
+                center = avatarTarget;
+            }
+        }
+        
+        vector = Vec3.subtract(position, center);
+        radius = Vec3.length(vector);
+        azimuth = Math.atan2(vector.z, vector.x);
+        altitude = Math.asin(vector.y / Vec3.length(vector));
+        
+        Camera.keepLookingAt(center);
+    }
+}
+
+function mouseReleaseEvent(event) {
+    if (isActive) {
+        isActive = false;
+    }
+}
+
+function mouseMoveEvent(event) {
+    if (isActive && mode != noMode) {
+        if (mode == radialMode) {
+            handleRadialMode(event.x - mouseLastX, event.y - mouseLastY);
+        }
+        if (mode == orbitMode) {
+            handleOrbitMode(event.x - mouseLastX, event.y - mouseLastY);
+        }
+        if (mode == panningMode) {
+            handlePanMode(event.x - mouseLastX, event.y - mouseLastY);
+        }
+        
+        mouseLastX = event.x;
+        mouseLastY = event.y;
+    }
+}
+
+function scriptEnding() {
+    if (mode != noMode) {
+        restoreCameraState();
+    }
+}
+
+Controller.keyPressEvent.connect(keyPressEvent);
+Controller.keyReleaseEvent.connect(keyReleaseEvent);
+
+Controller.mousePressEvent.connect(mousePressEvent);
+Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
+Controller.mouseMoveEvent.connect(mouseMoveEvent);
+
+Script.scriptEnding.connect(scriptEnding);

examples/lookWithTouch.js

@@ -9,6 +9,7 @@
 //
 //
 
+var startedTouching = false;
 var lastX = 0;
 var lastY = 0;
 var yawFromMouse = 0;
@@ -21,12 +22,14 @@ function touchBeginEvent(event) {
     }
     lastX = event.x;
     lastY = event.y;
+    startedTouching = true;
 }
 
 function touchEndEvent(event) {
     if (wantDebugging) {
         print("touchEndEvent event.x,y=" + event.x + ", " + event.y);
     }
+    startedTouching = false;
 }
 
 function touchUpdateEvent(event) {
@@ -44,24 +47,26 @@ function touchUpdateEvent(event) {
 }
 
 function update(deltaTime) {
-    // rotate body yaw for yaw received from mouse
-    var newOrientation = Quat.multiply(MyAvatar.orientation, Quat.fromPitchYawRollRadians(0, yawFromMouse, 0));
-    if (wantDebugging) {
-        print("changing orientation"
-            + " [old]MyAvatar.orientation="+MyAvatar.orientation.x + "," + MyAvatar.orientation.y + "," 
-            + MyAvatar.orientation.z + "," + MyAvatar.orientation.w
-            + " newOrientation="+newOrientation.x + "," + newOrientation.y + "," + newOrientation.z + "," + newOrientation.w);
-    }
-    MyAvatar.orientation = newOrientation;
-    yawFromMouse = 0;
+    if (startedTouching) {
+        // rotate body yaw for yaw received from mouse
+        var newOrientation = Quat.multiply(MyAvatar.orientation, Quat.fromPitchYawRollRadians(0, yawFromMouse, 0));
+        if (wantDebugging) {
+            print("changing orientation"
+                + " [old]MyAvatar.orientation="+MyAvatar.orientation.x + "," + MyAvatar.orientation.y + "," 
+                + MyAvatar.orientation.z + "," + MyAvatar.orientation.w
+                + " newOrientation="+newOrientation.x + "," + newOrientation.y + "," + newOrientation.z + "," + newOrientation.w);
+        }
+        MyAvatar.orientation = newOrientation;
+        yawFromMouse = 0;
 
-    // apply pitch from mouse
-    var newPitch = MyAvatar.headPitch + pitchFromMouse;
-    if (wantDebugging) {
-        print("changing pitch [old]MyAvatar.headPitch="+MyAvatar.headPitch+ " newPitch="+newPitch);
+        // apply pitch from mouse
+        var newPitch = MyAvatar.headPitch + pitchFromMouse;
+        if (wantDebugging) {
+            print("changing pitch [old]MyAvatar.headPitch="+MyAvatar.headPitch+ " newPitch="+newPitch);
+        }
+        MyAvatar.headPitch = newPitch;
+        pitchFromMouse = 0;
     }
-    MyAvatar.headPitch = newPitch;
-    pitchFromMouse = 0;
 }
 
 // Map the mouse events to our functions
@@ -77,10 +82,6 @@ function scriptEnding() {
     Controller.releaseTouchEvents();
 }
 
-MyAvatar.bodyYaw = 0;
-MyAvatar.bodyPitch = 0;
-MyAvatar.bodyRoll = 0;
-
 // would be nice to change to update
 Script.update.connect(update);
 Script.scriptEnding.connect(scriptEnding);

examples/menuExample.js

@@ -32,6 +32,7 @@ function setupMenus() {
     Menu.addSeparator("Foo","Removable Tools");
     Menu.addMenuItem("Foo","Remove Foo item 4");
     Menu.addMenuItem("Foo","Remove Foo");
+    Menu.addMenuItem("Foo","Remove Bar-Spam");
     Menu.addMenu("Bar");
 
     Menu.addMenuItem("Bar","Bar item 1", "b");
@@ -91,6 +92,10 @@ function menuItemEvent(menuItem) {
     if (menuItem == "Remove Foo") {
         Menu.removeMenu("Foo");
     }
+    if (menuItem == "Remove Bar-Spam") {
+        Menu.removeMenu("Bar > Spam");
+    }
+
     if (menuItem == "Remove Spam item 2") {
         Menu.removeMenuItem("Bar > Spam", "Spam item 2");
     }

examples/seeingVoxelsExample.js

@@ -13,18 +13,23 @@ var yawDirection = -1;
 var yaw = 45;
 var yawMax = 70;
 var yawMin = 20;
+var vantagePoint = {x: 5000, y: 500, z: 5000};
 
 var isLocal = false;
 
 // set up our VoxelViewer with a position and orientation
 var orientation = Quat.fromPitchYawRollDegrees(0, yaw, 0);
 
+function getRandomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
 function init() {
     if (isLocal) {
-        MyAvatar.position = {x: 5000, y: 500, z: 5000};
+        MyAvatar.position = vantagePoint;
         MyAvatar.orientation = orientation;
     } else {
-        VoxelViewer.setPosition({x: 5000, y: 500, z: 5000});
+        VoxelViewer.setPosition(vantagePoint);
         VoxelViewer.setOrientation(orientation);
         VoxelViewer.queryOctree();
         Agent.isAvatar = true;
@@ -38,21 +43,26 @@ function keepLooking(deltaTime) {
         init();
     }
     count++;
-    if (count % 10 == 0) {
+    if (count % getRandomInt(5, 15) == 0) {
         yaw += yawDirection;
         orientation = Quat.fromPitchYawRollDegrees(0, yaw, 0);
         if (yaw > yawMax || yaw < yawMin) {
             yawDirection = yawDirection * -1;
         }
 
-        print("calling VoxelViewer.queryOctree()... count=" + count + " yaw=" + yaw);
+        if (count % 10000 == 0) {
+            print("calling VoxelViewer.queryOctree()... count=" + count + " yaw=" + yaw);
+        }
 
         if (isLocal) {
             MyAvatar.orientation = orientation;
         } else {
             VoxelViewer.setOrientation(orientation);
             VoxelViewer.queryOctree();
-            print("VoxelViewer.getOctreeElementsCount()=" + VoxelViewer.getOctreeElementsCount());
+            
+            if (count % 10000 == 0) {
+                print("VoxelViewer.getOctreeElementsCount()=" + VoxelViewer.getOctreeElementsCount());
+            }
         }
         
     }

examples/selectAudioDevice.js

@@ -0,0 +1,114 @@
+//
+//  audioDeviceExample.js
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 3/22/14
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+//  This is an example script that demonstrates use of the Menu object
+//
+
+if (typeof String.prototype.startsWith != 'function') {
+    String.prototype.startsWith = function (str){
+        return this.slice(0, str.length) == str;
+    };
+}
+
+if (typeof String.prototype.endsWith != 'function') {
+    String.prototype.endsWith = function (str){
+        return this.slice(-str.length) == str;
+    };
+}
+
+if (typeof String.prototype.trimStartsWith != 'function') {
+    String.prototype.trimStartsWith = function (str){
+        if (this.startsWith(str)) {
+            return this.substr(str.length);
+        }
+        return this;
+    };
+}
+
+if (typeof String.prototype.trimEndsWith != 'function') {
+    String.prototype.trimEndsWith = function (str){
+        if (this.endsWith(str)) {
+            return this.substr(0,this.length - str.length);
+        }
+        return this;
+    };
+}
+
+var selectedInputMenu = "";
+var selectedOutputMenu = "";
+
+function setupAudioMenus() {
+    Menu.addMenu("Tools > Audio");
+    Menu.addSeparator("Tools > Audio","Output Audio Device");
+
+    var outputDevices = AudioDevice.getOutputDevices();
+    var selectedOutputDevice = AudioDevice.getOutputDevice();
+
+    for(var i = 0; i < outputDevices.length; i++) {
+        var thisDeviceSelected = (outputDevices[i] == selectedOutputDevice);
+        var menuItem = "Use " + outputDevices[i] + " for Output";
+        Menu.addMenuItem({ 
+                            menuName: "Tools > Audio", 
+                            menuItemName: menuItem, 
+                            isCheckable: true, 
+                            isChecked: thisDeviceSelected 
+                        });
+        if (thisDeviceSelected) {
+            selectedOutputMenu = menuItem;
+        }
+    }
+
+    Menu.addSeparator("Tools > Audio","Input Audio Device");
+
+    var inputDevices = AudioDevice.getInputDevices();
+    var selectedInputDevice = AudioDevice.getInputDevice();
+
+    for(var i = 0; i < inputDevices.length; i++) {
+        var thisDeviceSelected = (inputDevices[i] == selectedInputDevice);
+        var menuItem = "Use " + inputDevices[i] + " for Input";
+        Menu.addMenuItem({ 
+                            menuName: "Tools > Audio", 
+                            menuItemName: menuItem, 
+                            isCheckable: true, 
+                            isChecked: thisDeviceSelected 
+                        });
+        if (thisDeviceSelected) {
+            selectedInputMenu = menuItem;
+        }
+    }
+}
+
+setupAudioMenus();
+
+function scriptEnding() {
+    Menu.removeMenu("Tools > Audio");
+}
+Script.scriptEnding.connect(scriptEnding);
+
+
+function menuItemEvent(menuItem) {
+    if (menuItem.startsWith("Use ")) {
+        if (menuItem.endsWith(" for Output")) {
+            var selectedDevice = menuItem.trimStartsWith("Use ").trimEndsWith(" for Output");
+            print("output audio selection..." + selectedDevice);
+            Menu.setIsOptionChecked(selectedOutputMenu, false);
+            selectedOutputMenu = menuItem;
+            Menu.setIsOptionChecked(selectedOutputMenu, true);
+            AudioDevice.setOutputDevice(selectedDevice);
+            
+        } else if (menuItem.endsWith(" for Input")) {
+            var selectedDevice = menuItem.trimStartsWith("Use ").trimEndsWith(" for Input");
+            print("input audio selection..." + selectedDevice);
+            Menu.setIsOptionChecked(selectedInputMenu, false);
+            selectedInputMenu = menuItem;
+            Menu.setIsOptionChecked(selectedInputMenu, true);
+            AudioDevice.setInputDevice(selectedDevice);
+        }
+    }
+}
+
+Menu.menuItemEvent.connect(menuItemEvent);

examples/settingsExample.js

@@ -0,0 +1,18 @@
+//
+//  settingsExample.js
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 3/22/14
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+//  This is an example script that demonstrates use of the Menu object
+//
+
+
+
+
+print("mySetting: " + Settings.getValue("mySetting"));
+Settings.setValue("mySetting", "spam");
+print("mySetting: " + Settings.getValue("mySetting"));
+
+Script.stop();

examples/voxelBird.js

@@ -1,133 +0,0 @@
-//
-//  This sample script moves a voxel around like a bird and sometimes makes tweeting noises 
-//
-
-function vLength(v) {
-    return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
-}
-
-function printVector(v) {
-	print(v.x + ", " + v.y + ", " + v.z + "\n");
-}
-
-//  Create a random vector with individual lengths between a,b
-function randVector(a, b) {
-	var rval = { x: a + Math.random() * (b - a), y: a + Math.random() * (b - a), z: a + Math.random() * (b - a) };
-	return rval;
-}
-
-function vMinus(a, b) { 
-	var rval = { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
-	return rval;
-}
-
-function vPlus(a, b) { 
-	var rval = { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
-	return rval;
-}
-
-function vCopy(a, b) {
-	a.x = b.x;
-	a.y = b.y;
-	a.z = b.z;
-	return;
-}
-
-//  Returns a vector which is fraction of the way between a and b
-function vInterpolate(a, b, fraction) { 
-	var rval = { x: a.x + (b.x - a.x) * fraction, y: a.y + (b.y - a.y) * fraction, z: a.z + (b.z - a.z) * fraction };
-	return rval;
-}
-
-//  Decide what kind of bird we are 
-var tweet;
-
-var which = Math.random();
-if (which < 0.2) {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/bushtit_1.raw");
-} else if (which < 0.4) {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/rosyfacedlovebird.raw");
-} else if (which < 0.6) {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/saysphoebe.raw");
-} else  if (which < 0.8) {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/mexicanWhipoorwill.raw");
-} else {
-	tweet = new Sound("https://s3-us-west-1.amazonaws.com/highfidelity-public/sounds/Animals/westernscreechowl.raw");
-} 
-
-var position  = { x: 0, y: 0, z: 0 };
-var lastPosition  = { x: 0, y: 0, z: 0 };
-var oldPosition = { x: 0, y: 0, z:0 };
-var targetPosition = { x: 0, y: 0, z: 0 };
-
-var size = 0.125;
-var range = 50.0;       //   Over what distance in meters do you want your bird to fly around 
-var color = { r: 100, g: 50, b: 150 };
-var colorEdge = { r:255, g:250, b:175 };
-var frame = 0;
-var thisColor = color;
-var moving = false;
-var tweeting = 0;
-var moved = true;
-
-var CHANCE_OF_MOVING = 0.05;
-var CHANCE_OF_TWEETING = 0.05;
-
-function moveBird(deltaTime) {
-    frame++;
-	if (frame % 3 == 0) {
-		// Tweeting behavior
-		if (tweeting == 0) {
-			if (Math.random() < CHANCE_OF_TWEETING) {
-				//print("tweet!" + "\n");
-				var options = new AudioInjectionOptions();

-				options.position = position;
-				options.volume = 0.75;
-				Audio.playSound(tweet, options);
-				tweeting = 10;
-			}
-		} else {
-			tweeting -= 1;
-		}
-		// Moving behavior 
-		if (moving == false) {
-			if (Math.random() < CHANCE_OF_MOVING) {
-				targetPosition = randVector(0, range);
-				//printVector(position);
-				moving = true;
-			}
-		}
-		if (moving) {
-			position = vInterpolate(position, targetPosition, 0.5);
-			if (vLength(vMinus(position, targetPosition)) < (size / 2.0)) {
-				moved = false;
-				moving = false;
-			} else {
-				moved = true;
-			}
-		}
-
-		if (tweeting > 0) {
-			//  Change color of voxel to blinky red a bit while playing the sound
-			var blinkColor = { r: Math.random() * 255, g: 0, b: 0 };
-			Voxels.setVoxel(position.x, 
-                            position.y, 
-                            position.z, 
-                            size, 
-                            blinkColor.r, blinkColor.g, blinkColor.b);
-		}
-		if (moved) {
-			Voxels.setVoxel(position.x, position.y, position.z, size, thisColor.r, thisColor.g, thisColor.b);
-			//  delete old voxel 
-			
-			Voxels.eraseVoxel(oldPosition.x, oldPosition.y, oldPosition.z, size);
-			//  Copy old location to new 
-			vCopy(oldPosition, position);
-			moved = false; 
-		}
-	}
-}
-
-Voxels.setPacketsPerSecond(10000);
-// Connect a call back that happens every frame
-Script.update.connect(moveBird);

interface/CMakeLists.txt

@@ -48,7 +48,7 @@ configure_file(InterfaceVersion.h.in "${PROJECT_BINARY_DIR}/includes/InterfaceVe
 
 # grab the implementation and header files from src dirs
 file(GLOB INTERFACE_SRCS src/*.cpp src/*.h)
-foreach(SUBDIR avatar devices renderer ui starfield location)
+foreach(SUBDIR avatar devices renderer ui starfield location scripting voxels)
   file(GLOB_RECURSE SUBDIR_SRCS src/${SUBDIR}/*.cpp src/${SUBDIR}/*.h)
   set(INTERFACE_SRCS ${INTERFACE_SRCS} "${SUBDIR_SRCS}")
 endforeach(SUBDIR)

interface/interface_en.ts

@@ -4,22 +4,22 @@
 <context>
     <name>Application</name>
     <message>
-        <location filename="src/Application.cpp" line="1354"/>
+        <location filename="src/Application.cpp" line="1380"/>
         <source>Export Voxels</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/Application.cpp" line="1355"/>
+        <location filename="src/Application.cpp" line="1381"/>
         <source>Sparse Voxel Octree Files (*.svo)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/Application.cpp" line="3565"/>
+        <location filename="src/Application.cpp" line="3597"/>
         <source>Open Script</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/Application.cpp" line="3566"/>
+        <location filename="src/Application.cpp" line="3598"/>
         <source>JavaScript Files (*.js)</source>
         <translation type="unfinished"></translation>
     </message>
@@ -113,18 +113,18 @@
 <context>
     <name>Menu</name>
     <message>
-        <location filename="src/Menu.cpp" line="437"/>
+        <location filename="src/Menu.cpp" line="457"/>
         <source>Open .ini config file</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/Menu.cpp" line="439"/>
-        <location filename="src/Menu.cpp" line="451"/>
+        <location filename="src/Menu.cpp" line="459"/>
+        <location filename="src/Menu.cpp" line="471"/>
         <source>Text files (*.ini)</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/Menu.cpp" line="449"/>
+        <location filename="src/Menu.cpp" line="469"/>
         <source>Save .ini config file</source>
         <translation type="unfinished"></translation>
     </message>
@@ -132,28 +132,28 @@
 <context>
     <name>QObject</name>
     <message>
-        <location filename="src/ImportDialog.cpp" line="22"/>
-        <location filename="src/ImportDialog.cpp" line="23"/>
+        <location filename="src/ui/ImportDialog.cpp" line="22"/>
+        <location filename="src/ui/ImportDialog.cpp" line="23"/>
         <source>Import Voxels</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/ImportDialog.cpp" line="24"/>
+        <location filename="src/ui/ImportDialog.cpp" line="24"/>
         <source>Loading ...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/ImportDialog.cpp" line="25"/>
+        <location filename="src/ui/ImportDialog.cpp" line="25"/>
         <source>Place voxels</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/ImportDialog.cpp" line="26"/>
+        <location filename="src/ui/ImportDialog.cpp" line="26"/>
         <source>&lt;b&gt;Import&lt;/b&gt; %1 as voxels</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="src/ImportDialog.cpp" line="27"/>
+        <location filename="src/ui/ImportDialog.cpp" line="27"/>
         <source>Cancel</source>
         <translation type="unfinished"></translation>
     </message>

interface/resources/shaders/model_shadow.frag

@@ -0,0 +1,14 @@
+#version 120
+
+//
+//  model_shadow.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 3/24/14.
+//  Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+void main(void) {
+    // fixed color for now (we may eventually want to use texture alpha)
+    gl_FragColor = vec4(1.0, 1.0, 1.0, 1.0);
+}

interface/resources/shaders/model_shadow.vert

@@ -0,0 +1,14 @@
+#version 120
+
+//
+//  model_shadow.vert
+//  vertex shader
+//
+//  Created by Andrzej Kapolka on 3/24/14.
+//  Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+void main(void) {
+    // just use standard pipeline transform
+    gl_Position = ftransform();
+}

interface/resources/shaders/skin_model_shadow.vert

@@ -0,0 +1,27 @@
+#version 120
+
+//
+//  skin_model_shadow.vert
+//  vertex shader
+//
+//  Created by Andrzej Kapolka on 3/24/14.
+//  Copyright (c) 2014 High Fidelity, Inc. All rights reserved.
+//
+
+const int MAX_CLUSTERS = 128;
+const int INDICES_PER_VERTEX = 4;
+
+uniform mat4 clusterMatrices[MAX_CLUSTERS];
+
+attribute vec4 clusterIndices;
+attribute vec4 clusterWeights;
+
+void main(void) {
+    vec4 position = vec4(0.0, 0.0, 0.0, 0.0);
+    for (int i = 0; i < INDICES_PER_VERTEX; i++) {
+        mat4 clusterMatrix = clusterMatrices[int(clusterIndices[i])];
+        float clusterWeight = clusterWeights[i];
+        position += clusterMatrix * gl_Vertex * clusterWeight;
+    }
+    gl_Position = gl_ModelViewProjectionMatrix * position;
+}

interface/resources/visage/tracker.cfg

@@ -40,7 +40,7 @@ detect_strip_roi_width 2
 detect_strip_roi_height 4
 
 smoothing_factors
-     150           15        -2             100        -1      50        50         0
+     5           25        -2             100        -1      50        25         0
 #translation   rotation   action_units   eyebrows   mouth   gaze   eye_closure   other
 
 process_eyes			1

interface/src/Application.cpp

@@ -28,6 +28,7 @@
 #include <QDesktopWidget>
 #include <QCheckBox>
 #include <QImage>
+#include <QInputDialog>
 #include <QKeyEvent>
 #include <QMainWindow>
 #include <QMenuBar>
@@ -65,17 +66,21 @@
 #include <FstReader.h>
 
 #include "Application.h"
-#include "ClipboardScriptingInterface.h"
 #include "InterfaceVersion.h"
 #include "Menu.h"
-#include "MenuScriptingInterface.h"
 #include "Util.h"
 #include "devices/OculusManager.h"
 #include "devices/TV3DManager.h"
 #include "renderer/ProgramObject.h"
-#include "ui/TextRenderer.h"
-#include "InfoView.h"
+
+#include "scripting/AudioDeviceScriptingInterface.h"
+#include "scripting/ClipboardScriptingInterface.h"
+#include "scripting/MenuScriptingInterface.h"
+#include "scripting/SettingsScriptingInterface.h"
+
+#include "ui/InfoView.h"
 #include "ui/Snapshot.h"
+#include "ui/TextRenderer.h"
 
 using namespace std;
 
@@ -246,7 +251,7 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
     QMetaObject::invokeMethod(&accountManager, "checkAndSignalForAccessToken", Qt::QueuedConnection);
 
     _settings = new QSettings(this);
-
+    
     // Check to see if the user passed in a command line option for loading a local
     // Voxel File.
     _voxelsFilename = getCmdOption(argc, constArgv, "-i");
@@ -325,9 +330,20 @@ Application::Application(int& argc, char** argv, timeval &startup_time) :
     
     LocalVoxelsList::getInstance()->addPersistantTree(DOMAIN_TREE_NAME, _voxels.getTree());
     LocalVoxelsList::getInstance()->addPersistantTree(CLIPBOARD_TREE_NAME, &_clipboard);
-    
-    // do this as late as possible so that all required subsystems are inialized
-    loadScripts();
+
+    // check first run...
+    QVariant firstRunValue = _settings->value("firstRun",QVariant(true));
+    if (firstRunValue.isValid() && firstRunValue.toBool()) {
+        qDebug() << "This is a first run...";
+        // clear the scripts, and set out script to our default scripts
+        clearScriptsBeforeRunning();
+        loadScript("http://public.highfidelity.io/scripts/defaultScripts.js");
+        
+        _settings->setValue("firstRun",QVariant(false));
+    } else {
+        // do this as late as possible so that all required subsystems are inialized
+        loadScripts();
+    }
 }
 
 Application::~Application() {
@@ -692,6 +708,8 @@ bool Application::event(QEvent* event) {
 
 void Application::keyPressEvent(QKeyEvent* event) {
 
+    _keysPressed.insert(event->key());
+
     _controllerScriptingInterface.emitKeyPressEvent(event); // send events to any registered scripts
     
     // if one of our scripts have asked to capture this event, then stop processing it
@@ -914,6 +932,8 @@ void Application::keyPressEvent(QKeyEvent* event) {
 
 void Application::keyReleaseEvent(QKeyEvent* event) {
 
+    _keysPressed.remove(event->key());
+
     _controllerScriptingInterface.emitKeyReleaseEvent(event); // send events to any registered scripts
 
     // if one of our scripts have asked to capture this event, then stop processing it
@@ -921,60 +941,66 @@ void Application::keyReleaseEvent(QKeyEvent* event) {
         return;
     }
 
+    switch (event->key()) {
+        case Qt::Key_E:
+            _myAvatar->setDriveKeys(UP, 0.f);
+            break;
 
-    if (activeWindow() == _window) {
-        switch (event->key()) {
-            case Qt::Key_E:
-                _myAvatar->setDriveKeys(UP, 0.f);
-                break;
+        case Qt::Key_C:
+            _myAvatar->setDriveKeys(DOWN, 0.f);
+            break;
 
-            case Qt::Key_C:
-                _myAvatar->setDriveKeys(DOWN, 0.f);
-                break;
+        case Qt::Key_W:
+            _myAvatar->setDriveKeys(FWD, 0.f);
+            break;
 
-            case Qt::Key_W:
-                _myAvatar->setDriveKeys(FWD, 0.f);
-                break;
+        case Qt::Key_S:
+            _myAvatar->setDriveKeys(BACK, 0.f);
+            break;
 
-            case Qt::Key_S:
-                _myAvatar->setDriveKeys(BACK, 0.f);
-                break;
+        case Qt::Key_A:
+            _myAvatar->setDriveKeys(ROT_LEFT, 0.f);
+            break;
 
-            case Qt::Key_A:
-                _myAvatar->setDriveKeys(ROT_LEFT, 0.f);
-                break;
+        case Qt::Key_D:
+            _myAvatar->setDriveKeys(ROT_RIGHT, 0.f);
+            break;
 
-            case Qt::Key_D:
-                _myAvatar->setDriveKeys(ROT_RIGHT, 0.f);
-                break;
+        case Qt::Key_Up:
+            _myAvatar->setDriveKeys(FWD, 0.f);
+            _myAvatar->setDriveKeys(UP, 0.f);
+            break;
 
-            case Qt::Key_Up:
-                _myAvatar->setDriveKeys(FWD, 0.f);
-                _myAvatar->setDriveKeys(UP, 0.f);
-                break;
+        case Qt::Key_Down:
+            _myAvatar->setDriveKeys(BACK, 0.f);
+            _myAvatar->setDriveKeys(DOWN, 0.f);
+            break;
 
-            case Qt::Key_Down:
-                _myAvatar->setDriveKeys(BACK, 0.f);
-                _myAvatar->setDriveKeys(DOWN, 0.f);
-                break;
+        case Qt::Key_Left:
+            _myAvatar->setDriveKeys(LEFT, 0.f);
+            _myAvatar->setDriveKeys(ROT_LEFT, 0.f);
+            break;
 
-            case Qt::Key_Left:
-                _myAvatar->setDriveKeys(LEFT, 0.f);
-                _myAvatar->setDriveKeys(ROT_LEFT, 0.f);
-                break;
+        case Qt::Key_Right:
+            _myAvatar->setDriveKeys(RIGHT, 0.f);
+            _myAvatar->setDriveKeys(ROT_RIGHT, 0.f);
+            break;
 
-            case Qt::Key_Right:
-                _myAvatar->setDriveKeys(RIGHT, 0.f);
-                _myAvatar->setDriveKeys(ROT_RIGHT, 0.f);
-                break;
-
-            default:
-                event->ignore();
-                break;
-        }
+        default:
+            event->ignore();
+            break;
     }
 }
 
+void Application::focusOutEvent(QFocusEvent* event) {
+    // synthesize events for keys currently pressed, since we may not get their release events
+    foreach (int key, _keysPressed) {
+        QKeyEvent event(QEvent::KeyRelease, key, Qt::NoModifier);
+        keyReleaseEvent(&event);
+    }
+    _keysPressed.clear();
+}
+
 void Application::mouseMoveEvent(QMouseEvent* event) {
     _controllerScriptingInterface.emitMouseMoveEvent(event); // send events to any registered scripts
 
@@ -1680,7 +1706,7 @@ void Application::updateMyAvatarLookAtPosition() {
     } else {
         // look in direction of the mouse ray, but use distance from intersection, if any
         float distance = TREE_SCALE;
-        if (_myAvatar->getLookAtTargetAvatar()) {
+        if (_myAvatar->getLookAtTargetAvatar() && _myAvatar != _myAvatar->getLookAtTargetAvatar()) {
             distance = glm::distance(_mouseRayOrigin,
                 static_cast<Avatar*>(_myAvatar->getLookAtTargetAvatar())->getHead()->calculateAverageEyePosition()); 
         }
@@ -2140,7 +2166,8 @@ void Application::loadViewFrustum(Camera& camera, ViewFrustum& viewFrustum) {
 }
 
 glm::vec3 Application::getSunDirection() {
-    return glm::normalize(_environment.getClosestData(_myCamera.getPosition()).getSunLocation() - _myCamera.getPosition());
+    return glm::normalize(_environment.getClosestData(_myCamera.getPosition()).getSunLocation(_myCamera.getPosition()) -
+        _myCamera.getPosition());
 }
 
 void Application::updateShadowMap() {
@@ -2152,21 +2179,22 @@ void Application::updateShadowMap() {
     glViewport(0, 0, fbo->width(), fbo->height());
 
     glm::vec3 lightDirection = -getSunDirection();
-    glm::quat rotation = glm::inverse(rotationBetween(IDENTITY_FRONT, lightDirection));
-    glm::vec3 translation = glm::vec3();
+    glm::quat rotation = rotationBetween(IDENTITY_FRONT, lightDirection);
+    glm::quat inverseRotation = glm::inverse(rotation);
     float nearScale = 0.0f;
     const float MAX_SHADOW_DISTANCE = 2.0f;
-    float farScale = (MAX_SHADOW_DISTANCE - _viewFrustum.getNearClip()) / (_viewFrustum.getFarClip() - _viewFrustum.getNearClip());
+    float farScale = (MAX_SHADOW_DISTANCE - _viewFrustum.getNearClip()) /
+        (_viewFrustum.getFarClip() - _viewFrustum.getNearClip());
     loadViewFrustum(_myCamera, _viewFrustum);
     glm::vec3 points[] = {
-        rotation * (glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), nearScale) + translation),
-        rotation * (glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), nearScale) + translation),
-        rotation * (glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), nearScale) + translation),
-        rotation * (glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), nearScale) + translation),
-        rotation * (glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), farScale) + translation),
-        rotation * (glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), farScale) + translation),
-        rotation * (glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), farScale) + translation),
-        rotation * (glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), farScale) + translation) };
+        inverseRotation * (glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), nearScale)),
+        inverseRotation * (glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), nearScale)),
+        inverseRotation * (glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), nearScale)),
+        inverseRotation * (glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), nearScale)),
+        inverseRotation * (glm::mix(_viewFrustum.getNearTopLeft(), _viewFrustum.getFarTopLeft(), farScale)),
+        inverseRotation * (glm::mix(_viewFrustum.getNearTopRight(), _viewFrustum.getFarTopRight(), farScale)),
+        inverseRotation * (glm::mix(_viewFrustum.getNearBottomLeft(), _viewFrustum.getFarBottomLeft(), farScale)),
+        inverseRotation * (glm::mix(_viewFrustum.getNearBottomRight(), _viewFrustum.getFarBottomRight(), farScale)) };
     glm::vec3 minima(FLT_MAX, FLT_MAX, FLT_MAX), maxima(-FLT_MAX, -FLT_MAX, -FLT_MAX);
     for (size_t i = 0; i < sizeof(points) / sizeof(points[0]); i++) {
         minima = glm::min(minima, points[i]);
@@ -2179,9 +2207,20 @@ void Application::updateShadowMap() {
 
     // save the combined matrix for rendering
     _shadowMatrix = glm::transpose(glm::translate(glm::vec3(0.5f, 0.5f, 0.5f)) * glm::scale(glm::vec3(0.5f, 0.5f, 0.5f)) *
-        glm::ortho(minima.x, maxima.x, minima.y, maxima.y, -maxima.z, -minima.z) *
-        glm::mat4_cast(rotation) * glm::translate(translation));
+        glm::ortho(minima.x, maxima.x, minima.y, maxima.y, -maxima.z, -minima.z) * glm::mat4_cast(inverseRotation));
 
+    // update the shadow view frustum
+    _shadowViewFrustum.setPosition(rotation * ((minima + maxima) * 0.5f));
+    _shadowViewFrustum.setOrientation(rotation);
+    _shadowViewFrustum.setOrthographic(true);
+    _shadowViewFrustum.setWidth(maxima.x - minima.x);
+    _shadowViewFrustum.setHeight(maxima.y - minima.y);
+    _shadowViewFrustum.setNearClip(minima.z);
+    _shadowViewFrustum.setFarClip(maxima.z);
+    _shadowViewFrustum.setEyeOffsetPosition(glm::vec3());
+    _shadowViewFrustum.setEyeOffsetOrientation(glm::quat());
+    _shadowViewFrustum.calculate();
+    
     glMatrixMode(GL_PROJECTION);
     glPushMatrix();
     glLoadIdentity();
@@ -2190,16 +2229,14 @@ void Application::updateShadowMap() {
     glMatrixMode(GL_MODELVIEW);
     glPushMatrix();
     glLoadIdentity();
-    glm::vec3 axis = glm::axis(rotation);
-    glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
+    glm::vec3 axis = glm::axis(inverseRotation);
+    glRotatef(glm::degrees(glm::angle(inverseRotation)), axis.x, axis.y, axis.z);
 
     // store view matrix without translation, which we'll use for precision-sensitive objects
     glGetFloatv(GL_MODELVIEW_MATRIX, (GLfloat*)&_untranslatedViewMatrix);
-    _viewMatrixTranslation = translation;
+    _viewMatrixTranslation = glm::vec3();
 
-    glTranslatef(translation.x, translation.y, translation.z);
-
-    _avatarManager.renderAvatars(true);
+    _avatarManager.renderAvatars(Avatar::SHADOW_RENDER_MODE);
     _particles.render();
 
     glPopMatrix();
@@ -2302,7 +2339,8 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
         float alpha = 1.0f;
         if (Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) {
             const EnvironmentData& closestData = _environment.getClosestData(whichCamera.getPosition());
-            float height = glm::distance(whichCamera.getPosition(), closestData.getAtmosphereCenter());
+            float height = glm::distance(whichCamera.getPosition(),
+                closestData.getAtmosphereCenter(whichCamera.getPosition()));
             if (height < closestData.getAtmosphereInnerRadius()) {
                 alpha = 0.0f;
 
@@ -2376,7 +2414,7 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
     }
 
     bool mirrorMode = (whichCamera.getInterpolatedMode() == CAMERA_MODE_MIRROR);
-    _avatarManager.renderAvatars(mirrorMode, selfAvatarOnly);
+    _avatarManager.renderAvatars(mirrorMode ? Avatar::MIRROR_RENDER_MODE : Avatar::NORMAL_RENDER_MODE, selfAvatarOnly);
 
     if (!selfAvatarOnly) {
         //  Render the world box
@@ -3240,6 +3278,9 @@ void Application::domainChanged(const QString& domainHostname) {
     
     // reset the particle renderer
     _particles.clear();
+
+    // reset the voxels renderer
+    _voxels.killLocalVoxels();
 }
 
 void Application::connectedToDomain(const QString& hostname) {
@@ -3424,6 +3465,13 @@ void Application::loadScripts() {
     settings->endArray();
 }
 
+void Application::clearScriptsBeforeRunning() {
+    // clears all scripts from the settings
+    QSettings* settings = new QSettings(this);
+    settings->beginWriteArray("Settings");
+    settings->endArray();
+}
+
 void Application::saveScripts() {
     // saves all current running scripts
     QSettings* settings = new QSettings(this);
@@ -3479,35 +3527,17 @@ void Application::cleanupScriptMenuItem(const QString& scriptMenuName) {
     Menu::getInstance()->removeAction(Menu::getInstance()->getActiveScriptsMenu(), scriptMenuName);
 }
 
-void Application::loadScript(const QString& fileNameString) {
-    QByteArray fileNameAscii = fileNameString.toLocal8Bit();
-    const char* fileName = fileNameAscii.data();
-
-    std::ifstream file(fileName, std::ios::in|std::ios::binary|std::ios::ate);
-    if(!file.is_open()) {
-        qDebug("Error loading file %s", fileName);
-        return;
-    }
-    qDebug("Loading file %s...", fileName);
-    _activeScripts.append(fileNameString);
-
-    // get file length....
-    unsigned long fileLength = file.tellg();
-    file.seekg( 0, std::ios::beg );
-
-    // read the entire file into a buffer, WHAT!? Why not.
-    char* entireFile = new char[fileLength+1];
-    file.read((char*)entireFile, fileLength);
-    file.close();
-
-    entireFile[fileLength] = 0;// null terminate
-    QString script(entireFile);
-    delete[] entireFile;
+void Application::loadScript(const QString& scriptName) {
 
     // start the script on a new thread...
     bool wantMenuItems = true; // tells the ScriptEngine object to add menu items for itself
+    ScriptEngine* scriptEngine = new ScriptEngine(QUrl(scriptName), wantMenuItems, &_controllerScriptingInterface);
 
-    ScriptEngine* scriptEngine = new ScriptEngine(script, wantMenuItems, fileName, &_controllerScriptingInterface);
+    if (!scriptEngine->hasScript()) {
+        qDebug() << "Application::loadScript(), script failed to load...";
+        return;
+    }
+    _activeScripts.append(scriptName);
     
     // add a stop menu item
     Menu::getInstance()->addActionToQMenuAndActionHash(Menu::getInstance()->getActiveScriptsMenu(), 
@@ -3533,6 +3563,8 @@ void Application::loadScript(const QString& fileNameString) {
 
     scriptEngine->registerGlobalObject("Overlays", &_overlays);
     scriptEngine->registerGlobalObject("Menu", MenuScriptingInterface::getInstance());
+    scriptEngine->registerGlobalObject("Settings", SettingsScriptingInterface::getInstance());
+    scriptEngine->registerGlobalObject("AudioDevice", AudioDeviceScriptingInterface::getInstance());
 
     QThread* workerThread = new QThread(this);
 
@@ -3568,6 +3600,31 @@ void Application::loadDialog() {
     loadScript(fileNameString);
 }
 
+void Application::loadScriptURLDialog() {
+
+    QInputDialog scriptURLDialog(Application::getInstance()->getWindow());
+    scriptURLDialog.setWindowTitle("Open and Run Script URL");
+    scriptURLDialog.setLabelText("Script:");
+    scriptURLDialog.setWindowFlags(Qt::Sheet);
+    const float DIALOG_RATIO_OF_WINDOW = 0.30f;
+    scriptURLDialog.resize(scriptURLDialog.parentWidget()->size().width() * DIALOG_RATIO_OF_WINDOW, 
+                        scriptURLDialog.size().height());
+
+    int dialogReturn = scriptURLDialog.exec();
+    QString newScript;
+    if (dialogReturn == QDialog::Accepted) {
+        if (scriptURLDialog.textValue().size() > 0) {
+            // the user input a new hostname, use that
+            newScript = scriptURLDialog.textValue();
+        }
+        loadScript(newScript);
+    }
+
+    sendFakeEnterEvent();
+}
+
+
+
 void Application::toggleLogDialog() {
     if (! _logDialog) {
         _logDialog = new LogDialog(_glWidget, getLogger());

interface/src/Application.h

@@ -18,6 +18,7 @@
 #include <QSettings>
 #include <QTouchEvent>
 #include <QList>
+#include <QSet>
 #include <QStringList>
 #include <QPointer>
 
@@ -28,12 +29,12 @@
 #include <ParticleEditPacketSender.h>
 #include <ScriptEngine.h>
 #include <OctreeQuery.h>
+#include <ViewFrustum.h>
+#include <VoxelEditPacketSender.h>
 
 #include "Audio.h"
-#include "BandwidthMeter.h"
 #include "BuckyBalls.h"
 #include "Camera.h"
-#include "ControllerScriptingInterface.h"
 #include "DatagramProcessor.h"
 #include "Environment.h"
 #include "FileLogger.h"
@@ -43,13 +44,6 @@
 #include "PacketHeaders.h"
 #include "ParticleTreeRenderer.h"
 #include "Stars.h"
-#include "ViewFrustum.h"
-#include "VoxelFade.h"
-#include "VoxelEditPacketSender.h"
-#include "VoxelHideShowThread.h"
-#include "VoxelPacketProcessor.h"
-#include "VoxelSystem.h"
-#include "VoxelImporter.h"
 #include "avatar/Avatar.h"
 #include "avatar/AvatarManager.h"
 #include "avatar/MyAvatar.h"
@@ -62,13 +56,20 @@
 #include "renderer/PointShader.h"
 #include "renderer/TextureCache.h"
 #include "renderer/VoxelShader.h"
+#include "scripting/ControllerScriptingInterface.h"
 #include "ui/BandwidthDialog.h"
+#include "ui/BandwidthMeter.h"
 #include "ui/OctreeStatsDialog.h"
 #include "ui/RearMirrorTools.h"
 #include "ui/LodToolsDialog.h"
 #include "ui/LogDialog.h"
 #include "ui/UpdateDialog.h"
-#include "ui/Overlays.h"
+#include "ui/overlays/Overlays.h"
+#include "voxels/VoxelFade.h"
+#include "voxels/VoxelHideShowThread.h"
+#include "voxels/VoxelImporter.h"
+#include "voxels/VoxelPacketProcessor.h"
+#include "voxels/VoxelSystem.h"
 
 
 class QAction;
@@ -114,6 +115,7 @@ public:
     void loadScript(const QString& fileNameString);    
     void loadScripts();
     void storeSizeAndPosition();
+    void clearScriptsBeforeRunning();
     void saveScripts();
     void initializeGL();
     void paintGL();
@@ -122,6 +124,8 @@ public:
     void keyPressEvent(QKeyEvent* event);
     void keyReleaseEvent(QKeyEvent* event);
 
+    void focusOutEvent(QFocusEvent* event);
+
     void mouseMoveEvent(QMouseEvent* event);
     void mousePressEvent(QMouseEvent* event);
     void mouseReleaseEvent(QMouseEvent* event);
@@ -152,6 +156,7 @@ public:
     Audio* getAudio() { return &_audio; }
     Camera* getCamera() { return &_myCamera; }
     ViewFrustum* getViewFrustum() { return &_viewFrustum; }
+    ViewFrustum* getShadowViewFrustum() { return &_shadowViewFrustum; }
     VoxelSystem* getVoxels() { return &_voxels; }
     VoxelTree* getVoxelTree() { return _voxels.getTree(); }
     ParticleTreeRenderer* getParticles() { return &_particles; }
@@ -168,7 +173,11 @@ public:
     Visage* getVisage() { return &_visage; }
     SixenseManager* getSixenseManager() { return &_sixenseManager; }
     BandwidthMeter* getBandwidthMeter() { return &_bandwidthMeter; }
-    QSettings* getSettings() { return _settings; }
+
+    /// if you need to access the application settings, use lockSettings()/unlockSettings()
+    QSettings* lockSettings() { _settingsMutex.lock(); return _settings; }
+    void unlockSettings() { _settingsMutex.unlock(); }
+
     QMainWindow* getWindow() { return _window; }
     NodeToOctreeSceneStats* getOcteeSceneStats() { return &_octreeServerSceneStats; }
     void lockOctreeSceneStats() { _octreeSceneStatsLock.lockForRead(); }
@@ -246,6 +255,7 @@ public slots:
     void setRenderVoxels(bool renderVoxels);
     void doKillLocalVoxels();
     void loadDialog();
+    void loadScriptURLDialog();
     void toggleLogDialog();
     void initAvatarAndViewFrustum();
     void stopAllScripts();
@@ -349,6 +359,7 @@ private:
     DatagramProcessor _datagramProcessor;
 
     QNetworkAccessManager* _networkAccessManager;
+    QMutex _settingsMutex;
     QSettings* _settings;
 
     glm::vec3 _gravity;
@@ -382,6 +393,7 @@ private:
 
     ViewFrustum _viewFrustum; // current state of view frustum, perspective, orientation, etc.
     ViewFrustum _lastQueriedViewFrustum; /// last view frustum used to query octree servers (voxels, particles)
+    ViewFrustum _shadowViewFrustum;
     quint64 _lastQueriedTime;
 
     Oscilloscope _audioScope;
@@ -432,6 +444,8 @@ private:
 
     bool _mousePressed; //  true if mouse has been pressed (clear when finished)
 
+    QSet<int> _keysPressed;
+
     GeometryCache _geometryCache;
     TextureCache _textureCache;
 

interface/src/Audio.cpp

@@ -92,6 +92,16 @@ void Audio::reset() {
     _ringBuffer.reset();
 }
 
+QAudioDeviceInfo getNamedAudioDeviceForMode(QAudio::Mode mode, const QString& deviceName) {
+    QAudioDeviceInfo result;
+    foreach(QAudioDeviceInfo audioDevice, QAudioDeviceInfo::availableDevices(mode)) {
+        if (audioDevice.deviceName().trimmed() == deviceName.trimmed()) {
+            result = audioDevice;
+        }
+    }
+    return result;
+}
+
 QAudioDeviceInfo defaultAudioDeviceForMode(QAudio::Mode mode) {
 #ifdef __APPLE__
     if (QAudioDeviceInfo::availableDevices(mode).size() > 1) {
@@ -249,27 +259,105 @@ void Audio::start() {
     _desiredOutputFormat.setChannelCount(2);
 
     QAudioDeviceInfo inputDeviceInfo = defaultAudioDeviceForMode(QAudio::AudioInput);
-    qDebug() << "The audio input device is" << inputDeviceInfo.deviceName();
+    qDebug() << "The default audio input device is" << inputDeviceInfo.deviceName();
+    bool inputFormatSupported = switchInputToAudioDevice(inputDeviceInfo.deviceName());
+
+    QAudioDeviceInfo outputDeviceInfo = defaultAudioDeviceForMode(QAudio::AudioOutput);
+    qDebug() << "The default audio output device is" << outputDeviceInfo.deviceName();
+    bool outputFormatSupported = switchOutputToAudioDevice(outputDeviceInfo.deviceName());
     
-    if (adjustedFormatForAudioDevice(inputDeviceInfo, _desiredInputFormat, _inputFormat)) {
-        qDebug() << "The format to be used for audio input is" << _inputFormat;
+    if (!inputFormatSupported || !outputFormatSupported) {
+        qDebug() << "Unable to set up audio I/O because of a problem with input or output formats.";
+    }
+}
+
+QString Audio::getDefaultDeviceName(QAudio::Mode mode) {
+    QAudioDeviceInfo deviceInfo = defaultAudioDeviceForMode(mode);
+    return deviceInfo.deviceName();
+}
+
+QVector<QString> Audio::getDeviceNames(QAudio::Mode mode) {
+    QVector<QString> deviceNames;
+    foreach(QAudioDeviceInfo audioDevice, QAudioDeviceInfo::availableDevices(mode)) {
+        deviceNames << audioDevice.deviceName().trimmed();
+    }
+    return deviceNames;
+}
+
+bool Audio::switchInputToAudioDevice(const QString& inputDeviceName) {
+    bool supportedFormat = false;
+    
+    // cleanup any previously initialized device
+    if (_audioInput) {
+        _audioInput->stop();
+        disconnect(_inputDevice, 0, 0, 0);
+        _inputDevice = NULL;
+
+        delete _audioInput;
+        _audioInput = NULL;
+        _numInputCallbackBytes = 0;
+
+        _inputAudioDeviceName = "";
+    }
+
+    QAudioDeviceInfo inputDeviceInfo = getNamedAudioDeviceForMode(QAudio::AudioInput, inputDeviceName);
+    
+    if (!inputDeviceInfo.isNull()) {
+        qDebug() << "The audio input device " << inputDeviceInfo.deviceName() << "is available.";
+        _inputAudioDeviceName = inputDeviceInfo.deviceName().trimmed();
+    
+        if (adjustedFormatForAudioDevice(inputDeviceInfo, _desiredInputFormat, _inputFormat)) {
+            qDebug() << "The format to be used for audio input is" << _inputFormat;
         
-        _audioInput = new QAudioInput(inputDeviceInfo, _inputFormat, this);
-        _numInputCallbackBytes = NETWORK_BUFFER_LENGTH_BYTES_PER_CHANNEL * _inputFormat.channelCount()
-            * (_inputFormat.sampleRate() / SAMPLE_RATE)
-            / CALLBACK_ACCELERATOR_RATIO;
-        _audioInput->setBufferSize(_numInputCallbackBytes);
+            _audioInput = new QAudioInput(inputDeviceInfo, _inputFormat, this);
+            _numInputCallbackBytes = NETWORK_BUFFER_LENGTH_BYTES_PER_CHANNEL * _inputFormat.channelCount()
+                * (_inputFormat.sampleRate() / SAMPLE_RATE)
+                / CALLBACK_ACCELERATOR_RATIO;
+            _audioInput->setBufferSize(_numInputCallbackBytes);
 
-        QAudioDeviceInfo outputDeviceInfo = defaultAudioDeviceForMode(QAudio::AudioOutput);
-        qDebug() << "The audio output device is" << outputDeviceInfo.deviceName();
-
-        if (adjustedFormatForAudioDevice(outputDeviceInfo, _desiredOutputFormat, _outputFormat)) {
-            qDebug() << "The format to be used for audio output is" << _outputFormat;
-            
+            // how do we want to handle input working, but output not working?
             _inputRingBuffer.resizeForFrameSize(_numInputCallbackBytes * CALLBACK_ACCELERATOR_RATIO / sizeof(int16_t));
             _inputDevice = _audioInput->start();
             connect(_inputDevice, SIGNAL(readyRead()), this, SLOT(handleAudioInput()));
 
+            supportedFormat = true;
+        }
+    }
+    return supportedFormat;
+}
+
+bool Audio::switchOutputToAudioDevice(const QString& outputDeviceName) {
+    bool supportedFormat = false;
+
+    // cleanup any previously initialized device
+    if (_audioOutput) {
+        _audioOutput->stop();
+        disconnect(_outputDevice, 0, 0, 0);
+        _outputDevice = NULL;
+        
+        delete _audioOutput;
+        _audioOutput = NULL;
+        _numInputCallbackBytes = 0;
+
+        _loopbackOutputDevice = NULL;
+        delete _loopbackAudioOutput;
+        _loopbackAudioOutput = NULL;
+
+        _proceduralOutputDevice = NULL;
+        delete _proceduralAudioOutput;
+        _proceduralAudioOutput = NULL;
+        _outputAudioDeviceName = "";
+    }
+
+    QAudioDeviceInfo outputDeviceInfo = getNamedAudioDeviceForMode(QAudio::AudioOutput, outputDeviceName);
+
+    if (!outputDeviceInfo.isNull()) {
+        qDebug() << "The audio output device " << outputDeviceInfo.deviceName() << "is available.";
+        _outputAudioDeviceName = outputDeviceInfo.deviceName().trimmed();
+
+        if (adjustedFormatForAudioDevice(outputDeviceInfo, _desiredOutputFormat, _outputFormat)) {
+            qDebug() << "The format to be used for audio output is" << _outputFormat;
+        
             // setup our general output device for audio-mixer audio
             _audioOutput = new QAudioOutput(outputDeviceInfo, _outputFormat, this);
             _audioOutput->setBufferSize(_ringBuffer.getSampleCapacity() * sizeof(int16_t));
@@ -278,17 +366,15 @@ void Audio::start() {
 
             // setup a loopback audio output device
             _loopbackAudioOutput = new QAudioOutput(outputDeviceInfo, _outputFormat, this);
-            
+        
             // setup a procedural audio output device
             _proceduralAudioOutput = new QAudioOutput(outputDeviceInfo, _outputFormat, this);
 
             gettimeofday(&_lastReceiveTime, NULL);
+            supportedFormat = true;
         }
-
-        return;
     }
-    
-    qDebug() << "Unable to set up audio I/O because of a problem with input or output formats.";
+    return supportedFormat;
 }
 
 void Audio::handleAudioInput() {
@@ -309,13 +395,15 @@ void Audio::handleAudioInput() {
     if (Menu::getInstance()->isOptionChecked(MenuOption::EchoLocalAudio) && !_muted) {
         // if this person wants local loopback add that to the locally injected audio
 
-        if (!_loopbackOutputDevice) {
+        if (!_loopbackOutputDevice && _loopbackAudioOutput) {
             // we didn't have the loopback output device going so set that up now
             _loopbackOutputDevice = _loopbackAudioOutput->start();
         }
 
         if (_inputFormat == _outputFormat) {
-            _loopbackOutputDevice->write(inputByteArray);
+            if (_loopbackOutputDevice) {
+                _loopbackOutputDevice->write(inputByteArray);
+            }
         } else {
             static float loopbackOutputToInputRatio = (_outputFormat.sampleRate() / (float) _inputFormat.sampleRate())
                 * (_outputFormat.channelCount() / _inputFormat.channelCount());
@@ -326,7 +414,9 @@ void Audio::handleAudioInput() {
                              inputByteArray.size() / sizeof(int16_t),
                              loopBackByteArray.size() / sizeof(int16_t), _inputFormat, _outputFormat);
 
-            _loopbackOutputDevice->write(loopBackByteArray);
+            if (_loopbackOutputDevice) {
+                _loopbackOutputDevice->write(loopBackByteArray);
+            }
         }
     }
 
@@ -455,7 +545,7 @@ void Audio::handleAudioInput() {
         addProceduralSounds(monoAudioSamples,
                             NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL);
         
-        if (!_proceduralOutputDevice) {
+        if (!_proceduralOutputDevice && _proceduralAudioOutput) {
             _proceduralOutputDevice = _proceduralAudioOutput->start();
         }
         
@@ -469,7 +559,9 @@ void Audio::handleAudioInput() {
                          NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL * 4,
                          _desiredInputFormat, _outputFormat);
         
-        _proceduralOutputDevice->write(proceduralOutput);
+        if (_proceduralOutputDevice) {
+            _proceduralOutputDevice->write(proceduralOutput);
+        }
 
         NodeList* nodeList = NodeList::getInstance();
         SharedNodePointer audioMixer = nodeList->soloNodeOfType(NodeType::AudioMixer);
@@ -553,7 +645,7 @@ void Audio::addReceivedAudioToBuffer(const QByteArray& audioByteArray) {
     static float networkOutputToOutputRatio = (_desiredOutputFormat.sampleRate() / (float) _outputFormat.sampleRate())
         * (_desiredOutputFormat.channelCount() / (float) _outputFormat.channelCount());
     
-    if (!_ringBuffer.isStarved() && _audioOutput->bytesFree() == _audioOutput->bufferSize()) {
+    if (!_ringBuffer.isStarved() && _audioOutput && _audioOutput->bytesFree() == _audioOutput->bufferSize()) {
         // we don't have any audio data left in the output buffer
         // we just starved
         //qDebug() << "Audio output just starved.";

interface/src/Audio.h

@@ -19,17 +19,20 @@
 
 #include "InterfaceConfig.h"
 
+#include <QAudio>
+#include <QAudioInput>
+#include <QGLWidget>
 #include <QtCore/QObject>
 #include <QtCore/QVector>
 #include <QtMultimedia/QAudioFormat>
+#include <QVector>
 
 #include <AbstractAudioInterface.h>
 #include <AudioRingBuffer.h>
 #include <StdDev.h>
 
-#include "Oscilloscope.h"
+#include "ui/Oscilloscope.h"
 
-#include <QGLWidget>
 
 static const int NUM_AUDIO_CHANNELS = 2;
 
@@ -72,7 +75,7 @@ public:
     
     int getNetworkSampleRate() { return SAMPLE_RATE; }
     int getNetworkBufferLengthSamplesPerChannel() { return NETWORK_BUFFER_LENGTH_SAMPLES_PER_CHANNEL; }
-    
+
 public slots:
     void start();
     void addReceivedAudioToBuffer(const QByteArray& audioByteArray);
@@ -83,10 +86,21 @@ public slots:
     
     virtual void handleAudioByteArray(const QByteArray& audioByteArray);
 
+    bool switchInputToAudioDevice(const QString& inputDeviceName);
+    bool switchOutputToAudioDevice(const QString& outputDeviceName);
+    QString getDeviceName(QAudio::Mode mode) const { return (mode == QAudio::AudioInput) ?
+                                                            _inputAudioDeviceName : _outputAudioDeviceName; }
+    QString getDefaultDeviceName(QAudio::Mode mode);
+    QVector<QString> getDeviceNames(QAudio::Mode mode);
+
+    float getInputVolume() const { return (_audioInput) ? _audioInput->volume() : 0.0f; }
+    void setInputVolume(float volume) { if (_audioInput) _audioInput->setVolume(volume); }
+
 signals:
     bool muteToggled();
     
 private:
+
     QByteArray firstInputFrame;
     QAudioInput* _audioInput;
     QAudioFormat _desiredInputFormat;
@@ -105,6 +119,9 @@ private:
     QIODevice* _proceduralOutputDevice;
     AudioRingBuffer _inputRingBuffer;
     AudioRingBuffer _ringBuffer;
+
+    QString _inputAudioDeviceName;
+    QString _outputAudioDeviceName;
     
     Oscilloscope* _scope;
     StDev _stdev;

interface/src/Environment.cpp

@@ -92,7 +92,7 @@ glm::vec3 Environment::getGravity (const glm::vec3& position) {
     
     foreach (const ServerData& serverData, _data) {
         foreach (const EnvironmentData& environmentData, serverData) {
-            glm::vec3 vector = environmentData.getAtmosphereCenter() - position;
+            glm::vec3 vector = environmentData.getAtmosphereCenter(position) - position;
             float surfaceRadius = environmentData.getAtmosphereInnerRadius();
             if (glm::length(vector) <= surfaceRadius) {
                 //  At or inside a planet, gravity is as set for the planet
@@ -116,7 +116,7 @@ const EnvironmentData Environment::getClosestData(const glm::vec3& position) {
     float closestDistance = FLT_MAX;
     foreach (const ServerData& serverData, _data) {
         foreach (const EnvironmentData& environmentData, serverData) {
-            float distance = glm::distance(position, environmentData.getAtmosphereCenter()) -
+            float distance = glm::distance(position, environmentData.getAtmosphereCenter(position)) -
                 environmentData.getAtmosphereOuterRadius();
             if (distance < closestDistance) {
                 closest = environmentData;
@@ -132,6 +132,8 @@ bool Environment::findCapsulePenetration(const glm::vec3& start, const glm::vec3
     // collide with the "floor"
     bool found = findCapsulePlanePenetration(start, end, radius, glm::vec4(0.0f, 1.0f, 0.0f, 0.0f), penetration);
     
+    glm::vec3 middle = (start + end) * 0.5f;
+    
     // get the lock for the duration of the call
     QMutexLocker locker(&_mutex);
     
@@ -141,7 +143,7 @@ bool Environment::findCapsulePenetration(const glm::vec3& start, const glm::vec3
                 continue; // don't bother colliding with gravity-less environments
             }
             glm::vec3 environmentPenetration;
-            if (findCapsuleSpherePenetration(start, end, radius, environmentData.getAtmosphereCenter(),
+            if (findCapsuleSpherePenetration(start, end, radius, environmentData.getAtmosphereCenter(middle),
                     environmentData.getAtmosphereInnerRadius(), environmentPenetration)) {
                 penetration = addPenetrations(penetration, environmentPenetration);
                 found = true;
@@ -203,10 +205,12 @@ ProgramObject* Environment::createSkyProgram(const char* from, int* locations) {
 }
 
 void Environment::renderAtmosphere(Camera& camera, const EnvironmentData& data) {
+    glm::vec3 center = data.getAtmosphereCenter(camera.getPosition());
+    
     glPushMatrix();
-    glTranslatef(data.getAtmosphereCenter().x, data.getAtmosphereCenter().y, data.getAtmosphereCenter().z);
-
-    glm::vec3 relativeCameraPos = camera.getPosition() - data.getAtmosphereCenter();
+    glTranslatef(center.x, center.y, center.z);
+    
+    glm::vec3 relativeCameraPos = camera.getPosition() - center;
     float height = glm::length(relativeCameraPos);
     
     // use the appropriate shader depending on whether we're inside or outside

interface/src/GLCanvas.cpp

@@ -55,6 +55,10 @@ void GLCanvas::keyReleaseEvent(QKeyEvent* event) {
     Application::getInstance()->keyReleaseEvent(event);
 }
 
+void GLCanvas::focusOutEvent(QFocusEvent* event) {
+    Application::getInstance()->focusOutEvent(event);
+}
+
 void GLCanvas::mouseMoveEvent(QMouseEvent* event) {
     Application::getInstance()->mouseMoveEvent(event);
 }

interface/src/GLCanvas.h

@@ -31,6 +31,8 @@ protected:
     virtual void keyPressEvent(QKeyEvent* event);
     virtual void keyReleaseEvent(QKeyEvent* event);
     
+    virtual void focusOutEvent(QFocusEvent* event);
+    
     virtual void mouseMoveEvent(QMouseEvent* event);
     virtual void mousePressEvent(QMouseEvent* event);
     virtual void mouseReleaseEvent(QMouseEvent* event);

interface/src/Menu.cpp

@@ -24,18 +24,20 @@
 #include <QSlider>
 #include <QStandardPaths>
 #include <QUuid>
-#include <QWindow>
+#include <QHBoxLayout>
 
 #include <AccountManager.h>
 #include <XmppClient.h>
 #include <UUID.h>
+#include <FileDownloader.h>
 
 #include "Application.h"
 #include "Menu.h"
-#include "MenuScriptingInterface.h"
+#include "scripting/MenuScriptingInterface.h"
 #include "Util.h"
-#include "InfoView.h"
+#include "ui/InfoView.h"
 #include "ui/MetavoxelEditor.h"
+#include "ui/ModelBrowser.h"
 
 
 Menu* Menu::_instance = NULL;
@@ -59,6 +61,7 @@ Menu* Menu::getInstance() {
 
 const ViewFrustumOffset DEFAULT_FRUSTUM_OFFSET = {-135.0f, 0.0f, 0.0f, 25.0f, 0.0f};
 const float DEFAULT_FACESHIFT_EYE_DEFLECTION = 0.25f;
+const float DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER = 1.0f;
 const int FIVE_SECONDS_OF_FRAMES = 5 * 60;
 
 Menu::Menu() :
@@ -73,9 +76,11 @@ Menu::Menu() :
     _lodToolsDialog(NULL),
     _maxVoxels(DEFAULT_MAX_VOXELS_PER_SYSTEM),
     _voxelSizeScale(DEFAULT_OCTREE_SIZE_SCALE),
+    _avatarLODDistanceMultiplier(DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER),
     _boundaryLevelAdjust(0),
     _maxVoxelPacketsPerSecond(DEFAULT_MAX_VOXEL_PPS),
     _lastAdjust(usecTimestampNow()),
+    _lastAvatarDetailDrop(usecTimestampNow()),
     _fpsAverage(FIVE_SECONDS_OF_FRAMES),
     _loginAction(NULL)
 {
@@ -105,6 +110,8 @@ Menu::Menu() :
 
     addDisabledActionAndSeparator(fileMenu, "Scripts");
     addActionToQMenuAndActionHash(fileMenu, MenuOption::LoadScript, Qt::CTRL | Qt::Key_O, appInstance, SLOT(loadDialog()));
+    addActionToQMenuAndActionHash(fileMenu, MenuOption::LoadScriptURL, 
+                                    Qt::CTRL | Qt::SHIFT | Qt::Key_O, appInstance, SLOT(loadScriptURLDialog()));
     addActionToQMenuAndActionHash(fileMenu, MenuOption::StopAllScripts, 0, appInstance, SLOT(stopAllScripts()));
     addActionToQMenuAndActionHash(fileMenu, MenuOption::ReloadAllScripts, 0, appInstance, SLOT(reloadAllScripts()));
     _activeScriptsMenu = fileMenu->addMenu("Running Scripts");
@@ -136,9 +143,8 @@ Menu::Menu() :
                                   this,
                                   SLOT(goTo()));
 
-    addDisabledActionAndSeparator(fileMenu, "Upload/Browse");
-    addActionToQMenuAndActionHash(fileMenu, MenuOption::UploaderAvatarHead, 0, Application::getInstance(), SLOT(uploadFST()));
-    addActionToQMenuAndActionHash(fileMenu, MenuOption::UploaderAvatarSkeleton, 0, Application::getInstance(), SLOT(uploadFST()));
+    addDisabledActionAndSeparator(fileMenu, "Upload Avatar Model");
+    addActionToQMenuAndActionHash(fileMenu, MenuOption::UploadFST, 0, Application::getInstance(), SLOT(uploadFST()));
     
     addDisabledActionAndSeparator(fileMenu, "Settings");
     addActionToQMenuAndActionHash(fileMenu, MenuOption::SettingsImport, 0, this, SLOT(importSettings()));
@@ -165,7 +171,7 @@ Menu::Menu() :
     addCheckableActionToQMenuAndActionHash(editMenu, MenuOption::Gravity, Qt::SHIFT | Qt::Key_G, false);
 
     
-    addCheckableActionToQMenuAndActionHash(editMenu, MenuOption::ClickToFly);
+  
 
     addAvatarCollisionSubMenu(editMenu);
 
@@ -373,8 +379,10 @@ Menu::~Menu() {
 }
 
 void Menu::loadSettings(QSettings* settings) {
+    bool lockedSettings = false;
     if (!settings) {
-        settings = Application::getInstance()->getSettings();
+        settings = Application::getInstance()->lockSettings();
+        lockedSettings = true;
     }
 
     _audioJitterBufferSamples = loadSetting(settings, "audioJitterBufferSamples", 0);
@@ -383,6 +391,8 @@ void Menu::loadSettings(QSettings* settings) {
     _maxVoxels = loadSetting(settings, "maxVoxels", DEFAULT_MAX_VOXELS_PER_SYSTEM);
     _maxVoxelPacketsPerSecond = loadSetting(settings, "maxVoxelsPPS", DEFAULT_MAX_VOXEL_PPS);
     _voxelSizeScale = loadSetting(settings, "voxelSizeScale", DEFAULT_OCTREE_SIZE_SCALE);
+    _avatarLODDistanceMultiplier = loadSetting(settings, "avatarLODDistanceMultiplier",
+        DEFAULT_AVATAR_LOD_DISTANCE_MULTIPLIER);
     _boundaryLevelAdjust = loadSetting(settings, "boundaryLevelAdjust", 0);
 
     settings->beginGroup("View Frustum Offset Camera");
@@ -403,11 +413,17 @@ void Menu::loadSettings(QSettings* settings) {
     // TODO: cache more settings in MyAvatar that are checked with very high frequency.
     MyAvatar* myAvatar = Application::getInstance()->getAvatar();
     myAvatar->updateCollisionFlags();
+
+    if (lockedSettings) {
+        Application::getInstance()->unlockSettings();
+    }
 }
 
 void Menu::saveSettings(QSettings* settings) {
+    bool lockedSettings = false;
     if (!settings) {
-        settings = Application::getInstance()->getSettings();
+        settings = Application::getInstance()->lockSettings();
+        lockedSettings = true;
     }
 
     settings->setValue("audioJitterBufferSamples", _audioJitterBufferSamples);
@@ -416,6 +432,7 @@ void Menu::saveSettings(QSettings* settings) {
     settings->setValue("maxVoxels", _maxVoxels);
     settings->setValue("maxVoxelsPPS", _maxVoxelPacketsPerSecond);
     settings->setValue("voxelSizeScale", _voxelSizeScale);
+    settings->setValue("avatarLODDistanceMultiplier", _avatarLODDistanceMultiplier);
     settings->setValue("boundaryLevelAdjust", _boundaryLevelAdjust);
     settings->beginGroup("View Frustum Offset Camera");
     settings->setValue("viewFrustumOffsetYaw", _viewFrustumOffset.yaw);
@@ -429,6 +446,9 @@ void Menu::saveSettings(QSettings* settings) {
     Application::getInstance()->getAvatar()->saveData(settings);
     NodeList::getInstance()->saveData(settings);
 
+    if (lockedSettings) {
+        Application::getInstance()->unlockSettings();
+    }
 }
 
 void Menu::importSettings() {
@@ -692,6 +712,10 @@ void Menu::loginForCurrentDomain() {
 
 void Menu::editPreferences() {
     Application* applicationInstance = Application::getInstance();
+    ModelBrowser headBrowser(Head);
+    ModelBrowser skeletonBrowser(Skeleton);
+    
+    const QString BROWSE_BUTTON_TEXT = "Browse";
 
     QDialog dialog(applicationInstance->getWindow());
     dialog.setWindowTitle("Interface Preferences");
@@ -702,17 +726,31 @@ void Menu::editPreferences() {
     QFormLayout* form = new QFormLayout();
     layout->addLayout(form, 1);
 
+    
+    QHBoxLayout headModelLayout;
     QString faceURLString = applicationInstance->getAvatar()->getHead()->getFaceModel().getURL().toString();
-    QLineEdit* faceURLEdit = new QLineEdit(faceURLString);
-    faceURLEdit->setMinimumWidth(QLINE_MINIMUM_WIDTH);
-    faceURLEdit->setPlaceholderText(DEFAULT_HEAD_MODEL_URL.toString());
-    form->addRow("Face URL:", faceURLEdit);
-
+    QLineEdit headURLEdit(faceURLString);
+    QPushButton headBrowseButton(BROWSE_BUTTON_TEXT);
+    connect(&headBrowseButton, SIGNAL(clicked()), &headBrowser, SLOT(browse()));
+    connect(&headBrowser, SIGNAL(selected(QString)), &headURLEdit, SLOT(setText(QString)));
+    headURLEdit.setMinimumWidth(QLINE_MINIMUM_WIDTH);
+    headURLEdit.setPlaceholderText(DEFAULT_HEAD_MODEL_URL.toString());
+    headModelLayout.addWidget(&headURLEdit);
+    headModelLayout.addWidget(&headBrowseButton);
+    form->addRow("Head URL:", &headModelLayout);
+    
+    QHBoxLayout skeletonModelLayout;
     QString skeletonURLString = applicationInstance->getAvatar()->getSkeletonModel().getURL().toString();
-    QLineEdit* skeletonURLEdit = new QLineEdit(skeletonURLString);
-    skeletonURLEdit->setMinimumWidth(QLINE_MINIMUM_WIDTH);
-    skeletonURLEdit->setPlaceholderText(DEFAULT_BODY_MODEL_URL.toString());
-    form->addRow("Skeleton URL:", skeletonURLEdit);
+    QLineEdit skeletonURLEdit(skeletonURLString);
+    QPushButton SkeletonBrowseButton(BROWSE_BUTTON_TEXT);
+    connect(&SkeletonBrowseButton, SIGNAL(clicked()), &skeletonBrowser, SLOT(browse()));
+    connect(&skeletonBrowser, SIGNAL(selected(QString)), &skeletonURLEdit, SLOT(setText(QString)));
+    skeletonURLEdit.setMinimumWidth(QLINE_MINIMUM_WIDTH);
+    skeletonURLEdit.setPlaceholderText(DEFAULT_BODY_MODEL_URL.toString());
+    skeletonModelLayout.addWidget(&skeletonURLEdit);
+    skeletonModelLayout.addWidget(&SkeletonBrowseButton);
+    form->addRow("Skeleton URL:", &skeletonModelLayout);
+    
 
     QString displayNameString = applicationInstance->getAvatar()->getDisplayName();
     QLineEdit* displayNameEdit = new QLineEdit(displayNameString);
@@ -774,21 +812,17 @@ void Menu::editPreferences() {
 
     int ret = dialog.exec();
     if (ret == QDialog::Accepted) {
-        QUrl faceModelURL(faceURLEdit->text());
-        
         bool shouldDispatchIdentityPacket = false;
 
-        if (faceModelURL.toString() != faceURLString) {
+        if (headURLEdit.text() != faceURLString && !headURLEdit.text().isEmpty()) {
             // change the faceModelURL in the profile, it will also update this user's BlendFace
-            applicationInstance->getAvatar()->setFaceModelURL(faceModelURL);
+            applicationInstance->getAvatar()->setFaceModelURL(QUrl(headURLEdit.text()));
             shouldDispatchIdentityPacket = true;
         }
 
-        QUrl skeletonModelURL(skeletonURLEdit->text());
-
-        if (skeletonModelURL.toString() != skeletonURLString) {
+        if (skeletonURLEdit.text() != skeletonURLString && !skeletonURLEdit.text().isEmpty()) {
             // change the skeletonModelURL in the profile, it will also update this user's Body
-            applicationInstance->getAvatar()->setSkeletonModelURL(skeletonModelURL);
+            applicationInstance->getAvatar()->setSkeletonModelURL(QUrl(skeletonURLEdit.text()));
             shouldDispatchIdentityPacket = true;
         }
 
@@ -1159,8 +1193,24 @@ void Menu::autoAdjustLOD(float currentFPS) {
     }
     _fpsAverage.updateAverage(currentFPS);
 
-    bool changed = false;
     quint64 now = usecTimestampNow();
+    
+    if (_fpsAverage.getAverage() < ADJUST_LOD_DOWN_FPS) {
+        if (now - _lastAvatarDetailDrop > ADJUST_LOD_DOWN_DELAY) {
+            // attempt to lower the detail in proportion to the fps difference
+            float targetFps = (ADJUST_LOD_DOWN_FPS + ADJUST_LOD_UP_FPS) * 0.5f;
+            _avatarLODDistanceMultiplier *= (targetFps / _fpsAverage.getAverage()); 
+            _lastAvatarDetailDrop = now;
+        }
+    } else if (_fpsAverage.getAverage() > ADJUST_LOD_UP_FPS) {
+        // let the detail level creep slowly upwards
+        const float DISTANCE_DECREASE_RATE = 0.01f;
+        const float MINIMUM_DISTANCE_MULTIPLIER = 0.1f;
+        _avatarLODDistanceMultiplier = qMax(MINIMUM_DISTANCE_MULTIPLIER,
+            _avatarLODDistanceMultiplier - DISTANCE_DECREASE_RATE);
+    }
+    
+    bool changed = false;
     quint64 elapsed = now - _lastAdjust;
 
     if (elapsed > ADJUST_LOD_DOWN_DELAY && _fpsAverage.getAverage() < ADJUST_LOD_DOWN_FPS 
@@ -1388,9 +1438,8 @@ void Menu::removeMenu(const QString& menuName) {
     if (action) {
         QString finalMenuPart;
         QMenu* parent = getMenuParent(menuName, finalMenuPart);
-    
         if (parent) {
-            removeAction(parent, finalMenuPart);
+            parent->removeAction(action);
         } else {
             QMenuBar::removeAction(action);
         }

interface/src/Menu.h

@@ -89,7 +89,7 @@ public:
     void autoAdjustLOD(float currentFPS);
     void setVoxelSizeScale(float sizeScale);
     float getVoxelSizeScale() const { return _voxelSizeScale; }
-    float getAvatarLODDistanceMultiplier() const { return DEFAULT_OCTREE_SIZE_SCALE / _voxelSizeScale; }
+    float getAvatarLODDistanceMultiplier() const { return _avatarLODDistanceMultiplier; }
     void setBoundaryLevelAdjust(int boundaryLevelAdjust);
     int getBoundaryLevelAdjust() const { return _boundaryLevelAdjust; }
 
@@ -202,12 +202,14 @@ private:
     LodToolsDialog* _lodToolsDialog;
     int _maxVoxels;
     float _voxelSizeScale;
+    float _avatarLODDistanceMultiplier;
     int _boundaryLevelAdjust;
     QAction* _useVoxelShader;
     int _maxVoxelPacketsPerSecond;
     QMenu* _activeScriptsMenu;
     QString replaceLastOccurrence(QChar search, QChar replace, QString string);
     quint64 _lastAdjust;
+    quint64 _lastAvatarDetailDrop;
     SimpleMovingAverage _fpsAverage;
     QAction* _loginAction;
     QAction* _chatAction;
@@ -272,8 +274,8 @@ namespace MenuOption {
     const QString OffAxisProjection = "Off-Axis Projection";
     const QString OldVoxelCullingMode = "Old Voxel Culling Mode";
     const QString TurnWithHead = "Turn using Head";
-    const QString ClickToFly = "Fly to voxel on click";
-    const QString LoadScript = "Open and Run Script...";
+    const QString LoadScript = "Open and Run Script File...";
+    const QString LoadScriptURL = "Open and Run Script from URL...";
     const QString Oscilloscope = "Audio Oscilloscope";
     const QString Pair = "Pair";
     const QString Particles = "Particles";
@@ -296,8 +298,7 @@ namespace MenuOption {
     const QString StopAllScripts = "Stop All Scripts";
     const QString TestPing = "Test Ping";
     const QString TransmitterDrive = "Transmitter Drive";
-    const QString UploaderAvatarHead = "Upload Avatar Head";
-    const QString UploaderAvatarSkeleton = "Upload Avatar Skeleton";
+    const QString UploadFST = "Upload FST file";
     const QString Visage = "Visage";
     const QString Quit =  "Quit";
     const QString Voxels = "Voxels";
@@ -306,4 +307,6 @@ namespace MenuOption {
     const QString VoxelTextures = "Voxel Textures";
 }
 
+void sendFakeEnterEvent();
+
 #endif /* defined(__hifi__Menu__) */

interface/src/MetavoxelSystem.cpp

@@ -185,10 +185,11 @@ int MetavoxelSystem::SimulateVisitor::visit(MetavoxelInfo& info) {
     }
     QRgb color = info.inputValues.at(0).getInlineValue<QRgb>();
     QRgb normal = info.inputValues.at(1).getInlineValue<QRgb>();
-    int alpha = qAlpha(color);
+    quint8 alpha = qAlpha(color);
     if (alpha > 0) {
         Point point = { glm::vec4(info.minimum + glm::vec3(info.size, info.size, info.size) * 0.5f, info.size),
-            { qRed(color), qGreen(color), qBlue(color), alpha }, { qRed(normal), qGreen(normal), qBlue(normal) } };
+            { quint8(qRed(color)), quint8(qGreen(color)), quint8(qBlue(color)), alpha }, 
+            { quint8(qRed(normal)), quint8(qGreen(normal)), quint8(qBlue(normal)) } };
         _points.append(point);
     }
     return STOP_RECURSION;

interface/src/Util.cpp

@@ -14,6 +14,7 @@
 #include <glm/glm.hpp>
 #include <glm/gtc/noise.hpp>
 #include <glm/gtx/quaternion.hpp>
+#include <glm/detail/func_common.hpp>
 
 #include <SharedUtil.h>
 
@@ -24,12 +25,6 @@
 
 #include "Util.h"
 
-#ifdef _WIN32
-int isnan(double value) { return _isnan(value); }
-#else
-int isnan(double value) { return std::isnan(value); }
-#endif
-
 using namespace std;
 
 // no clue which versions are affected...
@@ -88,7 +83,7 @@ float angleBetween(const glm::vec3& v1, const glm::vec3& v2) {
 //  Helper function return the rotation from the first vector onto the second
 glm::quat rotationBetween(const glm::vec3& v1, const glm::vec3& v2) {
     float angle = angleBetween(v1, v2);
-    if (isnan(angle) || angle < EPSILON) {
+    if (glm::isnan(angle) || angle < EPSILON) {
         return glm::quat();
     }
     glm::vec3 axis;
@@ -586,7 +581,7 @@ void runTimingTests() {
 
 float loadSetting(QSettings* settings, const char* name, float defaultValue) {
     float value = settings->value(name, defaultValue).toFloat();
-    if (isnan(value)) {
+    if (glm::isnan(value)) {
         value = defaultValue;
     }
     return value;

interface/src/avatar/Avatar.cpp

@@ -189,10 +189,12 @@ static TextRenderer* textRenderer(TextRendererType type) {
     return displayNameRenderer;
 }
 
-void Avatar::render(const glm::vec3& cameraPosition, bool forShadowMap) {
+void Avatar::render(const glm::vec3& cameraPosition, RenderMode renderMode) {
     // simple frustum check
     float boundingRadius = getBillboardSize();
-    if (Application::getInstance()->getViewFrustum()->sphereInFrustum(cameraPosition, boundingRadius) == ViewFrustum::OUTSIDE) {
+    ViewFrustum* frustum = (renderMode == Avatar::SHADOW_RENDER_MODE) ?
+        Application::getInstance()->getShadowViewFrustum() : Application::getInstance()->getViewFrustum();
+    if (frustum->sphereInFrustum(_position, boundingRadius) == ViewFrustum::OUTSIDE) {
         return;
     }
 
@@ -202,11 +204,11 @@ void Avatar::render(const glm::vec3& cameraPosition, bool forShadowMap) {
     {
         // glow when moving far away
         const float GLOW_DISTANCE = 20.0f;
-        Glower glower(_moving && distanceToTarget > GLOW_DISTANCE && !forShadowMap ? 1.0f : 0.0f);
+        Glower glower(_moving && distanceToTarget > GLOW_DISTANCE && renderMode == NORMAL_RENDER_MODE ? 1.0f : 0.0f);
 
         // render body
         if (Menu::getInstance()->isOptionChecked(MenuOption::Avatars)) {
-            renderBody(forShadowMap);
+            renderBody(renderMode);
         }
         if (Menu::getInstance()->isOptionChecked(MenuOption::RenderSkeletonCollisionProxies)) {
             _skeletonModel.renderCollisionProxies(0.7f);
@@ -230,7 +232,8 @@ void Avatar::render(const glm::vec3& cameraPosition, bool forShadowMap) {
             float angle = abs(angleBetween(toTarget + delta, toTarget - delta));
             float sphereRadius = getHead()->getAverageLoudness() * SPHERE_LOUDNESS_SCALING;
             
-            if (!forShadowMap && (sphereRadius > MIN_SPHERE_SIZE) && (angle < MAX_SPHERE_ANGLE) && (angle > MIN_SPHERE_ANGLE)) {
+            if (renderMode == NORMAL_RENDER_MODE && (sphereRadius > MIN_SPHERE_SIZE) &&
+                    (angle < MAX_SPHERE_ANGLE) && (angle > MIN_SPHERE_ANGLE)) {
                 glColor4f(SPHERE_COLOR[0], SPHERE_COLOR[1], SPHERE_COLOR[2], 1.f - angle / MAX_SPHERE_ANGLE);
                 glPushMatrix();
                 glTranslatef(_position.x, _position.y, _position.z);
@@ -242,8 +245,8 @@ void Avatar::render(const glm::vec3& cameraPosition, bool forShadowMap) {
     }
 
     const float DISPLAYNAME_DISTANCE = 10.0f;
-    setShowDisplayName(!forShadowMap && distanceToTarget < DISPLAYNAME_DISTANCE);
-    if (forShadowMap) {
+    setShowDisplayName(renderMode == NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE);
+    if (renderMode != NORMAL_RENDER_MODE) {
         return;
     }
     renderDisplayName();
@@ -306,17 +309,16 @@ glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
     return glm::angleAxis(angle * proportion, axis);
 }
 
-void Avatar::renderBody(bool forShadowMap) {    
+void Avatar::renderBody(RenderMode renderMode) {    
     if (_shouldRenderBillboard || !(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
         // render the billboard until both models are loaded
-        if (forShadowMap) {
-            return;
+        if (renderMode != SHADOW_RENDER_MODE) {
+            renderBillboard();
         }
-        renderBillboard();
         return;
     }
-    _skeletonModel.render(1.0f);
-    getHead()->render(1.0f);
+    _skeletonModel.render(1.0f, renderMode == SHADOW_RENDER_MODE);
+    getHead()->render(1.0f, renderMode == SHADOW_RENDER_MODE);
     getHand()->render(false);
 }
 

interface/src/avatar/Avatar.h

@@ -74,7 +74,10 @@ public:
 
     void init();
     void simulate(float deltaTime);
-    virtual void render(const glm::vec3& cameraPosition, bool forShadowMap);
+    
+    enum RenderMode { NORMAL_RENDER_MODE, SHADOW_RENDER_MODE, MIRROR_RENDER_MODE };
+    
+    virtual void render(const glm::vec3& cameraPosition, RenderMode renderMode = NORMAL_RENDER_MODE);
 
     //setters
     void setDisplayingLookatVectors(bool displayingLookatVectors) { getHead()->setRenderLookatVectors(displayingLookatVectors); }
@@ -133,7 +136,7 @@ public:
 
     void setShowDisplayName(bool showDisplayName);
     
-    int parseDataAtOffset(const QByteArray& packet, int offset);
+    virtual int parseDataAtOffset(const QByteArray& packet, int offset);
 
     static void renderJointConnectingCone(glm::vec3 position1, glm::vec3 position2, float radius1, float radius2);
 
@@ -182,7 +185,7 @@ protected:
     float getPelvisToHeadLength() const;
 
     void renderDisplayName();
-    virtual void renderBody(bool forShadowMap);
+    virtual void renderBody(RenderMode renderMode);
 
 private:
 

interface/src/avatar/AvatarManager.cpp

@@ -48,15 +48,12 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
     AvatarHash::iterator avatarIterator = _avatarHash.begin();
     while (avatarIterator != _avatarHash.end()) {
         Avatar* avatar = static_cast<Avatar*>(avatarIterator.value().data());
-        if (avatar == static_cast<Avatar*>(_myAvatar.data())) {
+        if (avatar == static_cast<Avatar*>(_myAvatar.data()) || !avatar->isInitialized()) {
             // DO NOT update _myAvatar!  Its update has already been done earlier in the main loop.
-            //updateMyAvatar(deltaTime);
+            // DO NOT update uninitialized Avatars
             ++avatarIterator;
             continue;
         }
-        if (!avatar->isInitialized()) {
-            avatar->init();
-        }
         if (avatar->getOwningAvatarMixer()) {
             // this avatar's mixer is still around, go ahead and simulate it
             avatar->simulate(deltaTime);
@@ -72,7 +69,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
     simulateAvatarFades(deltaTime);
 }
 
-void AvatarManager::renderAvatars(bool forShadowMapOrMirror, bool selfAvatarOnly) {
+void AvatarManager::renderAvatars(Avatar::RenderMode renderMode, bool selfAvatarOnly) {
     PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
                             "Application::renderAvatars()");
     bool renderLookAtVectors = Menu::getInstance()->isOptionChecked(MenuOption::LookAtVectors);
@@ -85,13 +82,13 @@ void AvatarManager::renderAvatars(bool forShadowMapOrMirror, bool selfAvatarOnly
             if (!avatar->isInitialized()) {
                 continue;
             }
-            avatar->render(cameraPosition, forShadowMapOrMirror);
+            avatar->render(cameraPosition, renderMode);
             avatar->setDisplayingLookatVectors(renderLookAtVectors);
         }
-        renderAvatarFades(cameraPosition, forShadowMapOrMirror);
+        renderAvatarFades(cameraPosition, renderMode);
     } else {
         // just render myAvatar
-        _myAvatar->render(cameraPosition, forShadowMapOrMirror);
+        _myAvatar->render(cameraPosition, renderMode);
         _myAvatar->setDisplayingLookatVectors(renderLookAtVectors);
     }
 }
@@ -114,28 +111,46 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
     }
 }
 
-void AvatarManager::renderAvatarFades(const glm::vec3& cameraPosition, bool forShadowMap) {
+void AvatarManager::renderAvatarFades(const glm::vec3& cameraPosition, Avatar::RenderMode renderMode) {
     // render avatar fades
-    Glower glower(forShadowMap ? 0.0f : 1.0f);
+    Glower glower(renderMode == Avatar::NORMAL_RENDER_MODE ? 1.0f : 0.0f);
     
     foreach(const AvatarSharedPointer& fadingAvatar, _avatarFades) {
         Avatar* avatar = static_cast<Avatar*>(fadingAvatar.data());
-        if (avatar != static_cast<Avatar*>(_myAvatar.data())) {
-            avatar->render(cameraPosition, forShadowMap);
+        if (avatar != static_cast<Avatar*>(_myAvatar.data()) && avatar->isInitialized()) {
+            avatar->render(cameraPosition, renderMode);
         }
     }
 }
 
+AvatarSharedPointer AvatarManager::matchingOrNewAvatar(const QUuid& nodeUUID, const QWeakPointer<Node>& mixerWeakPointer) {
+    AvatarSharedPointer matchingAvatar = _avatarHash.value(nodeUUID);
+    
+    if (!matchingAvatar) {
+        // construct a new Avatar for this node
+        Avatar* avatar =  new Avatar();
+        avatar->setOwningAvatarMixer(mixerWeakPointer);
+        
+        // insert the new avatar into our hash
+        matchingAvatar = AvatarSharedPointer(avatar);
+        _avatarHash.insert(nodeUUID, matchingAvatar);
+        
+        qDebug() << "Adding avatar with UUID" << nodeUUID << "to AvatarManager hash.";
+    }
+    
+    return matchingAvatar;
+}
+
 void AvatarManager::processAvatarMixerDatagram(const QByteArray& datagram, const QWeakPointer<Node>& mixerWeakPointer) {
     switch (packetTypeForPacket(datagram)) {
         case PacketTypeBulkAvatarData:
             processAvatarDataPacket(datagram, mixerWeakPointer);
             break;
         case PacketTypeAvatarIdentity:
-            processAvatarIdentityPacket(datagram);
+            processAvatarIdentityPacket(datagram, mixerWeakPointer);
             break;
         case PacketTypeAvatarBillboard:
-            processAvatarBillboardPacket(datagram);
+            processAvatarBillboardPacket(datagram, mixerWeakPointer);
             break;
         case PacketTypeKillAvatar:
             processKillAvatar(datagram);
@@ -154,26 +169,21 @@ void AvatarManager::processAvatarDataPacket(const QByteArray &datagram, const QW
         QUuid nodeUUID = QUuid::fromRfc4122(datagram.mid(bytesRead, NUM_BYTES_RFC4122_UUID));
         bytesRead += NUM_BYTES_RFC4122_UUID;
         
-        AvatarSharedPointer matchingAvatar = _avatarHash.value(nodeUUID);
-        
-        if (!matchingAvatar) {
-            // construct a new Avatar for this node
-            Avatar* avatar =  new Avatar();
-            avatar->setOwningAvatarMixer(mixerWeakPointer);
-            
-            // insert the new avatar into our hash
-            matchingAvatar = AvatarSharedPointer(avatar);
-            _avatarHash.insert(nodeUUID, matchingAvatar);
-            
-            qDebug() << "Adding avatar with UUID" << nodeUUID << "to AvatarManager hash.";
-        }
+        AvatarSharedPointer matchingAvatarData = matchingOrNewAvatar(nodeUUID, mixerWeakPointer);
         
         // have the matching (or new) avatar parse the data from the packet
-        bytesRead += matchingAvatar->parseDataAtOffset(datagram, bytesRead);
+        bytesRead += matchingAvatarData->parseDataAtOffset(datagram, bytesRead);
+        
+        Avatar* matchingAvatar = reinterpret_cast<Avatar*>(matchingAvatarData.data());
+        
+        if (!matchingAvatar->isInitialized()) {
+            // now that we have AvatarData for this Avatar we are go for init
+            matchingAvatar->init();
+        }
     }
 }
 
-void AvatarManager::processAvatarIdentityPacket(const QByteArray &packet) {
+void AvatarManager::processAvatarIdentityPacket(const QByteArray &packet, const QWeakPointer<Node>& mixerWeakPointer) {
     // setup a data stream to parse the packet
     QDataStream identityStream(packet);
     identityStream.skipRawData(numBytesForPacketHeader(packet));
@@ -187,7 +197,7 @@ void AvatarManager::processAvatarIdentityPacket(const QByteArray &packet) {
         identityStream >> nodeUUID >> faceMeshURL >> skeletonURL >> displayName;
 
         // mesh URL for a UUID, find avatar in our list
-        AvatarSharedPointer matchingAvatar = _avatarHash.value(nodeUUID);
+        AvatarSharedPointer matchingAvatar = matchingOrNewAvatar(nodeUUID, mixerWeakPointer);
         if (matchingAvatar) {
             Avatar* avatar = static_cast<Avatar*>(matchingAvatar.data());
             
@@ -206,11 +216,11 @@ void AvatarManager::processAvatarIdentityPacket(const QByteArray &packet) {
     }
 }
 
-void AvatarManager::processAvatarBillboardPacket(const QByteArray& packet) {
+void AvatarManager::processAvatarBillboardPacket(const QByteArray& packet, const QWeakPointer<Node>& mixerWeakPointer) {
     int headerSize = numBytesForPacketHeader(packet);
     QUuid nodeUUID = QUuid::fromRfc4122(QByteArray::fromRawData(packet.constData() + headerSize, NUM_BYTES_RFC4122_UUID));
     
-    AvatarSharedPointer matchingAvatar = _avatarHash.value(nodeUUID);
+    AvatarSharedPointer matchingAvatar = matchingOrNewAvatar(nodeUUID, mixerWeakPointer);
     if (matchingAvatar) {
         Avatar* avatar = static_cast<Avatar*>(matchingAvatar.data());
         QByteArray billboard = packet.mid(headerSize + NUM_BYTES_RFC4122_UUID);
@@ -234,7 +244,9 @@ void AvatarManager::processKillAvatar(const QByteArray& datagram) {
 AvatarHash::iterator AvatarManager::erase(const AvatarHash::iterator& iterator) {
     if (iterator.key() != MY_AVATAR_KEY) {
         qDebug() << "Removing Avatar with UUID" << iterator.key() << "from AvatarManager hash.";
-        _avatarFades.push_back(iterator.value());
+        if (reinterpret_cast<Avatar*>(iterator.value().data())->isInitialized()) {
+            _avatarFades.push_back(iterator.value());
+        }
         return AvatarHashMap::erase(iterator);
     } else {
         // never remove _myAvatar from the list

interface/src/avatar/AvatarManager.h

@@ -29,7 +29,7 @@ public:
     MyAvatar* getMyAvatar() { return _myAvatar.data(); }
     
     void updateOtherAvatars(float deltaTime);
-    void renderAvatars(bool forShadowMapOrMirror = false, bool selfAvatarOnly = false);
+    void renderAvatars(Avatar::RenderMode renderMode, bool selfAvatarOnly = false);
     
     void clearOtherAvatars();
 
@@ -39,13 +39,15 @@ public slots:
 private:
     AvatarManager(const AvatarManager& other);
     
+    AvatarSharedPointer matchingOrNewAvatar(const QUuid& nodeUUID, const QWeakPointer<Node>& mixerWeakPointer);
+    
     void processAvatarDataPacket(const QByteArray& packet, const QWeakPointer<Node>& mixerWeakPointer);
-    void processAvatarIdentityPacket(const QByteArray& packet);
-    void processAvatarBillboardPacket(const QByteArray& packet);
+    void processAvatarIdentityPacket(const QByteArray& packet, const QWeakPointer<Node>& mixerWeakPointer);
+    void processAvatarBillboardPacket(const QByteArray& packet, const QWeakPointer<Node>& mixerWeakPointer);
     void processKillAvatar(const QByteArray& datagram);
 
     void simulateAvatarFades(float deltaTime);
-    void renderAvatarFades(const glm::vec3& cameraPosition, bool forShadowMap);
+    void renderAvatarFades(const glm::vec3& cameraPosition, Avatar::RenderMode renderMode);
     
     // virtual override
     AvatarHash::iterator erase(const AvatarHash::iterator& iterator);

interface/src/avatar/FaceModel.cpp

@@ -45,13 +45,6 @@ void FaceModel::simulate(float deltaTime) {
     Model::simulate(deltaTime, true, newJointStates);
 }
 
-bool FaceModel::render(float alpha) {
-    if (!Model::render(alpha)) {
-        return false;
-    }
-    return true;
-}
-
 void FaceModel::maybeUpdateNeckRotation(const JointState& parentState, const FBXJoint& joint, JointState& state) {
     // get the rotation axes in joint space and use them to adjust the rotation
     glm::mat3 axes = glm::mat3_cast(_rotation);

interface/src/avatar/FaceModel.h

@@ -22,7 +22,6 @@ public:
     FaceModel(Head* owningHead);
 
     void simulate(float deltaTime);
-    bool render(float alpha);
     
 protected:
 

interface/src/avatar/Hand.cpp

@@ -28,10 +28,7 @@ Hand::Hand(Avatar* owningAvatar) :
     HandData((AvatarData*)owningAvatar),
 
     _owningAvatar(owningAvatar),
-    _renderAlpha(1.0),
-    _collisionCenter(0,0,0),
-    _collisionAge(0),
-    _collisionDuration(0)
+    _renderAlpha(1.0)
 {
 }
 
@@ -43,10 +40,6 @@ void Hand::reset() {
 
 void Hand::simulate(float deltaTime, bool isMine) {
     
-    if (_collisionAge > 0.f) {
-        _collisionAge += deltaTime;
-    }
-    
     calculateGeometry();
     
     if (isMine) {
@@ -204,8 +197,8 @@ void Hand::collideAgainstOurself() {
         }
         // ignoring everything below the parent of the parent of the last free joint
         int skipIndex = skeletonModel.getParentJointIndex(skeletonModel.getParentJointIndex(
-            skeletonModel.getLastFreeJointIndex(((int)i == leftPalmIndex) ? skeletonModel.getLeftHandJointIndex() :
-                ((int)i == rightPalmIndex) ? skeletonModel.getRightHandJointIndex() : -1)));
+            skeletonModel.getLastFreeJointIndex((int(i) == leftPalmIndex) ? skeletonModel.getLeftHandJointIndex() :
+                (int(i) == rightPalmIndex) ? skeletonModel.getRightHandJointIndex() : -1)));
 
         handCollisions.clear();
         if (_owningAvatar->findSphereCollisions(palm.getPosition(), scaledPalmRadius, handCollisions, skipIndex)) {
@@ -227,26 +220,6 @@ void Hand::resolvePenetrations() {
     }
 }
 
-void Hand::handleVoxelCollision(PalmData* palm, const glm::vec3& fingerTipPosition, VoxelTreeElement* voxel, float deltaTime) {
-    //  Collision between finger and a voxel plays sound
-    const float LOWEST_FREQUENCY = 100.f;
-    const float HERTZ_PER_RGB = 3.f;
-    const float DECAY_PER_SAMPLE = 0.0005f;
-    const float DURATION_MAX = 2.0f;
-    const float MIN_VOLUME = 0.1f;
-    float volume = MIN_VOLUME + glm::clamp(glm::length(palm->getRawVelocity()), 0.f, (1.f - MIN_VOLUME));
-    float duration = volume;
-    _collisionCenter = fingerTipPosition;
-    _collisionAge = deltaTime;
-    _collisionDuration = duration;
-    int voxelBrightness = voxel->getColor()[0] + voxel->getColor()[1] + voxel->getColor()[2];
-    float frequency = LOWEST_FREQUENCY + (voxelBrightness * HERTZ_PER_RGB);
-    Application::getInstance()->getAudio()->startDrumSound(volume,
-                                                           frequency,
-                                                           DURATION_MAX,
-                                                           DECAY_PER_SAMPLE);
-}
-
 void Hand::calculateGeometry() {
     // generate finger tip balls....
     _leapFingerTipBalls.clear();
@@ -317,21 +290,6 @@ void Hand::render(bool isMine) {
         renderLeapHands(isMine);
     }
 
-    if (isMine) {
-        //  If hand/voxel collision has happened, render a little expanding sphere
-        if (_collisionAge > 0.f) {
-            float opacity = glm::clamp(1.f - (_collisionAge / _collisionDuration), 0.f, 1.f);
-            glColor4f(1, 0, 0, 0.5 * opacity);
-            glPushMatrix();
-            glTranslatef(_collisionCenter.x, _collisionCenter.y, _collisionCenter.z);
-            glutSolidSphere(_collisionAge * 0.25f, 20, 20);
-            glPopMatrix();
-            if (_collisionAge > _collisionDuration) {
-                _collisionAge = 0.f;
-            }
-        }
-    }
-
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_RESCALE_NORMAL);
     

interface/src/avatar/Hand.h

@@ -22,7 +22,6 @@
 
 #include "InterfaceConfig.h"
 #include "world.h"
-#include "VoxelSystem.h"
 
 
 class Avatar;
@@ -74,20 +73,11 @@ private:
     std::vector<HandBall> _leapFingerTipBalls;
     std::vector<HandBall> _leapFingerRootBalls;
     
-    glm::vec3 _lastFingerAddVoxel, _lastFingerDeleteVoxel;
-    VoxelDetail _collidingVoxel;
-    
-    glm::vec3 _collisionCenter;
-    float _collisionAge;
-    float _collisionDuration;
-    
     void renderLeapHands(bool isMine);
     void renderLeapFingerTrails();
     
     void calculateGeometry();
     
-    void handleVoxelCollision(PalmData* palm, const glm::vec3& fingerTipPosition, VoxelTreeElement* voxel, float deltaTime);
-
     void playSlaps(PalmData& palm, Avatar* avatar);
 };
 

interface/src/avatar/Head.cpp

@@ -168,8 +168,8 @@ void Head::simulate(float deltaTime, bool isMine, bool billboard) {
     _eyePosition = calculateAverageEyePosition();
 }
 
-void Head::render(float alpha) {
-    if (_faceModel.render(alpha) && _renderLookatVectors) {
+void Head::render(float alpha, bool forShadowMap) {
+    if (_faceModel.render(alpha, forShadowMap) && _renderLookatVectors) {
         renderLookatVectors(_leftEyePosition, _rightEyePosition, _lookAtPosition);
     }
 }

interface/src/avatar/Head.h

@@ -37,7 +37,7 @@ public:
     void init();
     void reset();
     void simulate(float deltaTime, bool isMine, bool billboard = false);
-    void render(float alpha);
+    void render(float alpha, bool forShadowMap);
     void setScale(float scale);
     void setPosition(glm::vec3 position) { _position = position; }
     void setGravity(glm::vec3 gravity) { _gravity = gravity; }

interface/src/avatar/MyAvatar.cpp

@@ -26,7 +26,6 @@
 #include "Menu.h"
 #include "MyAvatar.h"
 #include "Physics.h"
-#include "VoxelSystem.h"
 #include "devices/Faceshift.h"
 #include "devices/OculusManager.h"
 #include "ui/TextRenderer.h"
@@ -85,6 +84,7 @@ void MyAvatar::reset() {
 
     setVelocity(glm::vec3(0,0,0));
     setThrust(glm::vec3(0,0,0));
+    setOrientation(glm::quat(glm::vec3(0,0,0)));
 }
 
 void MyAvatar::setMoveTarget(const glm::vec3 moveTarget) {
@@ -427,11 +427,6 @@ void MyAvatar::updateFromGyros(float deltaTime) {
     }
 }
 
-static TextRenderer* textRenderer() {
-    static TextRenderer* renderer = new TextRenderer(SANS_FONT_FAMILY, 24, -1, false, TextRenderer::SHADOW_EFFECT);
-    return renderer;
-}
-
 void MyAvatar::renderDebugBodyPoints() {
     glm::vec3 torsoPosition(getPosition());
     glm::vec3 headPosition(getHead()->getEyePosition());
@@ -459,12 +454,12 @@ void MyAvatar::renderDebugBodyPoints() {
 }
 
 // virtual
-void MyAvatar::render(const glm::vec3& cameraPosition, bool forShadowMapOrMirror) {
+void MyAvatar::render(const glm::vec3& cameraPosition, RenderMode renderMode) {
     // don't render if we've been asked to disable local rendering
     if (!_shouldRender) {
         return; // exit early
     }
-    Avatar::render(cameraPosition, forShadowMapOrMirror);
+    Avatar::render(cameraPosition, renderMode);
 }
 
 void MyAvatar::renderHeadMouse() const {
@@ -559,6 +554,14 @@ void MyAvatar::loadData(QSettings* settings) {
     settings->endGroup();
 }
 
+int MyAvatar::parseDataAtOffset(const QByteArray& packet, int offset) {
+    qDebug() << "Error: ignoring update packet for MyAvatar"
+        << " packetLength = " << packet.size() 
+        << "  offset = " << offset;
+    // this packet is just bad, so we pretend that we unpacked it ALL
+    return packet.size() - offset;
+}
+
 void MyAvatar::sendKillAvatar() {
     QByteArray killPacket = byteArrayWithPopulatedHeader(PacketTypeKillAvatar);
     NodeList::getInstance()->broadcastToNodes(killPacket, NodeSet() << NodeType::AvatarMixer);
@@ -590,16 +593,15 @@ void MyAvatar::updateLookAtTargetAvatar() {
 
         foreach (const AvatarSharedPointer& avatarPointer, Application::getInstance()->getAvatarManager().getAvatarHash()) {
             Avatar* avatar = static_cast<Avatar*>(avatarPointer.data());
-            if (avatar == static_cast<Avatar*>(this)) {
-                continue;
-            }
             float distance;
             if (avatar->findRayIntersection(mouseOrigin, mouseDirection, distance)) {
                 _lookAtTargetAvatar = avatarPointer;
+                _targetAvatarPosition = avatarPointer->getPosition();
                 return;
             }
         }
         _lookAtTargetAvatar.clear();
+        _targetAvatarPosition = glm::vec3(0, 0, 0);
     }
 }
 
@@ -640,20 +642,20 @@ void MyAvatar::setSkeletonModelURL(const QUrl& skeletonModelURL) {
     _billboardValid = false;
 }
 
-void MyAvatar::renderBody(bool forceRenderHead) {
+void MyAvatar::renderBody(RenderMode renderMode) {
     if (!(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
         return; // wait until both models are loaded
     }
     
     //  Render the body's voxels and head
-    _skeletonModel.render(1.0f);
+    _skeletonModel.render(1.0f, renderMode == SHADOW_RENDER_MODE);
 
     //  Render head so long as the camera isn't inside it
     const float RENDER_HEAD_CUTOFF_DISTANCE = 0.40f;
     Camera* myCamera = Application::getInstance()->getCamera();
-    if (forceRenderHead || (glm::length(myCamera->getPosition() - getHead()->calculateAverageEyePosition()) >
+    if (renderMode != NORMAL_RENDER_MODE || (glm::length(myCamera->getPosition() - getHead()->calculateAverageEyePosition()) >
             RENDER_HEAD_CUTOFF_DISTANCE * _scale)) {
-        getHead()->render(1.0f);
+        getHead()->render(1.0f, renderMode == SHADOW_RENDER_MODE);
     }
     getHand()->render(true);
 }
@@ -1138,9 +1140,9 @@ void MyAvatar::goToLocationFromResponse(const QJsonObject& jsonObject) {
         NodeList::getInstance()->getDomainInfo().setHostname(domainHostnameString);
         
         // orient the user to face the target
-        glm::quat newOrientation = glm::quat(glm::vec3(orientationItems[0].toFloat(),
-                                                       orientationItems[1].toFloat(),
-                                                       orientationItems[2].toFloat()))
+        glm::quat newOrientation = glm::quat(glm::radians(glm::vec3(orientationItems[0].toFloat(),
+                                                                    orientationItems[1].toFloat(),
+                                                                    orientationItems[2].toFloat())))
             * glm::angleAxis(PI, glm::vec3(0.0f, 1.0f, 0.0f));
         setOrientation(newOrientation);
         

interface/src/avatar/MyAvatar.h

@@ -35,8 +35,8 @@ public:
     void simulate(float deltaTime);
     void updateFromGyros(float deltaTime);
 
-    void render(const glm::vec3& cameraPosition, bool forShadowMapOrMirror = false);
-    void renderBody(bool forceRenderHead);
+    void render(const glm::vec3& cameraPosition, RenderMode renderMode = NORMAL_RENDER_MODE);
+    void renderBody(RenderMode renderMode);
     void renderDebugBodyPoints();
     void renderHeadMouse() const;
 
@@ -71,11 +71,14 @@ public:
     void jump() { _shouldJump = true; };
     
     bool isMyAvatar() { return true; }
+
+    virtual int parseDataAtOffset(const QByteArray& packet, int offset);
     
     static void sendKillAvatar();
 
     void orbit(const glm::vec3& position, int deltaX, int deltaY);
 
+    Q_INVOKABLE glm::vec3 getTargetAvatarPosition() const { return _targetAvatarPosition; }
     AvatarData* getLookAtTargetAvatar() const { return _lookAtTargetAvatar.data(); }
     void updateLookAtTargetAvatar();
     void clearLookAtTargetAvatar();
@@ -116,6 +119,7 @@ private:
     glm::vec3 _moveTarget;
     int _moveTargetStepCounter;
     QWeakPointer<AvatarData> _lookAtTargetAvatar;
+    glm::vec3 _targetAvatarPosition;
     bool _shouldRender;
 
     bool _billboardValid;

interface/src/avatar/SkeletonModel.cpp

@@ -75,17 +75,6 @@ void SkeletonModel::syncToPalms() {
     }
 }
 
-bool SkeletonModel::render(float alpha) {
-
-    if (_jointStates.isEmpty()) {
-        return false;
-    }
-
-    Model::render(alpha);
-
-    return true;
-}
-
 void SkeletonModel::getHandShapes(int jointIndex, QVector<const Shape*>& shapes) const {
     if (jointIndex < 0 || jointIndex >= int(_shapes.size())) {
         return;
@@ -153,7 +142,7 @@ void SkeletonModel::applyPalmData(int jointIndex, const QVector<int>& fingerJoin
             direction += fingerVector / length;
         }
         fingerVector = glm::inverse(palmRotation) * fingerVector * -sign;
-        IndexValue indexValue = { i, atan2f(fingerVector.z, fingerVector.x) };
+        IndexValue indexValue = { int(i), atan2f(fingerVector.z, fingerVector.x) };
         fingerIndices.append(indexValue);
     }
     qSort(fingerIndices.begin(), fingerIndices.end());

interface/src/avatar/SkeletonModel.h

@@ -24,7 +24,6 @@ public:
     
     void simulate(float deltaTime, bool fullUpdate = true);
     void syncToPalms();
-    bool render(float alpha);
 
     /// \param jointIndex index of hand joint
     /// \param shapes[out] list in which is stored pointers to hand shapes

interface/src/devices/Faceshift.cpp

@@ -103,7 +103,7 @@ void Faceshift::reset() {
 }
 
 void Faceshift::updateFakeCoefficients(float leftBlink, float rightBlink, float browUp,
-        float jawOpen, std::vector<float>& coefficients) const {
+        float jawOpen, QVector<float>& coefficients) const {
     coefficients.resize(max((int)coefficients.size(), _jawOpenIndex + 1));
     qFill(coefficients.begin(), coefficients.end(), 0.0f);
     coefficients[_leftBlinkIndex] = leftBlink;
@@ -204,7 +204,7 @@ void Faceshift::receive(const QByteArray& buffer) {
                     _eyeGazeLeftYaw = data.m_eyeGazeLeftYaw;
                     _eyeGazeRightPitch = -data.m_eyeGazeRightPitch;
                     _eyeGazeRightYaw = data.m_eyeGazeRightYaw;
-                    _blendshapeCoefficients = data.m_coeffs;
+                    _blendshapeCoefficients = QVector<float>::fromStdVector(data.m_coeffs);
 
                     _lastTrackingStateReceived = usecTimestampNow();
                 }

interface/src/devices/Faceshift.h

@@ -9,8 +9,6 @@
 #ifndef __interface__Faceshift__
 #define __interface__Faceshift__
 
-#include <vector>
-
 #include <QTcpSocket>
 #include <QUdpSocket>
 
@@ -47,7 +45,7 @@ public:
     float getEstimatedEyePitch() const { return _estimatedEyePitch; }
     float getEstimatedEyeYaw() const { return _estimatedEyeYaw; }
 
-    const std::vector<float>& getBlendshapeCoefficients() const { return _blendshapeCoefficients; }
+    const QVector<float>& getBlendshapeCoefficients() const { return _blendshapeCoefficients; }
 
     float getLeftBlink() const { return getBlendshapeCoefficient(_leftBlinkIndex); }
     float getRightBlink() const { return getBlendshapeCoefficient(_rightBlinkIndex); }
@@ -68,7 +66,7 @@ public:
     void reset();
     
     void updateFakeCoefficients(float leftBlink, float rightBlink, float browUp,
-        float jawOpen, std::vector<float>& coefficients) const;
+        float jawOpen, QVector<float>& coefficients) const;
     
 signals:
 
@@ -111,7 +109,7 @@ private:
     float _eyeGazeRightPitch;
     float _eyeGazeRightYaw;
     
-    std::vector<float> _blendshapeCoefficients;
+    QVector<float> _blendshapeCoefficients;
     
     int _leftBlinkIndex;
     int _rightBlinkIndex;

interface/src/devices/Visage.h

@@ -9,8 +9,6 @@
 #ifndef __interface__Visage__
 #define __interface__Visage__
 
-#include <vector>
-
 #include <QMultiHash>
 #include <QPair>
 #include <QVector>
@@ -42,7 +40,7 @@ public:
     float getEstimatedEyePitch() const { return _estimatedEyePitch; }
     float getEstimatedEyeYaw() const { return _estimatedEyeYaw; }
     
-    const std::vector<float>& getBlendshapeCoefficients() const { return _blendshapeCoefficients; }
+    const QVector<float>& getBlendshapeCoefficients() const { return _blendshapeCoefficients; }
     
     void update();
     void reset();
@@ -71,7 +69,7 @@ private:
     float _estimatedEyePitch;
     float _estimatedEyeYaw;
     
-    std::vector<float> _blendshapeCoefficients;
+    QVector<float> _blendshapeCoefficients;
 };
 
 #endif /* defined(__interface__Visage__) */

interface/src/renderer/FBXReader.cpp

@@ -54,6 +54,15 @@ QStringList FBXGeometry::getJointNames() const {
     return names;
 }
 
+bool FBXGeometry::hasBlendedMeshes() const {
+    foreach (const FBXMesh& mesh, meshes) {
+        if (!mesh.blendshapes.isEmpty()) {
+            return true;
+        }
+    }
+    return false;
+}
+
 static int fbxGeometryMetaTypeId = qRegisterMetaType<FBXGeometry>();
 
 template<class T> QVariant readBinaryArray(QDataStream& in) {
@@ -1331,14 +1340,11 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping)
     geometry.staticExtents.reset();
     geometry.meshExtents.reset();
     
-    QVariantHash springs = mapping.value("spring").toHash();
-    QVariant defaultSpring = springs.value("default");
     for (QHash<QString, ExtractedMesh>::iterator it = meshes.begin(); it != meshes.end(); it++) {
         ExtractedMesh& extracted = it.value();
 
         // accumulate local transforms
         QString modelID = models.contains(it.key()) ? it.key() : parentMap.value(it.key());
-        extracted.mesh.springiness = springs.value(models.value(modelID).name, defaultSpring).toFloat();
         glm::mat4 modelTransform = getGlobalTransform(parentMap, models, modelID);
 
         // compute the mesh extents from the transformed vertices
@@ -1591,49 +1597,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping)
             }
         }
         extracted.mesh.isEye = (maxJointIndex == geometry.leftEyeJointIndex || maxJointIndex == geometry.rightEyeJointIndex);
-
-        // extract spring edges, connections if springy
-        if (extracted.mesh.springiness > 0.0f) {
-            QSet<QPair<int, int> > edges;
-
-            extracted.mesh.vertexConnections.resize(extracted.mesh.vertices.size());
-            foreach (const FBXMeshPart& part, extracted.mesh.parts) {
-                for (int i = 0; i < part.quadIndices.size(); i += 4) {
-                    int index0 = part.quadIndices.at(i);
-                    int index1 = part.quadIndices.at(i + 1);
-                    int index2 = part.quadIndices.at(i + 2);
-                    int index3 = part.quadIndices.at(i + 3);
-
-                    edges.insert(QPair<int, int>(qMin(index0, index1), qMax(index0, index1)));
-                    edges.insert(QPair<int, int>(qMin(index1, index2), qMax(index1, index2)));
-                    edges.insert(QPair<int, int>(qMin(index2, index3), qMax(index2, index3)));
-                    edges.insert(QPair<int, int>(qMin(index3, index0), qMax(index3, index0)));
-
-                    extracted.mesh.vertexConnections[index0].append(QPair<int, int>(index3, index1));
-                    extracted.mesh.vertexConnections[index1].append(QPair<int, int>(index0, index2));
-                    extracted.mesh.vertexConnections[index2].append(QPair<int, int>(index1, index3));
-                    extracted.mesh.vertexConnections[index3].append(QPair<int, int>(index2, index0));
-                }
-                for (int i = 0; i < part.triangleIndices.size(); i += 3) {
-                    int index0 = part.triangleIndices.at(i);
-                    int index1 = part.triangleIndices.at(i + 1);
-                    int index2 = part.triangleIndices.at(i + 2);
-
-                    edges.insert(QPair<int, int>(qMin(index0, index1), qMax(index0, index1)));
-                    edges.insert(QPair<int, int>(qMin(index1, index2), qMax(index1, index2)));
-                    edges.insert(QPair<int, int>(qMin(index2, index0), qMax(index2, index0)));
-
-                    extracted.mesh.vertexConnections[index0].append(QPair<int, int>(index2, index1));
-                    extracted.mesh.vertexConnections[index1].append(QPair<int, int>(index0, index2));
-                    extracted.mesh.vertexConnections[index2].append(QPair<int, int>(index1, index0));
-                }
-            }
-
-            for (QSet<QPair<int, int> >::const_iterator edge = edges.constBegin(); edge != edges.constEnd(); edge++) {
-                extracted.mesh.springEdges.append(*edge);
-            }
-        }
-
+        
         geometry.meshes.append(extracted.mesh);
     }
 
@@ -1797,7 +1761,6 @@ FBXGeometry readSVO(const QByteArray& model) {
     // and one mesh with one cluster and one part
     FBXMesh mesh;
     mesh.isEye = false;
-    mesh.springiness = 0.0f;
 
     FBXCluster cluster = { 0 };
     mesh.clusters.append(cluster);

interface/src/renderer/FBXReader.h

@@ -130,10 +130,6 @@ public:
     bool isEye;
     
     QVector<FBXBlendshape> blendshapes;
-    
-    float springiness;
-    QVector<QPair<int, int> > springEdges;
-    QVector<QVarLengthArray<QPair<int, int>, 4> > vertexConnections;
 };
 
 /// An attachment to an FBX document.
@@ -185,6 +181,8 @@ public:
     
     int getJointIndex(const QString& name) const { return jointIndices.value(name) - 1; }
     QStringList getJointNames() const;
+    
+    bool hasBlendedMeshes() const;
 };
 
 Q_DECLARE_METATYPE(FBXGeometry)

interface/src/renderer/GeometryCache.cpp

@@ -13,6 +13,7 @@
 
 #include "Application.h"
 #include "GeometryCache.h"
+#include "Model.h"
 #include "world.h"
 
 GeometryCache::~GeometryCache() {
@@ -291,6 +292,13 @@ QSharedPointer<NetworkGeometry> GeometryCache::getGeometry(const QUrl& url, cons
     return getResource(url, fallback, delayLoad).staticCast<NetworkGeometry>();
 }
 
+void GeometryCache::setBlendedVertices(const QPointer<Model>& model, const QWeakPointer<NetworkGeometry>& geometry,
+        const QVector<glm::vec3>& vertices, const QVector<glm::vec3>& normals) {
+    if (!model.isNull() && model->getGeometry() == geometry) {
+        model->setBlendedVertices(vertices, normals);
+    }
+}
+
 QSharedPointer<Resource> GeometryCache::createResource(const QUrl& url,
         const QSharedPointer<Resource>& fallback, bool delayLoad, const void* extra) {
     
@@ -565,8 +573,8 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
         networkMesh.vertexBuffer.bind();
         networkMesh.vertexBuffer.setUsagePattern(QOpenGLBuffer::StaticDraw);
         
-        // if we don't need to do any blending or springing, then the positions/normals can be static
-        if (mesh.blendshapes.isEmpty() && mesh.springiness == 0.0f) {
+        // if we don't need to do any blending, the positions/normals can be static
+        if (mesh.blendshapes.isEmpty()) {
             int normalsOffset = mesh.vertices.size() * sizeof(glm::vec3);
             int tangentsOffset = normalsOffset + mesh.normals.size() * sizeof(glm::vec3);
             int colorsOffset = tangentsOffset + mesh.tangents.size() * sizeof(glm::vec3);
@@ -587,8 +595,8 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
             networkMesh.vertexBuffer.write(clusterWeightsOffset, mesh.clusterWeights.constData(),
                 mesh.clusterWeights.size() * sizeof(glm::vec4));
         
-        // if there's no springiness, then the cluster indices/weights can be static
-        } else if (mesh.springiness == 0.0f) {
+        // otherwise, at least the cluster indices/weights can be static
+        } else {
             int colorsOffset = mesh.tangents.size() * sizeof(glm::vec3);
             int texCoordsOffset = colorsOffset + mesh.colors.size() * sizeof(glm::vec3);
             int clusterIndicesOffset = texCoordsOffset + mesh.texCoords.size() * sizeof(glm::vec2);
@@ -601,16 +609,7 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
             networkMesh.vertexBuffer.write(clusterIndicesOffset, mesh.clusterIndices.constData(),
                 mesh.clusterIndices.size() * sizeof(glm::vec4));
             networkMesh.vertexBuffer.write(clusterWeightsOffset, mesh.clusterWeights.constData(),
-                mesh.clusterWeights.size() * sizeof(glm::vec4));
-            
-        } else {
-            int colorsOffset = mesh.tangents.size() * sizeof(glm::vec3);
-            int texCoordsOffset = colorsOffset + mesh.colors.size() * sizeof(glm::vec3);
-            networkMesh.vertexBuffer.allocate(texCoordsOffset + mesh.texCoords.size() * sizeof(glm::vec2));
-            networkMesh.vertexBuffer.write(0, mesh.tangents.constData(), mesh.tangents.size() * sizeof(glm::vec3));
-            networkMesh.vertexBuffer.write(colorsOffset, mesh.colors.constData(), mesh.colors.size() * sizeof(glm::vec3));
-            networkMesh.vertexBuffer.write(texCoordsOffset, mesh.texCoords.constData(),
-                mesh.texCoords.size() * sizeof(glm::vec2));
+                mesh.clusterWeights.size() * sizeof(glm::vec4));   
         }
         
         networkMesh.vertexBuffer.release();

interface/src/renderer/GeometryCache.h

@@ -19,15 +19,18 @@
 
 #include "FBXReader.h"
 
+class Model;
 class NetworkGeometry;
 class NetworkMesh;
 class NetworkTexture;
 
 /// Stores cached geometry.
 class GeometryCache : public ResourceCache {
+    Q_OBJECT
+
 public:
     
-    ~GeometryCache();
+    virtual ~GeometryCache();
     
     void renderHemisphere(int slices, int stacks);
     void renderSquare(int xDivisions, int yDivisions);
@@ -38,7 +41,12 @@ public:
     /// \param fallback a fallback URL to load if the desired one is unavailable
     /// \param delayLoad if true, don't load the geometry immediately; wait until load is first requested
     QSharedPointer<NetworkGeometry> getGeometry(const QUrl& url, const QUrl& fallback = QUrl(), bool delayLoad = false);
-    
+
+public slots:
+
+    void setBlendedVertices(const QPointer<Model>& model, const QWeakPointer<NetworkGeometry>& geometry,
+        const QVector<glm::vec3>& vertices, const QVector<glm::vec3>& normals);
+
 protected:
 
     virtual QSharedPointer<Resource> createResource(const QUrl& url,

interface/src/renderer/Model.cpp

@@ -6,6 +6,10 @@
 //  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
 //
 
+#include <QMetaType>
+#include <QRunnable>
+#include <QThreadPool>
+
 #include <glm/gtx/transform.hpp>
 #include <glm/gtx/norm.hpp>
 
@@ -20,6 +24,10 @@
 
 using namespace std;
 
+static int modelPointerTypeId = qRegisterMetaType<QPointer<Model> >();
+static int weakNetworkGeometryPointerTypeId = qRegisterMetaType<QWeakPointer<NetworkGeometry> >();
+static int vec3VectorTypeId = qRegisterMetaType<QVector<glm::vec3> >();
+
 Model::Model(QObject* parent) :
     QObject(parent),
     _scale(1.0f, 1.0f, 1.0f),
@@ -37,11 +45,14 @@ Model::~Model() {
 
 ProgramObject Model::_program;
 ProgramObject Model::_normalMapProgram;
+ProgramObject Model::_shadowProgram;
 ProgramObject Model::_skinProgram;
 ProgramObject Model::_skinNormalMapProgram;
+ProgramObject Model::_skinShadowProgram;
 int Model::_normalMapTangentLocation;
 Model::SkinLocations Model::_skinLocations;
 Model::SkinLocations Model::_skinNormalMapLocations;
+Model::SkinLocations Model::_skinShadowLocations;
 
 void Model::initSkinProgram(ProgramObject& program, Model::SkinLocations& locations) {
     program.bind();
@@ -87,6 +98,11 @@ void Model::init() {
         _normalMapTangentLocation = _normalMapProgram.attributeLocation("tangent");
         _normalMapProgram.release();
         
+        _shadowProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() + "shaders/model_shadow.vert");
+        _shadowProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath() +
+            "shaders/model_shadow.frag");
+        _shadowProgram.link();
+        
         _skinProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath()
                                              + "shaders/skin_model.vert");
         _skinProgram.addShaderFromSourceFile(QGLShader::Fragment, Application::resourcesPath()
@@ -102,12 +118,18 @@ void Model::init() {
         _skinNormalMapProgram.link();
         
         initSkinProgram(_skinNormalMapProgram, _skinNormalMapLocations);
+        
+        _skinShadowProgram.addShaderFromSourceFile(QGLShader::Vertex,
+            Application::resourcesPath() + "shaders/skin_model_shadow.vert");
+        _skinShadowProgram.addShaderFromSourceFile(QGLShader::Fragment,
+            Application::resourcesPath() + "shaders/model_shadow.frag");
+        _skinShadowProgram.link();
+        
+        initSkinProgram(_skinShadowProgram, _skinShadowLocations);
     }
 }
 
 void Model::reset() {
-    _resetStates = true;
-    
     foreach (Model* attachment, _attachments) {
         attachment->reset();
     }
@@ -169,7 +191,7 @@ void Model::simulate(float deltaTime, bool fullUpdate) {
     simulate(deltaTime, fullUpdate, updateGeometry());
 }
 
-bool Model::render(float alpha) {
+bool Model::render(float alpha, bool forShadowMap) {
     // render the attachments
     foreach (Model* attachment, _attachments) {
         attachment->render(alpha);
@@ -178,20 +200,10 @@ bool Model::render(float alpha) {
         return false;
     }
     
-    // set up blended buffer ids on first render after load/simulate
+    // set up dilated textures on first render after load/simulate
     const FBXGeometry& geometry = _geometry->getFBXGeometry();
-    if (_blendedVertexBufferIDs.isEmpty()) {
+    if (_dilatedTextures.isEmpty()) {
         foreach (const FBXMesh& mesh, geometry.meshes) {
-            GLuint id = 0;
-            if (!mesh.blendshapes.isEmpty() || mesh.springiness > 0.0f) {
-                glGenBuffers(1, &id);
-                glBindBuffer(GL_ARRAY_BUFFER, id);
-                glBufferData(GL_ARRAY_BUFFER, (mesh.vertices.size() + mesh.normals.size()) * sizeof(glm::vec3),
-                    NULL, GL_DYNAMIC_DRAW);
-                glBindBuffer(GL_ARRAY_BUFFER, 0);
-            }
-            _blendedVertexBufferIDs.append(id);
-            
             QVector<QSharedPointer<Texture> > dilated;
             dilated.resize(mesh.parts.size());
             _dilatedTextures.append(dilated);
@@ -210,13 +222,13 @@ bool Model::render(float alpha) {
     glEnable(GL_ALPHA_TEST);
     glAlphaFunc(GL_GREATER, 0.5f * alpha);
     
-    renderMeshes(alpha, false);
+    renderMeshes(alpha, forShadowMap, false);
     
     glDisable(GL_ALPHA_TEST);
     
     // render translucent meshes afterwards, with back face culling
     
-    renderMeshes(alpha, true);
+    renderMeshes(alpha, forShadowMap, true);
     
     glDisable(GL_CULL_FACE);
     
@@ -470,6 +482,68 @@ QVector<Model::JointState> Model::updateGeometry() {
     return newJointStates;
 }
 
+class Blender : public QRunnable {
+public:
+
+    Blender(Model* model, const QWeakPointer<NetworkGeometry>& geometry,
+        const QVector<FBXMesh>& meshes, const QVector<float>& blendshapeCoefficients);
+    
+    virtual void run();
+
+private:
+    
+    QPointer<Model> _model;
+    QWeakPointer<NetworkGeometry> _geometry;
+    QVector<FBXMesh> _meshes;
+    QVector<float> _blendshapeCoefficients;
+};
+
+Blender::Blender(Model* model, const QWeakPointer<NetworkGeometry>& geometry,
+        const QVector<FBXMesh>& meshes, const QVector<float>& blendshapeCoefficients) :
+    _model(model),
+    _geometry(geometry),
+    _meshes(meshes),
+    _blendshapeCoefficients(blendshapeCoefficients) {
+}
+
+void Blender::run() {
+    // make sure the model/geometry still exists
+    if (_model.isNull() || _geometry.isNull()) {
+        return;
+    }
+    QVector<glm::vec3> vertices, normals;
+    int offset = 0;
+    foreach (const FBXMesh& mesh, _meshes) {
+        if (mesh.blendshapes.isEmpty()) {
+            continue;
+        }
+        vertices += mesh.vertices;
+        normals += mesh.normals;
+        glm::vec3* meshVertices = vertices.data() + offset;
+        glm::vec3* meshNormals = normals.data() + offset;
+        offset += mesh.vertices.size();
+        const float NORMAL_COEFFICIENT_SCALE = 0.01f;
+        for (int i = 0, n = qMin(_blendshapeCoefficients.size(), mesh.blendshapes.size()); i < n; i++) {
+            float vertexCoefficient = _blendshapeCoefficients.at(i);
+            if (vertexCoefficient < EPSILON) {
+                continue;
+            }
+            float normalCoefficient = vertexCoefficient * NORMAL_COEFFICIENT_SCALE;
+            const FBXBlendshape& blendshape = mesh.blendshapes.at(i);
+            for (int j = 0; j < blendshape.indices.size(); j++) {
+                int index = blendshape.indices.at(j);
+                meshVertices[index] += blendshape.vertices.at(j) * vertexCoefficient;
+                meshNormals[index] += blendshape.normals.at(j) * normalCoefficient;
+            }
+        }
+    }
+    
+    // post the result to the geometry cache, which will dispatch to the model if still alive
+    QMetaObject::invokeMethod(Application::getInstance()->getGeometryCache(), "setBlendedVertices",
+        Q_ARG(const QPointer<Model>&, _model), Q_ARG(const QWeakPointer<NetworkGeometry>&, _geometry),
+        Q_ARG(const QVector<glm::vec3>&, vertices), Q_ARG(const QVector<glm::vec3>&, normals));
+}
+
 void Model::simulate(float deltaTime, bool fullUpdate, const QVector<JointState>& newJointStates) {
     if (!isActive()) {
         return;
@@ -482,12 +556,20 @@ void Model::simulate(float deltaTime, bool fullUpdate, const QVector<JointState>
         foreach (const FBXMesh& mesh, geometry.meshes) {
             MeshState state;
             state.clusterMatrices.resize(mesh.clusters.size());
-            if (mesh.springiness > 0.0f) {
-                state.worldSpaceVertices.resize(mesh.vertices.size());
-                state.vertexVelocities.resize(mesh.vertices.size());
-                state.worldSpaceNormals.resize(mesh.vertices.size());
-            }
             _meshStates.append(state);    
+            
+            QOpenGLBuffer buffer;
+            if (!mesh.blendshapes.isEmpty()) {
+                buffer.setUsagePattern(QOpenGLBuffer::DynamicDraw);
+                buffer.create();
+                buffer.bind();
+                buffer.allocate((mesh.vertices.size() + mesh.normals.size()) * sizeof(glm::vec3));
+                buffer.write(0, mesh.vertices.constData(), mesh.vertices.size() * sizeof(glm::vec3));
+                buffer.write(mesh.vertices.size() * sizeof(glm::vec3), mesh.normals.constData(),
+                    mesh.normals.size() * sizeof(glm::vec3));
+                buffer.release();
+            }
+            _blendedVertexBuffers.append(buffer);
         }
         foreach (const FBXAttachment& attachment, geometry.attachments) {
             Model* model = new Model(this);
@@ -495,12 +577,12 @@ void Model::simulate(float deltaTime, bool fullUpdate, const QVector<JointState>
             model->setURL(attachment.url);
             _attachments.append(model);
         }
-        _resetStates = fullUpdate = true;
+        fullUpdate = true;
         createCollisionShapes();
     }
     
     // exit early if we don't have to perform a full update
-    if (!(fullUpdate || _resetStates)) {
+    if (!fullUpdate) {
         return;
     }
     
@@ -533,82 +615,12 @@ void Model::simulate(float deltaTime, bool fullUpdate, const QVector<JointState>
             const FBXCluster& cluster = mesh.clusters.at(j);
             state.clusterMatrices[j] = _jointStates[cluster.jointIndex].transform * cluster.inverseBindMatrix;
         }
-        int vertexCount = state.worldSpaceVertices.size();
-        if (vertexCount == 0) {
-            continue;
-        }
-        glm::vec3* destVertices = state.worldSpaceVertices.data();
-        glm::vec3* destVelocities = state.vertexVelocities.data();
-        glm::vec3* destNormals = state.worldSpaceNormals.data();
-        
-        const glm::vec3* sourceVertices = mesh.vertices.constData();
-        if (!mesh.blendshapes.isEmpty()) {
-            _blendedVertices.resize(max(_blendedVertices.size(), vertexCount));
-            memcpy(_blendedVertices.data(), mesh.vertices.constData(), vertexCount * sizeof(glm::vec3));
-            
-            // blend in each coefficient
-            for (unsigned int j = 0; j < _blendshapeCoefficients.size(); j++) {
-                float coefficient = _blendshapeCoefficients[j];
-                if (coefficient == 0.0f || j >= (unsigned int)mesh.blendshapes.size() || mesh.blendshapes[j].vertices.isEmpty()) {
-                    continue;
-                }
-                const glm::vec3* vertex = mesh.blendshapes[j].vertices.constData();
-                for (const int* index = mesh.blendshapes[j].indices.constData(),
-                        *end = index + mesh.blendshapes[j].indices.size(); index != end; index++, vertex++) {
-                    _blendedVertices[*index] += *vertex * coefficient;
-                }
-            }
-            sourceVertices = _blendedVertices.constData();
-        }
-        glm::mat4 transform = glm::translate(_translation);
-        if (mesh.clusters.size() > 1) {
-            _blendedVertices.resize(max(_blendedVertices.size(), vertexCount));
-
-            // skin each vertex
-            const glm::vec4* clusterIndices = mesh.clusterIndices.constData();
-            const glm::vec4* clusterWeights = mesh.clusterWeights.constData();
-            for (int j = 0; j < vertexCount; j++) {
-                _blendedVertices[j] =
-                    glm::vec3(state.clusterMatrices[clusterIndices[j][0]] *
-                        glm::vec4(sourceVertices[j], 1.0f)) * clusterWeights[j][0] +
-                    glm::vec3(state.clusterMatrices[clusterIndices[j][1]] *
-                        glm::vec4(sourceVertices[j], 1.0f)) * clusterWeights[j][1] +
-                    glm::vec3(state.clusterMatrices[clusterIndices[j][2]] *
-                        glm::vec4(sourceVertices[j], 1.0f)) * clusterWeights[j][2] +
-                    glm::vec3(state.clusterMatrices[clusterIndices[j][3]] *
-                        glm::vec4(sourceVertices[j], 1.0f)) * clusterWeights[j][3];
-            }
-            sourceVertices = _blendedVertices.constData();
-            
-        } else {
-            transform = state.clusterMatrices[0];
-        }
-        if (_resetStates) {
-            for (int j = 0; j < vertexCount; j++) {
-                destVertices[j] = glm::vec3(transform * glm::vec4(sourceVertices[j], 1.0f));        
-                destVelocities[j] = glm::vec3();
-            }        
-        } else {
-            const float SPRINGINESS_MULTIPLIER = 200.0f;
-            const float DAMPING = 5.0f;
-            for (int j = 0; j < vertexCount; j++) {
-                destVelocities[j] += ((glm::vec3(transform * glm::vec4(sourceVertices[j], 1.0f)) - destVertices[j]) *
-                    mesh.springiness * SPRINGINESS_MULTIPLIER - destVelocities[j] * DAMPING) * deltaTime;
-                destVertices[j] += destVelocities[j] * deltaTime;
-            }
-        }
-        for (int j = 0; j < vertexCount; j++) {
-            destNormals[j] = glm::vec3();
-            
-            const glm::vec3& middle = destVertices[j];
-            for (QVarLengthArray<QPair<int, int>, 4>::const_iterator connection = mesh.vertexConnections.at(j).constBegin(); 
-                    connection != mesh.vertexConnections.at(j).constEnd(); connection++) {
-                destNormals[j] += glm::normalize(glm::cross(destVertices[connection->second] - middle,
-                    destVertices[connection->first] - middle));
-            }
-        }
     }
-    _resetStates = false;
+    
+    // post the blender
+    if (geometry.hasBlendedMeshes()) {
+        QThreadPool::globalInstance()->start(new Blender(this, _geometry, geometry.meshes, _blendshapeCoefficients));
+    }
 }
 
 void Model::updateJointState(int index) {
@@ -907,6 +919,27 @@ void Model::applyCollision(CollisionInfo& collision) {
     }
 }
 
+void Model::setBlendedVertices(const QVector<glm::vec3>& vertices, const QVector<glm::vec3>& normals) {
+    if (_blendedVertexBuffers.isEmpty()) {
+        return;
+    }
+    const FBXGeometry& geometry = _geometry->getFBXGeometry();
+    int index = 0;
+    for (int i = 0; i < geometry.meshes.size(); i++) {
+        const FBXMesh& mesh = geometry.meshes.at(i);
+        if (mesh.blendshapes.isEmpty()) {
+            continue;
+        }
+        QOpenGLBuffer& buffer = _blendedVertexBuffers[i];
+        buffer.bind();
+        buffer.write(0, vertices.constData() + index, mesh.vertices.size() * sizeof(glm::vec3));
+        buffer.write(mesh.vertices.size() * sizeof(glm::vec3), normals.constData() + index,
+            mesh.normals.size() * sizeof(glm::vec3));
+        buffer.release();
+        index += mesh.vertices.size();
+    }
+}
+
 void Model::applyNextGeometry() {
     // delete our local geometry and custom textures
     deleteGeometry();
@@ -925,10 +958,7 @@ void Model::deleteGeometry() {
         delete attachment;
     }
     _attachments.clear();
-    foreach (GLuint id, _blendedVertexBufferIDs) {
-        glDeleteBuffers(1, &id);
-    }
-    _blendedVertexBufferIDs.clear();
+    _blendedVertexBuffers.clear();
     _jointStates.clear();
     _meshStates.clear();
     clearShapes();
@@ -938,7 +968,7 @@ void Model::deleteGeometry() {
     }
 }
 
-void Model::renderMeshes(float alpha, bool translucent) {
+void Model::renderMeshes(float alpha, bool forShadowMap, bool translucent) {
     const FBXGeometry& geometry = _geometry->getFBXGeometry();
     const QVector<NetworkMesh>& networkMeshes = _geometry->getMeshes();
     
@@ -963,7 +993,12 @@ void Model::renderMeshes(float alpha, bool translucent) {
         ProgramObject* program = &_program;
         ProgramObject* skinProgram = &_skinProgram;
         SkinLocations* skinLocations = &_skinLocations;
-        if (!mesh.tangents.isEmpty()) {
+        if (forShadowMap) {
+            program = &_shadowProgram;
+            skinProgram = &_skinShadowProgram;
+            skinLocations = &_skinShadowLocations;
+            
+        } else if (!mesh.tangents.isEmpty()) {
             program = &_normalMapProgram;
             skinProgram = &_skinNormalMapProgram;
             skinLocations = &_skinNormalMapLocations;
@@ -972,35 +1007,31 @@ void Model::renderMeshes(float alpha, bool translucent) {
         const MeshState& state = _meshStates.at(i);
         ProgramObject* activeProgram = program;
         int tangentLocation = _normalMapTangentLocation;
-        if (state.worldSpaceVertices.isEmpty()) {
-            glPushMatrix();
-            Application::getInstance()->loadTranslatedViewMatrix(_translation);
-            
-            if (state.clusterMatrices.size() > 1) {
-                skinProgram->bind();
-                glUniformMatrix4fvARB(skinLocations->clusterMatrices, state.clusterMatrices.size(), false,
-                    (const float*)state.clusterMatrices.constData());
-                int offset = (mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3) +
-                    mesh.texCoords.size() * sizeof(glm::vec2) +
-                    (mesh.blendshapes.isEmpty() ? vertexCount * 2 * sizeof(glm::vec3) : 0);
-                skinProgram->setAttributeBuffer(skinLocations->clusterIndices, GL_FLOAT, offset, 4);
-                skinProgram->setAttributeBuffer(skinLocations->clusterWeights, GL_FLOAT,
-                    offset + vertexCount * sizeof(glm::vec4), 4);
-                skinProgram->enableAttributeArray(skinLocations->clusterIndices);
-                skinProgram->enableAttributeArray(skinLocations->clusterWeights);
-                activeProgram = skinProgram;
-                tangentLocation = skinLocations->tangent;
-         
-            } else {    
-                glMultMatrixf((const GLfloat*)&state.clusterMatrices[0]);
-                program->bind();
-            }
-        } else {
+        glPushMatrix();
+        Application::getInstance()->loadTranslatedViewMatrix(_translation);
+        
+        if (state.clusterMatrices.size() > 1) {
+            skinProgram->bind();
+            glUniformMatrix4fvARB(skinLocations->clusterMatrices, state.clusterMatrices.size(), false,
+                (const float*)state.clusterMatrices.constData());
+            int offset = (mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3) +
+                mesh.texCoords.size() * sizeof(glm::vec2) +
+                (mesh.blendshapes.isEmpty() ? vertexCount * 2 * sizeof(glm::vec3) : 0);
+            skinProgram->setAttributeBuffer(skinLocations->clusterIndices, GL_FLOAT, offset, 4);
+            skinProgram->setAttributeBuffer(skinLocations->clusterWeights, GL_FLOAT,
+                offset + vertexCount * sizeof(glm::vec4), 4);
+            skinProgram->enableAttributeArray(skinLocations->clusterIndices);
+            skinProgram->enableAttributeArray(skinLocations->clusterWeights);
+            activeProgram = skinProgram;
+            tangentLocation = skinLocations->tangent;
+     
+        } else {    
+            glMultMatrixf((const GLfloat*)&state.clusterMatrices[0]);
             program->bind();
         }
 
-        if (mesh.blendshapes.isEmpty() && mesh.springiness == 0.0f) {
-            if (!mesh.tangents.isEmpty()) {
+        if (mesh.blendshapes.isEmpty()) {
+            if (!(mesh.tangents.isEmpty() || forShadowMap)) {
                 activeProgram->setAttributeBuffer(tangentLocation, GL_FLOAT, vertexCount * 2 * sizeof(glm::vec3), 3);
                 activeProgram->enableAttributeArray(tangentLocation);
             }
@@ -1010,46 +1041,13 @@ void Model::renderMeshes(float alpha, bool translucent) {
                 (mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3)));    
         
         } else {
-            if (!mesh.tangents.isEmpty()) {
+            if (!(mesh.tangents.isEmpty() || forShadowMap)) {
                 activeProgram->setAttributeBuffer(tangentLocation, GL_FLOAT, 0, 3);
                 activeProgram->enableAttributeArray(tangentLocation);
             }
             glColorPointer(3, GL_FLOAT, 0, (void*)(mesh.tangents.size() * sizeof(glm::vec3)));
             glTexCoordPointer(2, GL_FLOAT, 0, (void*)((mesh.tangents.size() + mesh.colors.size()) * sizeof(glm::vec3)));
-            glBindBuffer(GL_ARRAY_BUFFER, _blendedVertexBufferIDs.at(i));
-            
-            if (!state.worldSpaceVertices.isEmpty()) {
-                glBufferSubData(GL_ARRAY_BUFFER, 0, vertexCount * sizeof(glm::vec3), state.worldSpaceVertices.constData());
-                glBufferSubData(GL_ARRAY_BUFFER, vertexCount * sizeof(glm::vec3),
-                    vertexCount * sizeof(glm::vec3), state.worldSpaceNormals.constData());
-                
-            } else {
-                _blendedVertices.resize(max(_blendedVertices.size(), vertexCount));
-                _blendedNormals.resize(_blendedVertices.size());
-                memcpy(_blendedVertices.data(), mesh.vertices.constData(), vertexCount * sizeof(glm::vec3));
-                memcpy(_blendedNormals.data(), mesh.normals.constData(), vertexCount * sizeof(glm::vec3));
-                
-                // blend in each coefficient
-                for (unsigned int j = 0; j < _blendshapeCoefficients.size(); j++) {
-                    float coefficient = _blendshapeCoefficients[j];
-                    if (coefficient == 0.0f || j >= (unsigned int)mesh.blendshapes.size() || mesh.blendshapes[j].vertices.isEmpty()) {
-                        continue;
-                    }
-                    const float NORMAL_COEFFICIENT_SCALE = 0.01f;
-                    float normalCoefficient = coefficient * NORMAL_COEFFICIENT_SCALE;
-                    const glm::vec3* vertex = mesh.blendshapes[j].vertices.constData();
-                    const glm::vec3* normal = mesh.blendshapes[j].normals.constData();
-                    for (const int* index = mesh.blendshapes[j].indices.constData(),
-                            *end = index + mesh.blendshapes[j].indices.size(); index != end; index++, vertex++, normal++) {
-                        _blendedVertices[*index] += *vertex * coefficient;
-                        _blendedNormals[*index] += *normal * normalCoefficient;
-                    }
-                }
-        
-                glBufferSubData(GL_ARRAY_BUFFER, 0, vertexCount * sizeof(glm::vec3), _blendedVertices.constData());
-                glBufferSubData(GL_ARRAY_BUFFER, vertexCount * sizeof(glm::vec3),
-                    vertexCount * sizeof(glm::vec3), _blendedNormals.constData());
-            }
+            _blendedVertexBuffers[i].bind();
         }
         glVertexPointer(3, GL_FLOAT, 0, 0);
         glNormalPointer(GL_FLOAT, 0, (void*)(vertexCount * sizeof(glm::vec3)));
@@ -1072,31 +1070,33 @@ void Model::renderMeshes(float alpha, bool translucent) {
                 continue;
             }
             // apply material properties
-            glm::vec4 diffuse = glm::vec4(part.diffuseColor, alpha);
-            glm::vec4 specular = glm::vec4(part.specularColor, alpha);
-            glMaterialfv(GL_FRONT, GL_AMBIENT, (const float*)&diffuse);
-            glMaterialfv(GL_FRONT, GL_DIFFUSE, (const float*)&diffuse);
-            glMaterialfv(GL_FRONT, GL_SPECULAR, (const float*)&specular);
-            glMaterialf(GL_FRONT, GL_SHININESS, part.shininess);
-        
-            Texture* diffuseMap = networkPart.diffuseTexture.data();
-            if (mesh.isEye) {
-                if (diffuseMap) {
+            if (forShadowMap) {
+                glBindTexture(GL_TEXTURE_2D, 0);
+                
+            } else {
+                glm::vec4 diffuse = glm::vec4(part.diffuseColor, alpha);
+                glm::vec4 specular = glm::vec4(part.specularColor, alpha);
+                glMaterialfv(GL_FRONT, GL_AMBIENT, (const float*)&diffuse);
+                glMaterialfv(GL_FRONT, GL_DIFFUSE, (const float*)&diffuse);
+                glMaterialfv(GL_FRONT, GL_SPECULAR, (const float*)&specular);
+                glMaterialf(GL_FRONT, GL_SHININESS, part.shininess);
+            
+                Texture* diffuseMap = networkPart.diffuseTexture.data();
+                if (mesh.isEye && diffuseMap) {
                     diffuseMap = (_dilatedTextures[i][j] =
                         static_cast<DilatableNetworkTexture*>(diffuseMap)->getDilatedTexture(_pupilDilation)).data();
                 }
+                glBindTexture(GL_TEXTURE_2D, !diffuseMap ?
+                    Application::getInstance()->getTextureCache()->getWhiteTextureID() : diffuseMap->getID());
+                
+                if (!mesh.tangents.isEmpty()) {
+                    glActiveTexture(GL_TEXTURE1);                
+                    Texture* normalMap = networkPart.normalTexture.data();
+                    glBindTexture(GL_TEXTURE_2D, !normalMap ?
+                        Application::getInstance()->getTextureCache()->getBlueTextureID() : normalMap->getID());
+                    glActiveTexture(GL_TEXTURE0);
+                }
             }
-            glBindTexture(GL_TEXTURE_2D, !diffuseMap ?
-                Application::getInstance()->getTextureCache()->getWhiteTextureID() : diffuseMap->getID());
-            
-            if (!mesh.tangents.isEmpty()) {
-                glActiveTexture(GL_TEXTURE1);                
-                Texture* normalMap = networkPart.normalTexture.data();
-                glBindTexture(GL_TEXTURE_2D, !normalMap ?
-                    Application::getInstance()->getTextureCache()->getBlueTextureID() : normalMap->getID());
-                glActiveTexture(GL_TEXTURE0);
-            }
-            
             glDrawRangeElementsEXT(GL_QUADS, 0, vertexCount - 1, part.quadIndices.size(), GL_UNSIGNED_INT, (void*)offset);
             offset += part.quadIndices.size() * sizeof(int);
             glDrawRangeElementsEXT(GL_TRIANGLES, 0, vertexCount - 1, part.triangleIndices.size(),
@@ -1111,21 +1111,20 @@ void Model::renderMeshes(float alpha, bool translucent) {
             glDisableClientState(GL_TEXTURE_COORD_ARRAY);
         }
         
-        if (!mesh.tangents.isEmpty()) {
+        if (!(mesh.tangents.isEmpty() || forShadowMap)) {
             glActiveTexture(GL_TEXTURE1);
             glBindTexture(GL_TEXTURE_2D, 0);
             glActiveTexture(GL_TEXTURE0);
             
             activeProgram->disableAttributeArray(tangentLocation);
         }
-        
-        if (state.worldSpaceVertices.isEmpty()) {
-            if (state.clusterMatrices.size() > 1) {
-                skinProgram->disableAttributeArray(skinLocations->clusterIndices);
-                skinProgram->disableAttributeArray(skinLocations->clusterWeights);  
-            } 
-            glPopMatrix();
-        }
+                
+        if (state.clusterMatrices.size() > 1) {
+            skinProgram->disableAttributeArray(skinLocations->clusterIndices);
+            skinProgram->disableAttributeArray(skinLocations->clusterWeights);  
+        } 
+        glPopMatrix();
+
         activeProgram->release();
     }
 }

interface/src/renderer/Model.h

@@ -43,8 +43,8 @@ public:
     void setPupilDilation(float dilation) { _pupilDilation = dilation; }
     float getPupilDilation() const { return _pupilDilation; }
     
-    void setBlendshapeCoefficients(const std::vector<float>& coefficients) { _blendshapeCoefficients = coefficients; }
-    const std::vector<float>& getBlendshapeCoefficients() const { return _blendshapeCoefficients; }
+    void setBlendshapeCoefficients(const QVector<float>& coefficients) { _blendshapeCoefficients = coefficients; }
+    const QVector<float>& getBlendshapeCoefficients() const { return _blendshapeCoefficients; }
     
     bool isActive() const { return _geometry && _geometry->isLoaded(); }
     
@@ -58,7 +58,7 @@ public:
     void createCollisionShapes();
     void updateShapePositions();
     void simulate(float deltaTime, bool fullUpdate = true);
-    bool render(float alpha);
+    bool render(float alpha = 1.0f, bool forShadowMap = false);
     
     /// Sets the URL of the model to render.
     /// \param fallback the URL of a fallback model to render if the requested model fails to load
@@ -181,6 +181,9 @@ public:
 
     float getBoundingRadius() const { return _boundingRadius; }
 
+    /// Sets blended vertices computed in a separate thread.
+    void setBlendedVertices(const QVector<glm::vec3>& vertices, const QVector<glm::vec3>& normals);
+
 protected:
 
     QSharedPointer<NetworkGeometry> _geometry;
@@ -205,9 +208,6 @@ protected:
     class MeshState {
     public:
         QVector<glm::mat4> clusterMatrices;
-        QVector<glm::vec3> worldSpaceVertices;
-        QVector<glm::vec3> vertexVelocities;
-        QVector<glm::vec3> worldSpaceNormals;
     };
     
     QVector<MeshState> _meshStates;
@@ -247,7 +247,7 @@ private:
     
     void applyNextGeometry();
     void deleteGeometry();
-    void renderMeshes(float alpha, bool translucent);
+    void renderMeshes(float alpha, bool forShadowMap, bool translucent);
     
     QSharedPointer<NetworkGeometry> _baseGeometry; ///< reference required to prevent collection of base
     QSharedPointer<NetworkGeometry> _nextBaseGeometry;
@@ -257,16 +257,13 @@ private:
     float _nextLODHysteresis;
     
     float _pupilDilation;
-    std::vector<float> _blendshapeCoefficients;
+    QVector<float> _blendshapeCoefficients;
     
     QUrl _url;
         
-    QVector<GLuint> _blendedVertexBufferIDs;
-    QVector<QVector<QSharedPointer<Texture> > > _dilatedTextures;
-    bool _resetStates;
+    QVector<QOpenGLBuffer> _blendedVertexBuffers;
     
-    QVector<glm::vec3> _blendedVertices;
-    QVector<glm::vec3> _blendedNormals;
+    QVector<QVector<QSharedPointer<Texture> > > _dilatedTextures;
     
     QVector<Model*> _attachments;
 
@@ -274,8 +271,10 @@ private:
     
     static ProgramObject _program;
     static ProgramObject _normalMapProgram;
+    static ProgramObject _shadowProgram;
     static ProgramObject _skinProgram;
     static ProgramObject _skinNormalMapProgram;
+    static ProgramObject _skinShadowProgram;
     
     static int _normalMapTangentLocation;
     
@@ -289,9 +288,14 @@ private:
     
     static SkinLocations _skinLocations;
     static SkinLocations _skinNormalMapLocations;
+    static SkinLocations _skinShadowLocations;
     
     static void initSkinProgram(ProgramObject& program, SkinLocations& locations);
     static QVector<JointState> createJointStates(const FBXGeometry& geometry);
 };
 
+Q_DECLARE_METATYPE(QPointer<Model>)
+Q_DECLARE_METATYPE(QWeakPointer<NetworkGeometry>)
+Q_DECLARE_METATYPE(QVector<glm::vec3>)
+
 #endif /* defined(__interface__Model__) */

interface/src/renderer/TextureCache.cpp

@@ -38,9 +38,6 @@ TextureCache::~TextureCache() {
     if (_whiteTextureID != 0) {
         glDeleteTextures(1, &_whiteTextureID);
     }
-    foreach (GLuint id, _fileTextureIDs) {
-        glDeleteTextures(1, &id);
-    }
     if (_primaryFramebufferObject) {
         glDeleteTextures(1, &_primaryDepthTextureID);
     }
@@ -104,23 +101,6 @@ GLuint TextureCache::getBlueTextureID() {
     return _blueTextureID;
 }
 
-GLuint TextureCache::getFileTextureID(const QString& filename) {
-    GLuint id = _fileTextureIDs.value(filename);
-    if (id == 0) {
-        QImage image = QImage(filename).convertToFormat(QImage::Format_ARGB32);
-    
-        glGenTextures(1, &id);
-        glBindTexture(GL_TEXTURE_2D, id);
-        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width(), image.height(), 1,
-            GL_BGRA, GL_UNSIGNED_BYTE, image.constBits());
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-        glBindTexture(GL_TEXTURE_2D, 0);
-        
-        _fileTextureIDs.insert(filename, id);
-    }
-    return id;
-}
-
 QSharedPointer<NetworkTexture> TextureCache::getTexture(const QUrl& url, bool normalMap, bool dilatable) {
     if (!dilatable) {
         return ResourceCache::getResource(url, QUrl(), false, &normalMap).staticCast<NetworkTexture>();
@@ -293,27 +273,50 @@ void ImageReader::run() {
         _reply->deleteLater();
         return;
     }
+    QUrl url = _reply->url();
     QImage image = QImage::fromData(_reply->readAll());
+    _reply->deleteLater();
+    
+    // enforce a fixed maximum
+    const int MAXIMUM_SIZE = 1024;
+    if (image.width() > MAXIMUM_SIZE || image.height() > MAXIMUM_SIZE) {
+        qDebug() << "Image greater than maximum size:" << url << image.width() << image.height();
+        image = image.scaled(MAXIMUM_SIZE, MAXIMUM_SIZE, Qt::KeepAspectRatio);
+    }
+    
+    if (!image.hasAlphaChannel()) {
+        if (image.format() != QImage::Format_RGB888) {
+            image = image.convertToFormat(QImage::Format_RGB888);
+        }
+        QMetaObject::invokeMethod(texture.data(), "setImage", Q_ARG(const QImage&, image), Q_ARG(bool, false));
+        return;
+    }
     if (image.format() != QImage::Format_ARGB32) {
         image = image.convertToFormat(QImage::Format_ARGB32);
     }
     
-    // check for translucency
+    // check for translucency/false transparency
+    int opaquePixels = 0;
     int translucentPixels = 0;
     const int EIGHT_BIT_MAXIMUM = 255;
     const int RGB_BITS = 24;
     for (int y = 0; y < image.height(); y++) {
         for (int x = 0; x < image.width(); x++) {
             int alpha = image.pixel(x, y) >> RGB_BITS;
-            if (alpha != 0 && alpha != EIGHT_BIT_MAXIMUM) {
+            if (alpha == EIGHT_BIT_MAXIMUM) {
+                opaquePixels++;
+            } else if (alpha != 0) {
                 translucentPixels++;
             }
         }
     }
     int imageArea = image.width() * image.height();
+    if (opaquePixels == imageArea) {
+        qDebug() << "Image with alpha channel is completely opaque:" << url;
+        image = image.convertToFormat(QImage::Format_RGB888);
+    }
     QMetaObject::invokeMethod(texture.data(), "setImage", Q_ARG(const QImage&, image),
         Q_ARG(bool, translucentPixels >= imageArea / 2));
-    _reply->deleteLater();
 }
 
 void NetworkTexture::downloadFinished(QNetworkReply* reply) {
@@ -327,8 +330,13 @@ void NetworkTexture::setImage(const QImage& image, bool translucent) {
     finishedLoading(true);
     imageLoaded(image);
     glBindTexture(GL_TEXTURE_2D, getID());
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width(), image.height(), 1,
-        GL_BGRA, GL_UNSIGNED_BYTE, image.constBits());
+    if (image.hasAlphaChannel()) {
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width(), image.height(), 1,
+            GL_BGRA, GL_UNSIGNED_BYTE, image.constBits());
+    } else {
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.width(), image.height(), 1,
+            GL_RGB, GL_UNSIGNED_BYTE, image.constBits());
+    }
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glBindTexture(GL_TEXTURE_2D, 0);
 }
@@ -360,8 +368,13 @@ QSharedPointer<Texture> DilatableNetworkTexture::getDilatedTexture(float dilatio
             painter.end();
             
             glBindTexture(GL_TEXTURE_2D, texture->getID());
-            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, dilatedImage.width(), dilatedImage.height(), 1,
-                GL_BGRA, GL_UNSIGNED_BYTE, dilatedImage.constBits());
+            if (dilatedImage.hasAlphaChannel()) {
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, dilatedImage.width(), dilatedImage.height(), 1,
+                    GL_BGRA, GL_UNSIGNED_BYTE, dilatedImage.constBits());
+            } else {
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, dilatedImage.width(), dilatedImage.height(), 1,
+                    GL_RGB, GL_UNSIGNED_BYTE, dilatedImage.constBits());
+            }
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
             glBindTexture(GL_TEXTURE_2D, 0);
         }

interface/src/renderer/TextureCache.h

@@ -27,7 +27,7 @@ class TextureCache : public ResourceCache {
 public:
     
     TextureCache();
-    ~TextureCache();
+    virtual ~TextureCache();
     
     /// Returns the ID of the permutation/normal texture used for Perlin noise shader programs.  This texture
     /// has two lines: the first, a set of random numbers in [0, 255] to be used as permutation offsets, and
@@ -39,9 +39,6 @@ public:
 
     /// Returns the ID of a pale blue texture (useful for a normal map).
     GLuint getBlueTextureID();
-    
-    /// Returns the ID of a texture containing the contents of the specified file, loading it if necessary. 
-    GLuint getFileTextureID(const QString& filename);
 
     /// Loads a texture from the specified URL.
     QSharedPointer<NetworkTexture> getTexture(const QUrl& url, bool normalMap = false, bool dilatable = false);
@@ -84,8 +81,6 @@ private:
     GLuint _whiteTextureID;
     GLuint _blueTextureID;
     
-    QHash<QString, GLuint> _fileTextureIDs;
-
     QHash<QUrl, QWeakPointer<NetworkTexture> > _dilatableNetworkTextures;
     
     GLuint _primaryDepthTextureID;

interface/src/scripting/AudioDeviceScriptingInterface.cpp

@@ -0,0 +1,69 @@
+//
+//  AudioDeviceScriptingInterface.cpp
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 3/23/14
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+
+#include "Application.h"
+#include "AudioDeviceScriptingInterface.h"
+
+
+AudioDeviceScriptingInterface* AudioDeviceScriptingInterface::getInstance() {
+    static AudioDeviceScriptingInterface sharedInstance;
+    return &sharedInstance;
+}
+
+bool AudioDeviceScriptingInterface::setInputDevice(const QString& deviceName) {
+    bool result;
+    QMetaObject::invokeMethod(Application::getInstance()->getAudio(), "switchInputToAudioDevice",
+                        Qt::BlockingQueuedConnection,
+                        Q_RETURN_ARG(bool, result),
+                        Q_ARG(const QString&, deviceName));
+
+    return result;
+}
+
+bool AudioDeviceScriptingInterface::setOutputDevice(const QString& deviceName) {
+    bool result;
+    QMetaObject::invokeMethod(Application::getInstance()->getAudio(), "switchOutputToAudioDevice",
+                        Qt::BlockingQueuedConnection,
+                        Q_RETURN_ARG(bool, result),
+                        Q_ARG(const QString&, deviceName));
+
+    return result;
+}
+
+QString AudioDeviceScriptingInterface::getInputDevice() {
+    return Application::getInstance()->getAudio()->getDeviceName(QAudio::AudioInput);
+}
+
+QString AudioDeviceScriptingInterface::getOutputDevice() {
+    return Application::getInstance()->getAudio()->getDeviceName(QAudio::AudioOutput);
+}
+
+QString AudioDeviceScriptingInterface::getDefaultInputDevice() {
+    return Application::getInstance()->getAudio()->getDefaultDeviceName(QAudio::AudioInput);
+}
+
+QString AudioDeviceScriptingInterface::getDefaultOutputDevice() {
+    return Application::getInstance()->getAudio()->getDefaultDeviceName(QAudio::AudioOutput);
+}
+
+QVector<QString> AudioDeviceScriptingInterface::getInputDevices() {
+    return Application::getInstance()->getAudio()->getDeviceNames(QAudio::AudioInput);
+}
+
+QVector<QString> AudioDeviceScriptingInterface::getOutputDevices() {
+    return Application::getInstance()->getAudio()->getDeviceNames(QAudio::AudioOutput);
+}
+
+
+float AudioDeviceScriptingInterface::getInputVolume() {
+    return Application::getInstance()->getAudio()->getInputVolume();
+}
+
+void AudioDeviceScriptingInterface::setInputVolume(float volume) {
+    Application::getInstance()->getAudio()->setInputVolume(volume);
+}

interface/src/scripting/AudioDeviceScriptingInterface.h

@@ -0,0 +1,41 @@
+//
+//  AudioDeviceScriptingInterface.h
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 3/22/14
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+
+#ifndef __hifi__AudioDeviceScriptingInterface__
+#define __hifi__AudioDeviceScriptingInterface__
+
+#include <QDebug>
+#include <QObject>
+#include <QString>
+
+#include "Application.h"
+
+class AudioDeviceScriptingInterface : public QObject {
+    Q_OBJECT
+    AudioDeviceScriptingInterface() { };
+public:
+    static AudioDeviceScriptingInterface* getInstance();
+
+public slots:
+    bool setInputDevice(const QString& deviceName);
+    bool setOutputDevice(const QString& deviceName);
+
+    QString getInputDevice();
+    QString getOutputDevice();
+
+    QString getDefaultInputDevice();
+    QString getDefaultOutputDevice();
+
+    QVector<QString> getInputDevices();
+    QVector<QString> getOutputDevices();
+
+    float getInputVolume();
+    void setInputVolume(float volume);
+};
+
+#endif /* defined(__hifi__AudioDeviceScriptingInterface__) */

interface/src/scripting/SettingsScriptingInterface.cpp

@@ -0,0 +1,36 @@
+//
+//  SettingsScriptingInterface.cpp
+//  hifi
+//
+//  Created by Brad Hefta-Gaub on 2/25/14
+//  Copyright (c) 2014 HighFidelity, Inc. All rights reserved.
+//
+
+#include "Application.h"
+#include "SettingsScriptingInterface.h"
+
+
+SettingsScriptingInterface* SettingsScriptingInterface::getInstance() {
+    static SettingsScriptingInterface sharedInstance;
+    return &sharedInstance;
+}
+
+QVariant SettingsScriptingInterface::getValue(const QString& setting) {
+    QSettings* settings = Application::getInstance()->lockSettings();
+    QVariant value = settings->value(setting);
+    Application::getInstance()->unlockSettings();
+    return value;
+}
+
+QVariant SettingsScriptingInterface::getValue(const QString& setting, const QVariant& defaultValue) {
+    QSettings* settings = Application::getInstance()->lockSettings();
+    QVariant value = settings->value(setting, defaultValue);
+    Application::getInstance()->unlockSettings();
+    return value;
+}
+
+void SettingsScriptingInterface::setValue(const QString& setting, const QVariant& value) {
+    QSettings* settings = Application::getInstance()->lockSettings();
+    settings->setValue(setting, value);
+    Application::getInstance()->unlockSettings();
+}