Merge pull request #2869 from huffman/19630

Code Review for Job #19630

interface/src/Application.cpp

@@ -170,6 +170,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
         _packetsPerSecond(0),
         _bytesPerSecond(0),
         _previousScriptLocation(),
+        _nodeBoundsDisplay(this),
         _runningScriptsWidget(new RunningScriptsWidget(_window)),
         _runningScriptsWidgetWasVisible(false)
 {
@@ -2527,6 +2528,9 @@ void Application::displaySide(Camera& whichCamera, bool selfAvatarOnly) {
 
         // restore default, white specular
         glMaterialfv(GL_FRONT, GL_SPECULAR, WHITE_SPECULAR_COLOR);
+
+        _nodeBoundsDisplay.draw();
+
     }
 
     bool mirrorMode = (whichCamera.getInterpolatedMode() == CAMERA_MODE_MIRROR);
@@ -2760,6 +2764,7 @@ void Application::displayOverlay() {
                 ? 80 : 20;
         drawText(_glWidget->width() - 100, _glWidget->height() - timerBottom, 0.30f, 0.0f, 0, frameTimer, WHITE_TEXT);
     }
+    _nodeBoundsDisplay.drawOverlay();
 
     // give external parties a change to hook in
     emit renderingOverlay();

interface/src/Application.h

@@ -74,6 +74,7 @@
 #include "ui/BandwidthDialog.h"
 #include "ui/BandwidthMeter.h"
 #include "ui/ModelsBrowser.h"
+#include "ui/NodeBounds.h"
 #include "ui/OctreeStatsDialog.h"
 #include "ui/RearMirrorTools.h"
 #include "ui/SnapshotShareDialog.h"
@@ -191,6 +192,8 @@ public:
     bool isMouseHidden() const { return _mouseHidden; }
     const glm::vec3& getMouseRayOrigin() const { return _mouseRayOrigin; }
     const glm::vec3& getMouseRayDirection() const { return _mouseRayDirection; }
+    int getMouseX() const { return _mouseX; }
+    int getMouseY() const { return _mouseY; }
     Faceplus* getFaceplus() { return &_faceplus; }
     Faceshift* getFaceshift() { return &_faceshift; }
     Visage* getVisage() { return &_visage; }
@@ -246,7 +249,7 @@ public:
     void computeOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& nearVal,
         float& farVal, glm::vec4& nearClipPlane, glm::vec4& farClipPlane) const;
 
-
+    NodeBounds& getNodeBoundsDisplay()  { return _nodeBoundsDisplay; }
 
     VoxelShader& getVoxelShader() { return _voxelShader; }
     PointShader& getPointShader() { return _pointShader; }
@@ -526,6 +529,8 @@ private:
     NodeToOctreeSceneStats _octreeServerSceneStats;
     QReadWriteLock _octreeSceneStatsLock;
 
+    NodeBounds _nodeBoundsDisplay;
+
     std::vector<VoxelFade> _voxelFades;
     ControllerScriptingInterface _controllerScriptingInterface;
     QPointer<LogDialog> _logDialog;

interface/src/Menu.cpp

@@ -42,6 +42,7 @@
 #include "ui/MetavoxelEditor.h"
 #include "ui/ModelsBrowser.h"
 #include "ui/LoginDialog.h"
+#include "ui/NodeBounds.h"
 
 
 Menu* Menu::_instance = NULL;
@@ -242,6 +243,19 @@ Menu::Menu() :
                                            SLOT(setEnable3DTVMode(bool)));
 
 
