hook up menu-items to control debug rendering of collision hulls and owned simulations

interface/src/Application.cpp

@@ -164,8 +164,6 @@ const QString SKIP_FILENAME = QStandardPaths::writableLocation(QStandardPaths::D
 
 const QString DEFAULT_SCRIPTS_JS_URL = "http://s3.amazonaws.com/hifi-public/scripts/defaultScripts.js";
 
-bool renderCollisionHulls = false;
-
 #ifdef Q_OS_WIN
 class MyNativeEventFilter : public QAbstractNativeEventFilter {
 public:
@@ -1280,11 +1278,6 @@ void Application::keyPressEvent(QKeyEvent* event) {
                 break;
             }
 
-            case Qt::Key_Comma: {
-                renderCollisionHulls = !renderCollisionHulls;
-                break;
-            }
-
             default:
                 event->ignore();
                 break;
@@ -3110,13 +3103,20 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
             PerformanceTimer perfTimer("entities");
             PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
                 "Application::displaySide() ... entities...");
-            if (renderCollisionHulls) {
+
-                _entities.render(RenderArgs::DEBUG_RENDER_MODE, renderSide);
+            RenderArgs::DebugFlags renderDebugFlags = 0;
-            } else if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
+            RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE;
-                _entities.render(RenderArgs::MIRROR_RENDER_MODE, renderSide);
+
-            } else {
+            if (Menu::getInstance()->isOptionChecked(MenuOption::PhysicsShowHulls)) {
-                _entities.render(RenderArgs::DEFAULT_RENDER_MODE, renderSide);
+                renderDebugFlags |= RenderArgs::RENDER_DEBUG_HULLS;
             }
+            if (Menu::getInstance()->isOptionChecked(MenuOption::PhysicsShowOwned)) {
+                renderDebugFlags |= RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP;
+            }
+            if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
+                renderMode = RenderArgs::MIRROR_RENDER_MODE;
+            }
+            _entities.render(renderMode, renderSide, renderDebugFlags);
         }
 
         // render JS/scriptable overlays

interface/src/Menu.cpp

@@ -549,6 +549,11 @@ Menu::Menu() {
                                             statsRenderer.data(),
                                             SLOT(toggleShowInjectedStreams()));
 
+
+    QMenu* physicsOptionsMenu = developerMenu->addMenu("Physics");
+    addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowOwned);
+    addCheckableActionToQMenuAndActionHash(physicsOptionsMenu, MenuOption::PhysicsShowHulls);
+
     QMenu* helpMenu = addMenu("Help");
     addActionToQMenuAndActionHash(helpMenu, MenuOption::EditEntitiesHelp, 0, qApp, SLOT(showEditEntitiesHelp()));
 

interface/src/Menu.h

@@ -187,6 +187,8 @@ namespace MenuOption {
     const QString OnlyDisplayTopTen = "Only Display Top Ten";
     const QString PackageModel = "Package Model...";
     const QString Pair = "Pair";
+    const QString PhysicsShowOwned = "Highlight Simulation Ownership";
+    const QString PhysicsShowHulls = "Draw Collision Hulls";
     const QString PipelineWarnings = "Log Render Pipeline Warnings";
     const QString Preferences = "Preferences...";
     const QString Quit =  "Quit";

libraries/entities-renderer/src/EntityTreeRenderer.cpp

@@ -383,7 +383,9 @@ void EntityTreeRenderer::leaveAllEntities() {
         _lastAvatarPosition = _viewState->getAvatarPosition() + glm::vec3((float)TREE_SCALE);
     }
 }
