add menu item to enable/disable rendering as scene

interface/src/Menu.cpp

@@ -438,10 +438,15 @@ Menu::Menu() :
     addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::DisplayModelElementChildProxies, 0, false);
     addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::DisableLightEntities, 0, false);
 
+    addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::DontReduceMaterialSwitches, 0, false);
+    addCheckableActionToQMenuAndActionHash(entitiesDebugMenu, MenuOption::DontRenderEntitiesAsScene, 0, false);
+
     QMenu* entityCullingMenu = entitiesDebugMenu->addMenu("Culling");
     addCheckableActionToQMenuAndActionHash(entityCullingMenu, MenuOption::DontCullOutOfViewMeshParts, 0, false);
     addCheckableActionToQMenuAndActionHash(entityCullingMenu, MenuOption::DontCullTooSmallMeshParts, 0, false);
-    addCheckableActionToQMenuAndActionHash(entityCullingMenu, MenuOption::DontReduceMaterialSwitches, 0, false);
+
+    
+    
     
     QMenu* voxelOptionsMenu = developerMenu->addMenu("Voxels");
     addCheckableActionToQMenuAndActionHash(voxelOptionsMenu, MenuOption::VoxelTextures);

interface/src/Menu.h

@@ -378,6 +378,7 @@ namespace MenuOption {
     const QString DontCullOutOfViewMeshParts = "Don't Cull Out Of View Mesh Parts";
     const QString DontCullTooSmallMeshParts = "Don't Cull Too Small Mesh Parts";
     const QString DontReduceMaterialSwitches = "Don't Attempt to Reduce Material Switches";
+    const QString DontRenderEntitiesAsScene = "Don't Render Entities as Scene";
     const QString DecreaseAvatarSize = "Decrease Avatar Size";
     const QString DecreaseVoxelSize = "Decrease Voxel Size";
     const QString DisableActivityLogger = "Disable Activity Logger";

interface/src/entities/EntityTreeRenderer.cpp

@@ -253,40 +253,43 @@ void EntityTreeRenderer::checkEnterLeaveEntities() {
 }
 
 void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode) {
-    Model::startScene();
+    bool dontRenderAsScene = Menu::getInstance()->isOptionChecked(MenuOption::DontRenderEntitiesAsScene);
-    //OctreeRenderer::render(renderMode);
     
-    RenderArgs args = { this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, 
+    if (dontRenderAsScene) {
-                                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        OctreeRenderer::render(renderMode);
-    if (_tree) {
+    } else {
-        _tree->lockForRead();
+        Model::startScene();
-        _tree->recurseTreeWithOperation(renderOperation, &args);
+        RenderArgs args = { this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(), renderMode, 
-        _tree->unlock();
+                                            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        if (_tree) {
+            _tree->lockForRead();
+            _tree->recurseTreeWithOperation(renderOperation, &args);
+            _tree->unlock();
+        }
+
+        Model::RenderMode modelRenderMode = renderMode == RenderArgs::SHADOW_RENDER_MODE
+                                            ? Model::SHADOW_RENDER_MODE : Model::DEFAULT_RENDER_MODE;
+    
+        Model::endScene(modelRenderMode, &args);
+        
+        // stats...
+        _meshesConsidered = args._meshesConsidered;
+        _meshesRendered = args._meshesRendered;
+        _meshesOutOfView = args._meshesOutOfView;
+        _meshesTooSmall = args._meshesTooSmall;
+
+        _elementsTouched = args._elementsTouched;
+        _itemsRendered = args._itemsRendered;
+        _itemsOutOfView = args._itemsOutOfView;
+        _itemsTooSmall = args._itemsTooSmall;
+
+        _materialSwitches = args._materialSwitches;
+        _trianglesRendered = args._trianglesRendered;
+        _quadsRendered = args._quadsRendered;
+
+        _translucentMeshPartsRendered = args._translucentMeshPartsRendered;
+        _opaqueMeshPartsRendered = args._opaqueMeshPartsRendered;
     }
-
-    Model::RenderMode modelRenderMode = renderMode == RenderArgs::SHADOW_RENDER_MODE
-                                        ? Model::SHADOW_RENDER_MODE : Model::DEFAULT_RENDER_MODE;
-    
-    Model::endScene(modelRenderMode, &args);
-    
-    // stats...
-    _meshesConsidered = args._meshesConsidered;
-    _meshesRendered = args._meshesRendered;
-    _meshesOutOfView = args._meshesOutOfView;
-    _meshesTooSmall = args._meshesTooSmall;
-
-    _elementsTouched = args._elementsTouched;
-    _itemsRendered = args._itemsRendered;
-    _itemsOutOfView = args._itemsOutOfView;
-    _itemsTooSmall = args._itemsTooSmall;
-
-    _materialSwitches = args._materialSwitches;
-    _trianglesRendered = args._trianglesRendered;
-    _quadsRendered = args._quadsRendered;
-
-    _translucentMeshPartsRendered = args._translucentMeshPartsRendered;
-    _opaqueMeshPartsRendered = args._opaqueMeshPartsRendered;
-    
     deleteReleasedModels(); // seems like as good as any other place to do some memory cleanup
 }
 

interface/src/entities/RenderableModelEntityItem.cpp

@@ -172,8 +172,12 @@ void RenderableModelEntityItem::render(RenderArgs* args) {
                     // TODO: this is the majority of model render time. And rendering of a cube model vs the basic Box render
                     // is significantly more expensive. Is there a way to call this that doesn't cost us as much? 
                     PerformanceTimer perfTimer("model->render");
-                    //_model->render(alpha, modelRenderMode, args);
+                    bool dontRenderAsScene = Menu::getInstance()->isOptionChecked(MenuOption::DontRenderEntitiesAsScene);
-                    _model->renderInScene(alpha, args);
+                    if (dontRenderAsScene) {
+                        _model->render(alpha, modelRenderMode, args);
+                    } else {
+                        _model->renderInScene(alpha, args);
+                    }
                 } else {
                     // if we couldn't get a model, then just draw a cube
                     glColor3ub(getColor()[RED_INDEX],getColor()[GREEN_INDEX],getColor()[BLUE_INDEX]);