+    QMenu* nodeBordersMenu = viewMenu->addMenu("Server Borders");
+    NodeBounds& nodeBounds = appInstance->getNodeBoundsDisplay();
+    addCheckableActionToQMenuAndActionHash(nodeBordersMenu, MenuOption::ShowBordersVoxelNodes,
+                                           Qt::CTRL | Qt::SHIFT | Qt::Key_1, false,
+                                           &nodeBounds, SLOT(setShowVoxelNodes(bool)));
+    addCheckableActionToQMenuAndActionHash(nodeBordersMenu, MenuOption::ShowBordersModelNodes,
+                                           Qt::CTRL | Qt::SHIFT | Qt::Key_2, false,
+                                           &nodeBounds, SLOT(setShowModelNodes(bool)));
+    addCheckableActionToQMenuAndActionHash(nodeBordersMenu, MenuOption::ShowBordersParticleNodes,
+                                           Qt::CTRL | Qt::SHIFT | Qt::Key_3, false,
+                                           &nodeBounds, SLOT(setShowParticleNodes(bool)));
+
+
     QMenu* avatarSizeMenu = viewMenu->addMenu("Avatar Size");
 
     addActionToQMenuAndActionHash(avatarSizeMenu,

interface/src/Menu.h

@@ -367,6 +367,9 @@ namespace MenuOption {
     const QString SettingsExport = "Export Settings";
     const QString SettingsImport = "Import Settings";
     const QString Shadows = "Shadows";
+    const QString ShowBordersVoxelNodes = "Show Voxel Nodes";
+    const QString ShowBordersModelNodes = "Show Model Nodes";
+    const QString ShowBordersParticleNodes = "Show Particle Nodes";
     const QString ShowIKConstraints = "Show IK Constraints";
     const QString Stars = "Stars";
     const QString Stats = "Stats";

interface/src/ui/NodeBounds.cpp

@@ -0,0 +1,239 @@
+//
+//  NodeBounds.cpp
+//  interface/src/ui
+//
+//  Created by Ryan Huffman on 05/14/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  This class draws a border around the different Voxel, Model, and Particle nodes on the current domain,
+//  and a semi-transparent cube around the currently mouse-overed node.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#include "Application.h"
+#include "Util.h"
+
+#include "NodeBounds.h"
+
+NodeBounds::NodeBounds(QObject* parent) :
+    QObject(parent),
+    _showVoxelNodes(false),
+    _showModelNodes(false),
+    _showParticleNodes(false),
+    _overlayText() {
+
+}
+
+void NodeBounds::draw() {
+    if (!(_showVoxelNodes || _showModelNodes || _showParticleNodes)) {
+        _overlayText[0] = '\0';
+        return;
+    }
+
+    NodeToJurisdictionMap& voxelServerJurisdictions = Application::getInstance()->getVoxelServerJurisdictions();
+    NodeToJurisdictionMap& modelServerJurisdictions = Application::getInstance()->getModelServerJurisdictions();
+    NodeToJurisdictionMap& particleServerJurisdictions = Application::getInstance()->getParticleServerJurisdictions();
+    NodeToJurisdictionMap* serverJurisdictions;
+
+    // Compute ray to find selected nodes later on.  We can't use the pre-computed ray in Application because it centers
+    // itself after the cursor disappears.
+    Application* application = Application::getInstance();
+    QGLWidget* glWidget = application->getGLWidget();
+    float mouseX = application->getMouseX() / (float)glWidget->width();
+    float mouseY = application->getMouseY() / (float)glWidget->height();
+    glm::vec3 mouseRayOrigin;
+    glm::vec3 mouseRayDirection;
+    application->getViewFrustum()->computePickRay(mouseX, mouseY, mouseRayOrigin, mouseRayDirection);
+
+    // Variables to keep track of the selected node and properties to draw the cube later if needed
+    Node* selectedNode = NULL;
+    float selectedDistance = FLT_MAX;
+    bool selectedIsInside = true;
+    glm::vec3 selectedCenter;
+    float selectedScale = 0;
+
+    NodeList* nodeList = NodeList::getInstance();
+
+    foreach (const SharedNodePointer& node, nodeList->getNodeHash()) {
+        NodeType_t nodeType = node->getType();
+
+        if (nodeType == NodeType::VoxelServer && _showVoxelNodes) {
+            serverJurisdictions = &voxelServerJurisdictions;
+        } else if (nodeType == NodeType::ModelServer && _showModelNodes) {
+            serverJurisdictions = &modelServerJurisdictions;
+        } else if (nodeType == NodeType::ParticleServer && _showParticleNodes) {
+            serverJurisdictions = &particleServerJurisdictions;
+        } else {
+            continue;
+        }
+
+        QUuid nodeUUID = node->getUUID();
+        if (serverJurisdictions->find(nodeUUID) != serverJurisdictions->end()) {
+            const JurisdictionMap& map = serverJurisdictions->value(nodeUUID);
+
+            unsigned char* rootCode = map.getRootOctalCode();
+
+            if (rootCode) {
+                VoxelPositionSize rootDetails;
+                voxelDetailsForCode(rootCode, rootDetails);
+                glm::vec3 location(rootDetails.x, rootDetails.y, rootDetails.z);
+                location *= (float)TREE_SCALE;
+
+                AABox serverBounds(location, rootDetails.s * TREE_SCALE);
+
+                glm::vec3 center = serverBounds.getVertex(BOTTOM_RIGHT_NEAR)
+                    + ((serverBounds.getVertex(TOP_LEFT_FAR) - serverBounds.getVertex(BOTTOM_RIGHT_NEAR)) / 2.0f);
+
+                const float VOXEL_NODE_SCALE = 1.00f;
+                const float MODEL_NODE_SCALE = 0.99f;
+                const float PARTICLE_NODE_SCALE = 0.98f;
+
+                float scaleFactor = rootDetails.s * TREE_SCALE;
+
+                // Scale by 0.92 - 1.00 depending on the scale of the node.  This allows smaller nodes to scale in
+                // a bit and not overlap larger nodes.
+                scaleFactor *= 0.92 + (rootDetails.s * 0.08);
+
+                // Scale different node types slightly differently because it's common for them to overlap.
+                if (nodeType == NodeType::VoxelServer) {
+                    scaleFactor *= VOXEL_NODE_SCALE;
+                } else if (nodeType == NodeType::ModelServer) {
+                    scaleFactor *= MODEL_NODE_SCALE;
+                } else {
+                    scaleFactor *= PARTICLE_NODE_SCALE;
+                }
+
+                float red, green, blue;
+                getColorForNodeType(nodeType, red, green, blue);
+                drawNodeBorder(center, scaleFactor, red, green, blue);
+
+                float distance;
+                BoxFace face;
+                bool inside = serverBounds.contains(mouseRayOrigin);
+                bool colliding = serverBounds.findRayIntersection(mouseRayOrigin, mouseRayDirection, distance, face);
+
+                // If the camera is inside a node it will be "selected" if you don't have your cursor over another node
+                // that you aren't inside.
+                if (colliding && (!selectedNode || (!inside && (distance < selectedDistance || selectedIsInside)))) {
+                    selectedNode = node.data();
+                    selectedDistance = distance;
+                    selectedIsInside = inside;
+                    selectedCenter = center;
+                    selectedScale = scaleFactor;
+                }
+            }
+        }
+    }
+
+    if (selectedNode) {
+        glPushMatrix();
+
+        glTranslatef(selectedCenter.x, selectedCenter.y, selectedCenter.z);
+        glScalef(selectedScale, selectedScale, selectedScale);
+
+        NodeType_t selectedNodeType = selectedNode->getType();
+        float red, green, blue;
+        getColorForNodeType(selectedNode->getType(), red, green, blue);
+
+        glColor4f(red, green, blue, 0.2);
+        glutSolidCube(1.0);
+
+        glPopMatrix();
+
+        HifiSockAddr addr = selectedNode->getPublicSocket();
+        QString overlay = QString("%1:%2  %3ms")
+            .arg(addr.getAddress().toString())
+            .arg(addr.getPort())
+            .arg(selectedNode->getPingMs())
+            .left(MAX_OVERLAY_TEXT_LENGTH);
+
+        // Ideally we'd just use a QString, but I ran into weird blinking issues using
+        // constData() directly, as if the data was being overwritten.
+        strcpy(_overlayText, overlay.toLocal8Bit().constData());
+    } else {
+        _overlayText[0] = '\0';
+    }
+}
+
+void NodeBounds::drawNodeBorder(const glm::vec3& center, float scale, float red, float green, float blue) {
+    glPushMatrix();
+
+    glTranslatef(center.x, center.y, center.z);
+    glScalef(scale, scale, scale);
+
+    glLineWidth(2.5);
+    glColor3f(red, green, blue);
+    glBegin(GL_LINES);
+
+    glVertex3f(-0.5, -0.5, -0.5);
+    glVertex3f( 0.5, -0.5, -0.5);
+
+    glVertex3f(-0.5, -0.5, -0.5);
+    glVertex3f(-0.5,  0.5, -0.5);
+
+    glVertex3f(-0.5, -0.5, -0.5);
+    glVertex3f(-0.5, -0.5,  0.5);
+
+    glVertex3f(-0.5,  0.5, -0.5);
+    glVertex3f( 0.5,  0.5, -0.5);
+
+    glVertex3f(-0.5,  0.5, -0.5);
+    glVertex3f(-0.5,  0.5,  0.5);
+
+    glVertex3f( 0.5,  0.5,  0.5);
+    glVertex3f(-0.5,  0.5,  0.5);
+
+    glVertex3f( 0.5,  0.5,  0.5);
+    glVertex3f( 0.5, -0.5,  0.5);
+
+    glVertex3f( 0.5,  0.5,  0.5);
+    glVertex3f( 0.5,  0.5, -0.5);
+
+    glVertex3f( 0.5, -0.5,  0.5);
+    glVertex3f(-0.5, -0.5,  0.5);
+
+    glVertex3f( 0.5, -0.5,  0.5);
+    glVertex3f( 0.5, -0.5, -0.5);
+
+    glVertex3f( 0.5,  0.5, -0.5);
+    glVertex3f( 0.5, -0.5, -0.5);
+
+    glVertex3f(-0.5,  0.5,  0.5);
+    glVertex3f(-0.5, -0.5,  0.5);
+
+    glEnd();
+
+    glPopMatrix();
+}
+
+void NodeBounds::getColorForNodeType(NodeType_t nodeType, float& red, float& green, float& blue) {
+    red = nodeType == NodeType::VoxelServer ? 1.0 : 0.0;
+    green = nodeType == NodeType::ParticleServer ? 1.0 : 0.0;
+    blue = nodeType == NodeType::ModelServer ? 1.0 : 0.0;
+}
+
+void NodeBounds::drawOverlay() {
+    if (strlen(_overlayText) > 0) {
+        Application* application = Application::getInstance();
+
+        const float TEXT_COLOR[] = { 0.90f, 0.90f, 0.90f };
+        const float TEXT_SCALE = 0.1f;
+        const int TEXT_HEIGHT = 10;
+        const float ROTATION = 0.0f;
+        const int FONT = 2;
+        const int PADDING = 10;
+        const int MOUSE_OFFSET = 10;
+        const int BACKGROUND_OFFSET_Y = -20;
+        const int BACKGROUND_BEVEL = 3;
+
+        int mouseX = application->getMouseX(),
+            mouseY = application->getMouseY(),
+            textWidth = widthText(TEXT_SCALE, 0, _overlayText);
+        glColor4f(0.4, 0.4, 0.4, 0.6);
+        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/NodeBounds.h

@@ -0,0 +1,50 @@
+//
+//  NodeBounds.h
+//  interface/src/ui
+//
+//  Created by Ryan Huffman on 05/14/14.
+//  Copyright 2014 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+#ifndef hifi_NodeBounds_h
+#define hifi_NodeBounds_h
+
+#include <QObject>
+
+#include <NodeList.h>
+
+const int MAX_OVERLAY_TEXT_LENGTH = 64;
+
+class NodeBounds : public QObject {
+    Q_OBJECT
+public:
+    NodeBounds(QObject* parent = NULL);
+
+    bool getShowVoxelNodes() { return _showVoxelNodes; }
+    bool getShowModelNodes() { return _showModelNodes; }
+    bool getShowParticleNodes() { return _showParticleNodes; }
+
+    void draw();
+    void drawOverlay();
+
+public slots:
+    void setShowVoxelNodes(bool value) { _showVoxelNodes = value; }
+    void setShowModelNodes(bool value) { _showModelNodes = value; }
+    void setShowParticleNodes(bool value) { _showParticleNodes = value; }
+
+protected:
+    void drawNodeBorder(const glm::vec3& center, float scale, float red, float green, float blue);
+    void getColorForNodeType(NodeType_t nodeType, float& red, float& green, float& blue);
+
+private:
+    bool _showVoxelNodes;
+    bool _showModelNodes;
+    bool _showParticleNodes;
+    char _overlayText[MAX_OVERLAY_TEXT_LENGTH + 1];
+
+};
+
+#endif // hifi_NodeBounds_h