-void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode, RenderArgs::RenderSide renderSide) {
+void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode,
+                                RenderArgs::RenderSide renderSide,
+                                RenderArgs::DebugFlags renderDebugFlags) {
     if (_tree && !_shuttingDown) {
         Model::startScene(renderSide);
 
@@ -391,8 +393,7 @@ void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode, RenderArgs::R
             _viewState->getShadowViewFrustum() : _viewState->getCurrentViewFrustum();
 
         RenderArgs args = { this, frustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, renderSide,
-                                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+                            renderDebugFlags, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
 
         _tree->lockForRead();
 

libraries/entities-renderer/src/EntityTreeRenderer.h

@@ -58,7 +58,8 @@ public:
 
     virtual void init();
     virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, 
-                                        RenderArgs::RenderSide renderSide = RenderArgs::MONO);
+                        RenderArgs::RenderSide renderSide = RenderArgs::MONO,
+                        RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
 
     virtual const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem);
     virtual const Model* getModelForEntityItem(const EntityItem* entityItem);

libraries/entities-renderer/src/RenderableModelEntityItem.cpp

@@ -119,12 +119,14 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
     glm::vec3 dimensions = getDimensions();
     float size = glm::length(dimensions);
 
-    auto nodeList = DependencyManager::get<NodeList>(); // XXX for debugging
+    bool highlightSimulationOwnership = false;
-    const QUuid& myNodeID = nodeList->getSessionUUID(); // XXX for debugging
+    if (args->_debugFlags & RenderArgs::RENDER_DEBUG_SIMULATION_OWNERSHIP) {
+        auto nodeList = DependencyManager::get<NodeList>();
+        const QUuid& myNodeID = nodeList->getSessionUUID();
+        highlightSimulationOwnership = (getSimulatorID() == myNodeID);
+    }
 
-    if (drawAsModel
+    if (drawAsModel && !highlightSimulationOwnership) {
-        && getSimulatorID() != myNodeID // XXX for debugging
-        ) {
         remapTextures();
         glPushMatrix();
         {

libraries/entities/src/EntityItem.cpp

@@ -1085,6 +1085,7 @@ const float MIN_ALIGNMENT_DOT = 0.999999f;
 const float MIN_VELOCITY_DELTA = 0.01f;
 const float MIN_DAMPING_DELTA = 0.001f;
 const float MIN_GRAVITY_DELTA = 0.001f;
+const float MIN_ACCELERATION_DELTA = 0.001f;
 const float MIN_SPIN_DELTA = 0.0003f;
 
 void EntityItem::updatePositionInDomainUnits(const glm::vec3& value) { 

libraries/octree/src/OctreeRenderer.cpp

@@ -164,9 +164,11 @@ bool OctreeRenderer::renderOperation(OctreeElement* element, void* extraData) {
     return false;
 }
 
-void OctreeRenderer::render(RenderArgs::RenderMode renderMode, RenderArgs::RenderSide renderSide) {
+void OctreeRenderer::render(RenderArgs::RenderMode renderMode,
+                            RenderArgs::RenderSide renderSide,
+                            RenderArgs::DebugFlags renderDebugFlags) {
     RenderArgs args = { this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, renderSide, 
-                                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+                        renderDebugFlags, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
     if (_tree) {
         _tree->lockForRead();
         _tree->recurseTreeWithOperation(renderOperation, &args);

libraries/octree/src/OctreeRenderer.h

@@ -52,7 +52,8 @@ public:
 
     /// render the content of the octree
     virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE, 
-                                RenderArgs::RenderSide renderSide = RenderArgs::MONO);
+                        RenderArgs::RenderSide renderSide = RenderArgs::MONO,
+                        RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
 
     ViewFrustum* getViewFrustum() const { return _viewFrustum; }
     void setViewFrustum(ViewFrustum* viewFrustum) { _viewFrustum = viewFrustum; }

libraries/render-utils/src/Model.cpp

@@ -1947,14 +1947,14 @@ bool Model::renderInScene(float alpha, RenderArgs* args) {
         return false;
     }
 
-    if (args->_renderMode == RenderArgs::DEBUG_RENDER_MODE && _renderCollisionHull == false) {
+    if (args->_debugFlags == RenderArgs::RENDER_DEBUG_HULLS && _renderCollisionHull == false) {
         // turning collision hull rendering on
         _renderCollisionHull = true;
         _nextGeometry = _collisionGeometry;
         _saveNonCollisionGeometry = _geometry;
         updateGeometry();
         simulate(0.0, true);
-    } else if (args->_renderMode != RenderArgs::DEBUG_RENDER_MODE && _renderCollisionHull == true) {
+    } else if (args->_debugFlags != RenderArgs::RENDER_DEBUG_HULLS && _renderCollisionHull == true) {
         // turning collision hull rendering off
         _renderCollisionHull = false;
         _nextGeometry = _saveNonCollisionGeometry;

libraries/shared/src/RenderArgs.h

@@ -17,16 +17,23 @@ class OctreeRenderer;
 
 class RenderArgs {
 public:
-    enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE, MIRROR_RENDER_MODE, DEBUG_RENDER_MODE };
+    enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE, MIRROR_RENDER_MODE };
 
     enum RenderSide { MONO, STEREO_LEFT, STEREO_RIGHT };
 
+    enum DebugFlags {
+        RENDER_DEBUG_NONE=0,
+        RENDER_DEBUG_HULLS=1,
+        RENDER_DEBUG_SIMULATION_OWNERSHIP=2
+    };
+
     OctreeRenderer* _renderer;
     ViewFrustum* _viewFrustum;
     float _sizeScale;
     int _boundaryLevelAdjust;
     RenderMode _renderMode;
     RenderSide _renderSide;
+    DebugFlags _debugFlags;
 
     int _elementsTouched;
     int _itemsRendered;