Merge remote-tracking branch 'upstream/master'

examples/flockingBirds.js

@@ -51,7 +51,7 @@ var flockGravity = { x: 0, y: -1, z: 0};
 var enableRandomXZThrust = false; // leading birds randomly decide to thrust in some random direction.
 var enableSomeBirdsLead = false; // birds randomly decide not fly toward flock, causing other birds to follow
 var leaders = 0; // number of birds leading
-var PROBABILITY_TO_LEAD = 0.1; // probabolity a bird will choose to lead
+var PROBABILITY_TO_LEAD = 0.1; // probability a bird will choose to lead
 
 var birds = new Array(); // array of bird state data
 

interface/src/Application.cpp

@@ -292,8 +292,8 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
     // move the silentNodeTimer to the _nodeThread
     QTimer* silentNodeTimer = new QTimer();
     connect(silentNodeTimer, SIGNAL(timeout()), nodeList, SLOT(removeSilentNodes()));
-    silentNodeTimer->moveToThread(_nodeThread);
     silentNodeTimer->start(NODE_SILENCE_THRESHOLD_MSECS);
+    silentNodeTimer->moveToThread(_nodeThread);
 
     // send the identity packet for our avatar each second to our avatar mixer
     QTimer* identityPacketTimer = new QTimer();
