IMproving the probe system and cleaning the engine script

examples/utilities/tools/renderEngineDebug.js

@@ -10,25 +10,7 @@
 
 Script.include("cookies.js");
 
-var panel = new Panel(10, 400);
+var panel = new Panel(10, 800);
-
-panel.newCheckbox("Enable Cull Opaque", 
-    function(value) { Scene.setEngineCullOpaque((value != 0)); },
-    function() { return Scene.doEngineCullOpaque(); },
-    function(value) { return (value); }
-);
-
-panel.newCheckbox("Enable Sort Opaque", 
-    function(value) { Scene.setEngineSortOpaque((value != 0)); },
-    function() { return Scene.doEngineSortOpaque(); },
-    function(value) { return (value); }
-);
-
-panel.newCheckbox("Enable Render Opaque", 
-    function(value) { Scene.setEngineRenderOpaque((value != 0)); },
-    function() { return Scene.doEngineRenderOpaque(); },
-    function(value) { return (value); }
-);
 
 panel.newSlider("Num Feed Opaques", 0, 1000, 
     function(value) { },
@@ -48,24 +30,6 @@ panel.newSlider("Max Drawn Opaques", -1, 1000,
     function(value) { return (value); }
 );
 
-panel.newCheckbox("Enable Cull Transparent", 
-    function(value) { Scene.setEngineCullTransparent((value != 0)); },
-    function() { return Scene.doEngineCullTransparent(); },
-    function(value) { return (value); }
-);
-
-panel.newCheckbox("Enable Sort Transparent", 
-    function(value) { Scene.setEngineSortTransparent((value != 0)); },
-    function() { return Scene.doEngineSortTransparent(); },
-    function(value) { return (value); }
-);
-
-panel.newCheckbox("Enable Render Transparent", 
-    function(value) { Scene.setEngineRenderTransparent((value != 0)); },
-    function() { return Scene.doEngineRenderTransparent(); },
-    function(value) { return (value); }
-);
-
 panel.newSlider("Num Feed Transparents", 0, 100, 
     function(value) { },
     function() { return Scene.getEngineNumFeedTransparentItems(); },
@@ -84,6 +48,24 @@ panel.newSlider("Max Drawn Transparents", -1, 100,
     function(value) { return (value); }
 );
 
+panel.newSlider("Num Feed Overlay3Ds", 0, 100, 
+    function(value) { },
+    function() { return Scene.getEngineNumFeedOverlay3DItems(); },
+    function(value) { return (value); }
+);
+
+panel.newSlider("Num Drawn Overlay3Ds", 0, 100, 
+    function(value) { },
+    function() { return Scene.getEngineNumDrawnOverlay3DItems(); },
+    function(value) { return (value); }
+);
+
+panel.newSlider("Max Drawn Overlay3Ds", -1, 100, 
+    function(value) { Scene.setEngineMaxDrawnOverlay3DItems(value); },
+    function() { return Scene.getEngineMaxDrawnOverlay3DItems(); },
+    function(value) { return (value); }
+);
+
 var tickTackPeriod = 500;
 
 function updateCounters() {
@@ -91,6 +73,8 @@ function updateCounters() {
         panel.set("Num Drawn Opaques", panel.get("Num Drawn Opaques"));
         panel.set("Num Feed Transparents", panel.get("Num Feed Transparents"));
         panel.set("Num Drawn Transparents", panel.get("Num Drawn Transparents"));
+        panel.set("Num Feed Overlay3Ds", panel.get("Num Feed Overlay3Ds"));
+        panel.set("Num Drawn Overlay3Ds", panel.get("Num Drawn Overlay3Ds"));        
 }
 Script.setInterval(updateCounters, tickTackPeriod);
 

interface/src/Application.cpp

@@ -3541,6 +3541,7 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
 
         renderContext._maxDrawnOpaqueItems = sceneInterface->getEngineMaxDrawnOpaqueItems();
         renderContext._maxDrawnTransparentItems = sceneInterface->getEngineMaxDrawnTransparentItems();
+        renderContext._maxDrawnOverlay3DItems = sceneInterface->getEngineMaxDrawnOverlay3DItems();
 
         renderArgs->_shouldRender = LODManager::shouldRender;
 
@@ -3557,7 +3558,9 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
 
         sceneInterface->setEngineFeedTransparentItems(engineRC->_numFeedTransparentItems);
         sceneInterface->setEngineDrawnTransparentItems(engineRC->_numDrawnTransparentItems);
-        
+
+        sceneInterface->setEngineFeedOverlay3DItems(engineRC->_numFeedOverlay3DItems);
+        sceneInterface->setEngineDrawnOverlay3DItems(engineRC->_numDrawnOverlay3DItems);
     }
     //Render the sixense lasers
     if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)) {

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -38,22 +38,35 @@ void ResolveDeferred::run(const SceneContextPointer& sceneContext, const RenderC
 }
 
 RenderDeferredTask::RenderDeferredTask() : Task() {
-   _jobs.push_back(Job(new PrepareDeferred::JobModel("PrepareDeferred")));
+    _jobs.push_back(Job(new PrepareDeferred::JobModel("PrepareDeferred")));
-   _jobs.push_back(Job(new DrawBackground::JobModel("DrawBackground")));
+    _jobs.push_back(Job(new DrawBackground::JobModel("DrawBackground")));
-   _jobs.push_back(Job(new FetchItems::JobModel("FetchOpaque", FetchItems())));
+    _jobs.push_back(Job(new FetchItems::JobModel("FetchOpaque",
-   _jobs.push_back(Job(new CullItems::JobModel("CullOpaque", _jobs.back().getOutput())));
+        FetchItems(
-   _jobs.push_back(Job(new DepthSortItems::JobModel("DepthSortOpaque", _jobs.back().getOutput())));
+            [] (const RenderContextPointer& context, int count) {
-   _jobs.push_back(Job(new DrawOpaqueDeferred::JobModel("DrawOpaqueDeferred", _jobs.back().getOutput())));
+                context->_numFeedOpaqueItems = count; 
-   _jobs.push_back(Job(new DrawLight::JobModel("DrawLight")));
+            }
-   _jobs.push_back(Job(new ResetGLState::JobModel()));
+        )
-   _jobs.push_back(Job(new RenderDeferred::JobModel("RenderDeferred")));
+    )));
-   _jobs.push_back(Job(new ResolveDeferred::JobModel("ResolveDeferred")));
+    _jobs.push_back(Job(new CullItems::JobModel("CullOpaque", _jobs.back().getOutput())));
-   _jobs.push_back(Job(new FetchItems::JobModel("FetchTransparent", FetchItems(ItemFilter::Builder::transparentShape().withoutLayered()))));
+    _jobs.push_back(Job(new DepthSortItems::JobModel("DepthSortOpaque", _jobs.back().getOutput())));
-   _jobs.push_back(Job(new CullItems::JobModel("CullTransparent", _jobs.back().getOutput())));
+    _jobs.push_back(Job(new DrawOpaqueDeferred::JobModel("DrawOpaqueDeferred", _jobs.back().getOutput())));
-   _jobs.push_back(Job(new DepthSortItems::JobModel("DepthSortTransparent", _jobs.back().getOutput(), DepthSortItems(false))));
+    _jobs.push_back(Job(new DrawLight::JobModel("DrawLight")));
-   _jobs.push_back(Job(new DrawTransparentDeferred::JobModel("TransparentDeferred", _jobs.back().getOutput())));
+    _jobs.push_back(Job(new ResetGLState::JobModel()));
-   _jobs.push_back(Job(new DrawOverlay3D::JobModel("DrawOverlay3D")));
+    _jobs.push_back(Job(new RenderDeferred::JobModel("RenderDeferred")));
-   _jobs.push_back(Job(new ResetGLState::JobModel()));
+    _jobs.push_back(Job(new ResolveDeferred::JobModel("ResolveDeferred")));
+    _jobs.push_back(Job(new FetchItems::JobModel("FetchTransparent",
+         FetchItems(
+            ItemFilter::Builder::transparentShape().withoutLayered(),
+            [] (const RenderContextPointer& context, int count) {
+                context->_numFeedTransparentItems = count; 
+            }
+         )
+     )));
+    _jobs.push_back(Job(new CullItems::JobModel("CullTransparent", _jobs.back().getOutput())));
+    _jobs.push_back(Job(new DepthSortItems::JobModel("DepthSortTransparent", _jobs.back().getOutput(), DepthSortItems(false))));
+    _jobs.push_back(Job(new DrawTransparentDeferred::JobModel("TransparentDeferred", _jobs.back().getOutput())));
+    _jobs.push_back(Job(new DrawOverlay3D::JobModel("DrawOverlay3D")));
+    _jobs.push_back(Job(new ResetGLState::JobModel()));
 }
 
 RenderDeferredTask::~RenderDeferredTask() {
@@ -191,7 +204,9 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
             inItems.emplace_back(id);
         }
     }