@@ -1007,6 +1007,12 @@ void Application::keyPressEvent(QKeyEvent* event) {
             case Qt::Key_At:
                 Menu::getInstance()->goTo();
                 break;
+            case Qt::Key_B:
+                _applicationOverlay.setOculusAngle(_applicationOverlay.getOculusAngle() - RADIANS_PER_DEGREE);
+                break;
+            case Qt::Key_N:
+                _applicationOverlay.setOculusAngle(_applicationOverlay.getOculusAngle() + RADIANS_PER_DEGREE);
+                break;
             default:
                 event->ignore();
                 break;
@@ -1097,7 +1103,8 @@ void Application::mouseMoveEvent(QMouseEvent* event) {
 
 
     _lastMouseMove = usecTimestampNow();
-    if (_mouseHidden) {
+
+    if (_mouseHidden && !OculusManager::isConnected) {
         getGLWidget()->setCursor(Qt::ArrowCursor);
         _mouseHidden = false;
         _seenMouseMove = true;
@@ -3119,9 +3126,15 @@ void Application::domainChanged(const QString& domainHostname) {
     _environment.resetToDefault();
 
     // reset our node to stats and node to jurisdiction maps... since these must be changing...
+    _voxelServerJurisdictions.lockForWrite();
     _voxelServerJurisdictions.clear();
+    _voxelServerJurisdictions.unlock();
+
     _octreeServerSceneStats.clear();
+
+    _particleServerJurisdictions.lockForWrite();
     _particleServerJurisdictions.clear();
+    _particleServerJurisdictions.unlock();
 
     // reset the particle renderer
     _particles.clear();
@@ -3160,10 +3173,12 @@ void Application::nodeKilled(SharedNodePointer node) {
     if (node->getType() == NodeType::VoxelServer) {
         QUuid nodeUUID = node->getUUID();
         // see if this is the first we've heard of this node...
+        _voxelServerJurisdictions.lockForRead();
         if (_voxelServerJurisdictions.find(nodeUUID) != _voxelServerJurisdictions.end()) {
             unsigned char* rootCode = _voxelServerJurisdictions[nodeUUID].getRootOctalCode();
             VoxelPositionSize rootDetails;
             voxelDetailsForCode(rootCode, rootDetails);
+            _voxelServerJurisdictions.unlock();
 
             qDebug("voxel server going away...... v[%f, %f, %f, %f]",
                 rootDetails.x, rootDetails.y, rootDetails.z, rootDetails.s);
@@ -3180,8 +3195,10 @@ void Application::nodeKilled(SharedNodePointer node) {
             }
 
             // If the voxel server is going away, remove it from our jurisdiction map so we don't send voxels to a dead server
+            _voxelServerJurisdictions.lockForWrite();
             _voxelServerJurisdictions.erase(_voxelServerJurisdictions.find(nodeUUID));
         }
+        _voxelServerJurisdictions.unlock();
 
         // also clean up scene stats for that server
         _octreeSceneStatsLock.lockForWrite();
@@ -3193,10 +3210,12 @@ void Application::nodeKilled(SharedNodePointer node) {
     } else if (node->getType() == NodeType::ParticleServer) {
         QUuid nodeUUID = node->getUUID();
         // see if this is the first we've heard of this node...
+        _particleServerJurisdictions.lockForRead();
         if (_particleServerJurisdictions.find(nodeUUID) != _particleServerJurisdictions.end()) {
             unsigned char* rootCode = _particleServerJurisdictions[nodeUUID].getRootOctalCode();
             VoxelPositionSize rootDetails;
             voxelDetailsForCode(rootCode, rootDetails);
+            _particleServerJurisdictions.unlock();
 
             qDebug("particle server going away...... v[%f, %f, %f, %f]",
                 rootDetails.x, rootDetails.y, rootDetails.z, rootDetails.s);
@@ -3213,8 +3232,10 @@ void Application::nodeKilled(SharedNodePointer node) {
             }
 
             // If the particle server is going away, remove it from our jurisdiction map so we don't send voxels to a dead server
+            _particleServerJurisdictions.lockForWrite();
             _particleServerJurisdictions.erase(_particleServerJurisdictions.find(nodeUUID));
         }
+        _particleServerJurisdictions.unlock();
 
         // also clean up scene stats for that server
         _octreeSceneStatsLock.lockForWrite();
@@ -3227,10 +3248,12 @@ void Application::nodeKilled(SharedNodePointer node) {
 
         QUuid nodeUUID = node->getUUID();
         // see if this is the first we've heard of this node...
+        _modelServerJurisdictions.lockForRead();
         if (_modelServerJurisdictions.find(nodeUUID) != _modelServerJurisdictions.end()) {
             unsigned char* rootCode = _modelServerJurisdictions[nodeUUID].getRootOctalCode();
             VoxelPositionSize rootDetails;
             voxelDetailsForCode(rootCode, rootDetails);
+            _modelServerJurisdictions.unlock();
 
             qDebug("model server going away...... v[%f, %f, %f, %f]",
                 rootDetails.x, rootDetails.y, rootDetails.z, rootDetails.s);
@@ -3247,8 +3270,10 @@ void Application::nodeKilled(SharedNodePointer node) {
             }
 
             // If the model server is going away, remove it from our jurisdiction map so we don't send voxels to a dead server
+            _modelServerJurisdictions.lockForWrite();
             _modelServerJurisdictions.erase(_modelServerJurisdictions.find(nodeUUID));
         }
+        _modelServerJurisdictions.unlock();
 
         // also clean up scene stats for that server
         _octreeSceneStatsLock.lockForWrite();
@@ -3318,7 +3343,10 @@ int Application::parseOctreeStats(const QByteArray& packet, const SharedNodePoin
             serverType = "Model";
         }
 
+        jurisdiction->lockForRead();
         if (jurisdiction->find(nodeUUID) == jurisdiction->end()) {
+            jurisdiction->unlock();
+
             qDebug("stats from new %s server... [%f, %f, %f, %f]",
                 qPrintable(serverType), rootDetails.x, rootDetails.y, rootDetails.z, rootDetails.s);
 
@@ -3332,6 +3360,8 @@ int Application::parseOctreeStats(const QByteArray& packet, const SharedNodePoin
                 _voxelFades.push_back(fade);
                 _voxelFadesLock.unlock();
             }
+        } else {
+            jurisdiction->unlock();
         }
         // store jurisdiction details for later use
         // This is bit of fiddling is because JurisdictionMap assumes it is the owner of the values used to construct it
@@ -3339,7 +3369,9 @@ int Application::parseOctreeStats(const QByteArray& packet, const SharedNodePoin
         // details from the OctreeSceneStats to construct the JurisdictionMap
         JurisdictionMap jurisdictionMap;
         jurisdictionMap.copyContents(temp.getJurisdictionRoot(), temp.getJurisdictionEndNodes());
+        jurisdiction->lockForWrite();
         (*jurisdiction)[nodeUUID] = jurisdictionMap;
+        jurisdiction->unlock();
     }
     return statsMessageLength;
 }

interface/src/Menu.cpp

@@ -348,7 +348,6 @@ Menu::Menu() :
 
     QMenu* avatarOptionsMenu = developerMenu->addMenu("Avatar Options");
 
-    addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::AllowOculusCameraModeChange, 0, false);
     addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::Avatars, 0, true);
     addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::AvatarsReceiveShadows, 0, true);
     addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::RenderSkeletonCollisionShapes);
@@ -375,6 +374,10 @@ Menu::Menu() :
     addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::GlowWhenSpeaking, 0, true);
     addCheckableActionToQMenuAndActionHash(avatarOptionsMenu, MenuOption::ChatCircling, 0, false);
 
+    QMenu* oculusOptionsMenu = developerMenu->addMenu("Oculus Options");
+    addCheckableActionToQMenuAndActionHash(oculusOptionsMenu, MenuOption::AllowOculusCameraModeChange, 0, false);
+    addCheckableActionToQMenuAndActionHash(oculusOptionsMenu, MenuOption::DisplayOculusOverlays, 0, true);
+
     QMenu* handOptionsMenu = developerMenu->addMenu("Hand Options");
 
     addCheckableActionToQMenuAndActionHash(handOptionsMenu,

interface/src/Menu.h

@@ -326,6 +326,7 @@ namespace MenuOption {
     const QString DisplayModelBounds = "Display Model Bounds";
     const QString DisplayModelElementProxy = "Display Model Element Bounds";
     const QString DisplayModelElementChildProxies = "Display Model Element Children";
+    const QString DisplayOculusOverlays = "Display Oculus Overlays";
     const QString DisplayTimingDetails = "Display Timing Details";
     const QString DontFadeOnVoxelServerChanges = "Don't Fade In/Out on Voxel Server Changes";
     const QString EchoLocalAudio = "Echo Local Audio";

interface/src/Util.cpp

@@ -400,9 +400,9 @@ bool closeEnoughForGovernmentWork(float a, float b) {
 void runTimingTests() {
     //  How long does it take to make a call to get the time?
     const int numTests = 1000000;
-    int iResults[numTests];
+    int* iResults = (int*)malloc(sizeof(int) * numTests);
     float fTest = 1.0;
-    float fResults[numTests];
+    float* fResults = (float*)malloc(sizeof(float) * numTests);
     QElapsedTimer startTime;
     startTime.start();
     float elapsedUsecs;
@@ -413,7 +413,7 @@ void runTimingTests() {
     
     // Random number generation
     startTime.start();
-    for (int i = 1; i < numTests; i++) {
+    for (int i = 0; i < numTests; i++) {
         iResults[i] = rand();
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
@@ -421,16 +421,19 @@ void runTimingTests() {
 
     // Random number generation using randFloat()
     startTime.start();
-    for (int i = 1; i < numTests; i++) {
+    for (int i = 0; i < numTests; i++) {
         fResults[i] = randFloat();
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
     qDebug("randFloat() stored in array usecs: %f, first result: %f", elapsedUsecs / (float) numTests, fResults[0]);
 
+    free(iResults);
+    free(fResults);
+
     //  PowF function
     fTest = 1145323.2342f;
     startTime.start();
-    for (int i = 1; i < numTests; i++) {
+    for (int i = 0; i < numTests; i++) {
         fTest = powf(fTest, 0.5f);
     }
     elapsedUsecs = (float)startTime.nsecsElapsed() * NSEC_TO_USEC;
@@ -440,7 +443,7 @@ void runTimingTests() {
     float distance;
     glm::vec3 pointA(randVector()), pointB(randVector());
     startTime.start();
-    for (int i = 1; i < numTests; i++) {
+    for (int i = 0; i < numTests; i++) {
         //glm::vec3 temp = pointA - pointB;
         //float distanceSquared = glm::dot(temp, temp);
         distance = glm::distance(pointA, pointB);
@@ -454,7 +457,7 @@ void runTimingTests() {
     float result;
     
     startTime.start();
-    for (int i = 1; i < numTests; i++) {
+    for (int i = 0; i < numTests; i++) {
         glm::vec3 temp = vecA-vecB;
         result = glm::dot(temp,temp);
     }

interface/src/devices/OculusManager.cpp

@@ -86,7 +86,7 @@ void OculusManager::display(Camera& whichCamera) {
     // We only need to render the overlays to a texture once, then we just render the texture as a quad
     // PrioVR will only work if renderOverlay is called, calibration is connected to Application::renderingOverlay() 
     applicationOverlay.renderOverlay(true);
-    const bool displayOverlays = false;
+    const bool displayOverlays = Menu::getInstance()->isOptionChecked(MenuOption::DisplayOculusOverlays);
     
     Application::getInstance()->getGlowEffect()->prepare(); 
 

interface/src/ui/ApplicationOverlay.cpp

@@ -19,7 +19,10 @@
 
 #include "ui/Stats.h"
 
-ApplicationOverlay::ApplicationOverlay() : _framebufferObject(NULL) {
+ApplicationOverlay::ApplicationOverlay() : 
+    _framebufferObject(NULL),
+    _oculusAngle(65.0f * RADIANS_PER_DEGREE),
+    _distance(0.5f) {
 
 }
 
@@ -45,6 +48,10 @@ void ApplicationOverlay::renderOverlay(bool renderToTexture) {
     BandwidthMeter* bandwidthMeter = application->getBandwidthMeter();
     NodeBounds& nodeBoundsDisplay = application->getNodeBoundsDisplay();
 
+    int mouseX = application->getMouseX();
+    int mouseY = application->getMouseY();
+    bool renderPointer = renderToTexture;
+
     if (renderToTexture) {
         getFramebufferObject()->bind();
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -220,6 +227,34 @@ void ApplicationOverlay::renderOverlay(bool renderToTexture) {
 
     overlays.render2D();
 
+    // Render a crosshair over the pointer when in Oculus
+    if (renderPointer) {
+        const float pointerWidth = 10;
+        const float pointerHeight = 10;
+        const float crossPad = 4;
+
+        mouseX -= pointerWidth / 2.0f;
+        mouseY += pointerHeight / 2.0f;
+
+        glBegin(GL_QUADS);
+       
+        glColor3f(1, 0, 0);
+        
+        //Horizontal crosshair
+        glVertex2i(mouseX, mouseY - crossPad);
+        glVertex2i(mouseX + pointerWidth, mouseY - crossPad);
+        glVertex2i(mouseX + pointerWidth, mouseY - pointerHeight + crossPad);
+        glVertex2i(mouseX, mouseY - pointerHeight + crossPad);
+
+        //Vertical crosshair
+        glVertex2i(mouseX + crossPad, mouseY);
+        glVertex2i(mouseX + pointerWidth - crossPad, mouseY);
+        glVertex2i(mouseX + pointerWidth - crossPad, mouseY - pointerHeight);
+        glVertex2i(mouseX + crossPad, mouseY - pointerHeight);
+      
+        glEnd();
+    }
+
     glPopMatrix();
 
     glMatrixMode(GL_MODELVIEW);
@@ -227,7 +262,6 @@ void ApplicationOverlay::renderOverlay(bool renderToTexture) {
     glEnable(GL_LIGHTING);
     glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
 
-
     if (renderToTexture) {
         getFramebufferObject()->release();
     }
@@ -262,6 +296,15 @@ void ApplicationOverlay::displayOverlayTexture(Camera& whichCamera) {
     glDisable(GL_TEXTURE_2D);
 }
 
+// Fast helper functions
+inline float max(float a, float b) {
+    return (a > b) ? a : b;
+}
+
+inline float min(float a, float b) {
+    return (a < b) ? a : b;
+}
+
 // Draws the FBO texture for Oculus rift. TODO: Draw a curved texture instead of plane.
 void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
 
@@ -271,23 +314,36 @@ void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
     MyAvatar* myAvatar = application->getAvatar();
     const glm::vec3& viewMatrixTranslation = application->getViewMatrixTranslation();
 
-    // Calculates the world space width and height of the texture based on a desired FOV
+    int mouseX = application->getMouseX();
-    const float overlayFov = whichCamera.getFieldOfView() * PI / 180.0f;
+    int mouseY = application->getMouseY();
-    const float overlayDistance = 1;
+    int widgetWidth = glWidget->width();
+    int widgetHeight = glWidget->height();
+    float magnifyWidth = 80.0f;
+    float magnifyHeight = 60.0f;
+    const float magnification = 4.0f;
+
+    // Get vertical FoV of the displayed overlay texture
+    const float halfVerticalAngle = _oculusAngle / 2.0f;
+    const float verticalAngle = halfVerticalAngle * 2.0f;
     const float overlayAspectRatio = glWidget->width() / (float)glWidget->height();
-    const float overlayHeight = overlayDistance * tan(overlayFov);
+    const float halfOverlayHeight = _distance * tan(halfVerticalAngle);
-    const float overlayWidth = overlayHeight * overlayAspectRatio;
+
-    const float halfOverlayWidth = overlayWidth / 2;
+    // The more vertices, the better the curve
-    const float halfOverlayHeight = overlayHeight / 2;
+    const int numHorizontalVertices = 20;
+    // U texture coordinate width at each quad
+    const float quadTexWidth = 1.0f / (numHorizontalVertices - 1);
+
+    // Get horizontal angle and angle increment from vertical angle and aspect ratio
+    const float horizontalAngle = halfVerticalAngle * 2.0f * overlayAspectRatio;
+    const float angleIncrement = horizontalAngle / (numHorizontalVertices - 1);
+    const float halfHorizontalAngle = horizontalAngle / 2;
 
     glActiveTexture(GL_TEXTURE0);
-
+   
-    glDepthMask(GL_FALSE);
     glEnable(GL_BLEND);
-    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
-
     glBindTexture(GL_TEXTURE_2D, getFramebufferObject()->texture());
-    glDisable(GL_DEPTH_TEST);
+    glEnable(GL_DEPTH_TEST);
     glDisable(GL_LIGHTING);
     glEnable(GL_TEXTURE_2D);
 
@@ -305,21 +361,102 @@ void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
     glm::vec3 pos = whichCamera.getPosition();
     glm::quat rot = myAvatar->getOrientation();
     glm::vec3 axis = glm::axis(rot);
-    pos += rot * glm::vec3(0.0, 0.0, -overlayDistance);
+   
-
     glTranslatef(pos.x, pos.y, pos.z);
     glRotatef(glm::degrees(glm::angle(rot)), axis.x, axis.y, axis.z);
 
+    glColor3f(1.0f, 1.0f, 1.0f);
+
+    glDepthMask(GL_TRUE);
+    
+    glEnable(GL_ALPHA_TEST);
+    glAlphaFunc(GL_GREATER, 0.01f);
+
+    //Draw the magnifying glass
+
+    mouseX -= magnifyWidth / 2;
+    mouseY -= magnifyHeight / 2;
+
+    //clamp the magnification
+    if (mouseX < 0) {
+        magnifyWidth += mouseX;
+        mouseX = 0;
+    } else if (mouseX + magnifyWidth > widgetWidth) {
+        magnifyWidth = widgetWidth - mouseX;
+    }
+    if (mouseY < 0) {
+        magnifyHeight += mouseY;
+        mouseY = 0;
+    } else if (mouseY + magnifyHeight > widgetHeight) {
+        magnifyHeight = widgetHeight - mouseY;
+    }
+
+    float newWidth = magnifyWidth * magnification;
+    float newHeight = magnifyHeight * magnification;
+    float tmp;
+
+    // Magnification Texture Coordinates
+    float magnifyULeft = mouseX / (float)widgetWidth;
+    float magnifyURight = (mouseX + magnifyWidth) / (float)widgetWidth;
+    float magnifyVBottom = 1.0f - mouseY / (float)widgetHeight;
+    float magnifyVTop = 1.0f - (mouseY + magnifyHeight) / (float)widgetHeight;
+
+    // Coordinates of magnification overlay
+    float newMouseX = (mouseX + magnifyWidth / 2) - newWidth / 2.0f;
+    float newMouseY = (mouseY + magnifyHeight / 2) + newHeight / 2.0f;
+
+    // Get angle on the UI
+    float leftAngle = (newMouseX / (float)widgetWidth) * horizontalAngle - halfHorizontalAngle;
+    float rightAngle = ((newMouseX + newWidth) / (float)widgetWidth) * horizontalAngle - halfHorizontalAngle;
+   
+    float halfMagnifyHeight = magnifyHeight / 2.0f;
+
+    float leftX, rightX, leftZ, rightZ;
+    
+    // Get position on hemisphere using angle
+    leftX = sin(leftAngle) * _distance;
+    rightX = sin(rightAngle) * _distance;
+    leftZ = -cos(leftAngle) * _distance;
+    rightZ = -cos(rightAngle) * _distance;
+    
+    float bottomY = (1.0 - newMouseY / (float)widgetHeight) * halfOverlayHeight * 2.0f - halfOverlayHeight;
+    float topY = bottomY + (newHeight / widgetHeight) * halfOverlayHeight * 2;
+
+    //TODO: Remove immediate mode in favor of VBO
     glBegin(GL_QUADS);
-    glTexCoord2f(1, 0); glVertex3f(-halfOverlayWidth, halfOverlayHeight, 0);
+
-    glTexCoord2f(0, 0); glVertex3f(halfOverlayWidth, halfOverlayHeight, 0);
+    glTexCoord2f(magnifyULeft, magnifyVBottom); glVertex3f(leftX, topY, leftZ);
-    glTexCoord2f(0, 1); glVertex3f(halfOverlayWidth, -halfOverlayHeight, 0);
+    glTexCoord2f(magnifyURight, magnifyVBottom); glVertex3f(rightX, topY, rightZ);
-    glTexCoord2f(1, 1); glVertex3f(-halfOverlayWidth, -halfOverlayHeight, 0);
+    glTexCoord2f(magnifyURight, magnifyVTop); glVertex3f(rightX, bottomY, rightZ);
+    glTexCoord2f(magnifyULeft, magnifyVTop); glVertex3f(leftX, bottomY, leftZ);
+
+    glEnd();
+
+    glDepthMask(GL_FALSE);   
+    glDisable(GL_ALPHA_TEST);
+
+    //TODO: Remove immediate mode in favor of VBO
+    glBegin(GL_QUADS);
+    // Place the vertices in a semicircle curve around the camera
+    for (int i = 0; i < numHorizontalVertices-1; i++) {
+
+        // Calculate the X and Z coordinates from the angles and radius from camera
+        leftX = sin(angleIncrement * i - halfHorizontalAngle) * _distance;
+        rightX = sin(angleIncrement * (i + 1) - halfHorizontalAngle) * _distance;
+        leftZ = -cos(angleIncrement * i - halfHorizontalAngle) * _distance;
+        rightZ = -cos(angleIncrement * (i + 1) - halfHorizontalAngle) * _distance;
+
+        glTexCoord2f(quadTexWidth * i, 1); glVertex3f(leftX, halfOverlayHeight, leftZ);
+        glTexCoord2f(quadTexWidth * (i + 1), 1); glVertex3f(rightX,  halfOverlayHeight, rightZ);
+        glTexCoord2f(quadTexWidth * (i + 1), 0); glVertex3f(rightX, -halfOverlayHeight, rightZ);
+        glTexCoord2f(quadTexWidth * i, 0); glVertex3f(leftX, -halfOverlayHeight, leftZ);
+    }
+    
     glEnd();
 
     glPopMatrix();
 
-    glEnable(GL_DEPTH_TEST);
+    
     glDepthMask(GL_TRUE);
     glBindTexture(GL_TEXTURE_2D, 0);
     glDisable(GL_TEXTURE_2D);

interface/src/ui/ApplicationOverlay.h

@@ -28,11 +28,18 @@ public:
 
     // Getters
     QOpenGLFramebufferObject* getFramebufferObject();
+    float getOculusAngle() const { return _oculusAngle; }
+
+    // Setters
+    void setOculusAngle(float oculusAngle) { _oculusAngle = oculusAngle; }
 
 private:
 
+    ProgramObject _textureProgram;
     QOpenGLFramebufferObject* _framebufferObject;
     float _trailingAudioLoudness;
+    float _oculusAngle;
+    float _distance;
 };
 
 #endif // hifi_ApplicationOverlay_h

interface/src/ui/NodeBounds.cpp

@@ -70,14 +70,16 @@ void NodeBounds::draw() {
         }
 
         QUuid nodeUUID = node->getUUID();
+        serverJurisdictions->lockForRead();
         if (serverJurisdictions->find(nodeUUID) != serverJurisdictions->end()) {
-            const JurisdictionMap& map = serverJurisdictions->value(nodeUUID);
+            const JurisdictionMap& map = (*serverJurisdictions)[nodeUUID];
 
             unsigned char* rootCode = map.getRootOctalCode();
 
             if (rootCode) {
                 VoxelPositionSize rootDetails;
                 voxelDetailsForCode(rootCode, rootDetails);
+                serverJurisdictions->unlock();
                 glm::vec3 location(rootDetails.x, rootDetails.y, rootDetails.z);
                 location *= (float)TREE_SCALE;
 
@@ -123,7 +125,11 @@ void NodeBounds::draw() {
                     selectedCenter = center;
                     selectedScale = scaleFactor;
                 }
+            } else {
+                serverJurisdictions->unlock();
             }
+        } else {
+            serverJurisdictions->unlock();
         }
     }
 
@@ -136,7 +142,7 @@ void NodeBounds::draw() {
         float red, green, blue;
         getColorForNodeType(selectedNode->getType(), red, green, blue);
 
-        glColor4f(red, green, blue, 0.2);
+        glColor4f(red, green, blue, 0.2f);
         glutSolidCube(1.0);
 
         glPopMatrix();
@@ -229,7 +235,7 @@ void NodeBounds::drawOverlay() {
         int mouseX = application->getMouseX(),
             mouseY = application->getMouseY(),
             textWidth = widthText(TEXT_SCALE, 0, _overlayText);
-        glColor4f(0.4, 0.4, 0.4, 0.6);
+        glColor4f(0.4f, 0.4f, 0.4f, 0.6f);
         renderBevelCornersRect(mouseX + MOUSE_OFFSET, mouseY - TEXT_HEIGHT - PADDING,
                                textWidth + (2 * PADDING), TEXT_HEIGHT + (2 * PADDING), BACKGROUND_BEVEL);
         drawText(mouseX + MOUSE_OFFSET + PADDING, mouseY, TEXT_SCALE, ROTATION, FONT, _overlayText, TEXT_COLOR);

interface/src/ui/OctreeStatsDialog.cpp

@@ -281,8 +281,10 @@ void OctreeStatsDialog::showOctreeServersOfType(int& serverCount, NodeType_t ser
             
             // lookup our nodeUUID in the jurisdiction map, if it's missing then we're
             // missing at least one jurisdiction
+            serverJurisdictions.lockForRead();
             if (serverJurisdictions.find(nodeUUID) == serverJurisdictions.end()) {
                 serverDetails << " unknown jurisdiction ";
+                serverJurisdictions.unlock();
             } else {
                 const JurisdictionMap& map = serverJurisdictions[nodeUUID];
                 
@@ -305,6 +307,7 @@ void OctreeStatsDialog::showOctreeServersOfType(int& serverCount, NodeType_t ser
                 } else {
                     serverDetails << " jurisdiction has no rootCode";
                 } // root code
+                serverJurisdictions.unlock();
             } // jurisdiction
             
             // now lookup stats details for this server...

libraries/octree/src/JurisdictionMap.h

@@ -18,6 +18,7 @@
 
 #include <QtCore/QString>
 #include <QtCore/QUuid>
+#include <QReadWriteLock>
 
 #include <Node.h>
 
@@ -82,7 +83,7 @@ private:
 
 /// Map between node IDs and their reported JurisdictionMap. Typically used by classes that need to know which nodes are 
 /// managing which jurisdictions.
-typedef QMap<QUuid, JurisdictionMap> NodeToJurisdictionMap;
+class NodeToJurisdictionMap : public QMap<QUuid, JurisdictionMap>, public QReadWriteLock {};
 typedef QMap<QUuid, JurisdictionMap>::iterator NodeToJurisdictionMapIterator;
 
 

libraries/octree/src/OctreeEditPacketSender.cpp

@@ -71,9 +71,11 @@ bool OctreeEditPacketSender::serversExist() const {
             if (_serverJurisdictions) {
                 // lookup our nodeUUID in the jurisdiction map, if it's missing then we're
                 // missing at least one jurisdiction
+                _serverJurisdictions->lockForRead();
                 if ((*_serverJurisdictions).find(nodeUUID) == (*_serverJurisdictions).end()) {
                     atLeastOneJurisdictionMissing = true;
                 }
+                _serverJurisdictions->unlock();
             }
             hasServers = true;
         }
@@ -185,8 +187,10 @@ void OctreeEditPacketSender::queuePacketToNodes(unsigned char* buffer, ssize_t l
             bool isMyJurisdiction = true;
             // we need to get the jurisdiction for this
             // here we need to get the "pending packet" for this server
+            _serverJurisdictions->lockForRead();
             const JurisdictionMap& map = (*_serverJurisdictions)[nodeUUID];
             isMyJurisdiction = (map.isMyJurisdiction(octCode, CHECK_NODE_ONLY) == JurisdictionMap::WITHIN);
+            _serverJurisdictions->unlock();
             if (isMyJurisdiction) {
                 queuePacketToNode(nodeUUID, buffer, length);
             }
@@ -236,12 +240,14 @@ void OctreeEditPacketSender::queueOctreeEditMessage(PacketType type, unsigned ch
             if (_serverJurisdictions) {
                 // we need to get the jurisdiction for this
                 // here we need to get the "pending packet" for this server
+                _serverJurisdictions->lockForRead();
                 if ((*_serverJurisdictions).find(nodeUUID) != (*_serverJurisdictions).end()) {
                     const JurisdictionMap& map = (*_serverJurisdictions)[nodeUUID];
                     isMyJurisdiction = (map.isMyJurisdiction(codeColorBuffer, CHECK_NODE_ONLY) == JurisdictionMap::WITHIN);
                 } else {
                     isMyJurisdiction = false;
                 }
+                _serverJurisdictions->unlock();
             }
             if (isMyJurisdiction) {
                 EditPacketBuffer& packetBuffer = _pendingEditPackets[nodeUUID];

libraries/octree/src/OctreeHeadlessViewer.cpp

@@ -45,9 +45,11 @@ void OctreeHeadlessViewer::queryOctree() {
         qDebug() << "---------------";
         qDebug() << "_jurisdictionListener=" << _jurisdictionListener;
         qDebug() << "Jurisdictions...";
+        jurisdictions.lockForRead();
         for (NodeToJurisdictionMapIterator i = jurisdictions.begin(); i != jurisdictions.end(); ++i) {
             qDebug() << i.key() << ": " << &i.value();
         }
+        jurisdictions.unlock();
         qDebug() << "---------------";
     }
 
@@ -85,7 +87,9 @@ void OctreeHeadlessViewer::queryOctree() {
 
             // if we haven't heard from this voxel server, go ahead and send it a query, so we
             // can get the jurisdiction...
+            jurisdictions.lockForRead();
             if (jurisdictions.find(nodeUUID) == jurisdictions.end()) {
+                jurisdictions.unlock();
                 unknownJurisdictionServers++;
             } else {
                 const JurisdictionMap& map = (jurisdictions)[nodeUUID];
@@ -95,6 +99,7 @@ void OctreeHeadlessViewer::queryOctree() {
                 if (rootCode) {
                     VoxelPositionSize rootDetails;
                     voxelDetailsForCode(rootCode, rootDetails);
+                    jurisdictions.unlock();
                     AACube serverBounds(glm::vec3(rootDetails.x, rootDetails.y, rootDetails.z), rootDetails.s);
                     serverBounds.scale(TREE_SCALE);
 
@@ -103,6 +108,8 @@ void OctreeHeadlessViewer::queryOctree() {
                     if (serverFrustumLocation != ViewFrustum::OUTSIDE) {
                         inViewServers++;
                     }
+                } else {
+                    jurisdictions.unlock();
                 }
             }
         }
@@ -148,7 +155,9 @@ void OctreeHeadlessViewer::queryOctree() {
 
             // if we haven't heard from this voxel server, go ahead and send it a query, so we
             // can get the jurisdiction...
+            jurisdictions.lockForRead();
             if (jurisdictions.find(nodeUUID) == jurisdictions.end()) {
+                jurisdictions.unlock();
                 unknownView = true; // assume it's in view
                 if (wantExtraDebugging) {
                     qDebug() << "no known jurisdiction for node " << *node << ", assume it's visible.";
@@ -161,6 +170,7 @@ void OctreeHeadlessViewer::queryOctree() {
                 if (rootCode) {
                     VoxelPositionSize rootDetails;
                     voxelDetailsForCode(rootCode, rootDetails);
+                    jurisdictions.unlock();
                     AACube serverBounds(glm::vec3(rootDetails.x, rootDetails.y, rootDetails.z), rootDetails.s);
                     serverBounds.scale(TREE_SCALE);
 
@@ -171,6 +181,7 @@ void OctreeHeadlessViewer::queryOctree() {
                         inView = false;
                     }
                 } else {
+                    jurisdictions.unlock();
                     if (wantExtraDebugging) {
                         qDebug() << "Jurisdiction without RootCode for node " << *node << ". That's unusual!";
                     }