- 
+    renderContext->_numFeedOverlay3DItems = inItems.size();
+    renderContext->_numDrawnOverlay3DItems = inItems.size();
+
     RenderArgs* args = renderContext->args;
     gpu::Batch batch;
     args->_batch = &batch;
@@ -212,7 +227,7 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
 
     if (!inItems.empty()) {
         batch.clearFramebuffer(gpu::Framebuffer::BUFFER_DEPTH, glm::vec4(), 1.f, 0);
-        renderItems(sceneContext, renderContext, inItems);
+        renderItems(sceneContext, renderContext, inItems, renderContext->_maxDrawnOverlay3DItems);
     }
 
     // Before rendering the batch make sure we re in sync with gl state

libraries/render/src/render/DrawTask.cpp

@@ -107,13 +107,12 @@ void FetchItems::run(const SceneContextPointer& sceneContext, const RenderContex
     outItems.reserve(items.size());
     for (auto id : items) {
         auto& item = scene->getItem(id);
-      /*  AABox bound;
-        {
-      //      PerformanceTimer perfTimer("getBound");
-            bound = item.getBound();
-        }*/
         outItems.emplace_back(ItemIDAndBounds(id, item.getBound()));
     }
+
+    if (_probeNumItems) {
+        _probeNumItems(renderContext, outItems.size());
+    }
 }
 
 void CullItems::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems, ItemIDsBounds& outItems) {

libraries/render/src/render/DrawTask.h

@@ -195,11 +195,12 @@ void renderItems(const SceneContextPointer& sceneContext, const RenderContextPoi
 
 class FetchItems {
 public:
-
+    typedef std::function<void (const RenderContextPointer& context, int count)> ProbeNumItems;
-    FetchItems() {}
+    FetchItems(const ProbeNumItems& probe): _probeNumItems(probe) {}
-    FetchItems(const ItemFilter& filter): _filter(filter) {}
+    FetchItems(const ItemFilter& filter, const ProbeNumItems& probe): _filter(filter), _probeNumItems(probe) {}
 
     ItemFilter _filter = ItemFilter::Builder::opaqueShape().withoutLayered();
+    ProbeNumItems _probeNumItems;
 
     void run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, ItemIDsBounds& outItems);
 

libraries/render/src/render/Engine.h

@@ -45,6 +45,10 @@ public:
     int _numDrawnTransparentItems = 0;
     int _maxDrawnTransparentItems = -1;
 
+    int _numFeedOverlay3DItems = 0;
+    int _numDrawnOverlay3DItems = 0;
+    int _maxDrawnOverlay3DItems = -1;
+
     RenderContext() {}
 };
 typedef std::shared_ptr<RenderContext> RenderContextPointer;

libraries/script-engine/src/SceneScriptingInterface.cpp

@@ -159,4 +159,6 @@ void SceneScriptingInterface::clearEngineCounters() {
     _numDrawnOpaqueItems = 0;
     _numFeedTransparentItems = 0;
     _numDrawnTransparentItems = 0;
+    _numFeedOverlay3DItems = 0;
+    _numDrawnOverlay3DItems = 0;
 }

libraries/script-engine/src/SceneScriptingInterface.h

@@ -90,17 +90,22 @@ public:
     Q_INVOKABLE int getEngineNumDrawnOpaqueItems() { return _numDrawnOpaqueItems; }
     void setEngineDrawnTransparentItems(int count) { _numDrawnTransparentItems = count; }
     Q_INVOKABLE int getEngineNumDrawnTransparentItems() { return _numDrawnTransparentItems; }
+    void setEngineDrawnOverlay3DItems(int count) { _numDrawnOverlay3DItems = count; }
+    Q_INVOKABLE int getEngineNumDrawnOverlay3DItems() { return _numDrawnOverlay3DItems; }
 
     void setEngineFeedOpaqueItems(int count) { _numFeedOpaqueItems = count; }
     Q_INVOKABLE int getEngineNumFeedOpaqueItems() { return _numFeedOpaqueItems; }
     void setEngineFeedTransparentItems(int count) { _numFeedTransparentItems = count; }
     Q_INVOKABLE int getEngineNumFeedTransparentItems() { return _numFeedTransparentItems; }
+    void setEngineFeedOverlay3DItems(int count) { _numFeedOverlay3DItems = count; }
+    Q_INVOKABLE int getEngineNumFeedOverlay3DItems() { return _numFeedOverlay3DItems; }
 
     Q_INVOKABLE void setEngineMaxDrawnOpaqueItems(int count) { _maxDrawnOpaqueItems = count; }
     Q_INVOKABLE int getEngineMaxDrawnOpaqueItems() { return _maxDrawnOpaqueItems; }
     Q_INVOKABLE void setEngineMaxDrawnTransparentItems(int count) { _maxDrawnTransparentItems = count; }
     Q_INVOKABLE int getEngineMaxDrawnTransparentItems() { return _maxDrawnTransparentItems; }
-
+    Q_INVOKABLE void setEngineMaxDrawnOverlay3DItems(int count) { _maxDrawnOverlay3DItems = count; }
+    Q_INVOKABLE int getEngineMaxDrawnOverlay3DItems() { return _maxDrawnOverlay3DItems; }
 signals:
     void shouldRenderAvatarsChanged(bool shouldRenderAvatars);
     void shouldRenderEntitiesChanged(bool shouldRenderEntities);
@@ -124,9 +129,12 @@ protected:
     int _numDrawnOpaqueItems = 0;
     int _numFeedTransparentItems = 0;
     int _numDrawnTransparentItems = 0;
+    int _numFeedOverlay3DItems = 0;
+    int _numDrawnOverlay3DItems = 0;
 
     int _maxDrawnOpaqueItems = -1;
     int _maxDrawnTransparentItems = -1;
+    int _maxDrawnOverlay3DItems = -1;
 
 };