Avoiding any setVIewTransform in payloadREnder and introducing monitoring values

examples/utilities/tools/cookies.js

@@ -134,7 +134,7 @@ Slider = function(x,y,width,thumbSize) {
 }
 
 // The Checkbox class
-Checkbox = function(x,y,width,thumbSize) {
+Checkbox = function(x,y,thumbSize) {
 
     this.thumb = Overlays.addOverlay("text", {
                     backgroundColor: { red: 255, green: 255, blue: 255 },
@@ -150,7 +150,7 @@ Checkbox = function(x,y,width,thumbSize) {
                     backgroundColor: { red: 125, green: 125, blue: 255 },
                     x: x,
                     y: y,
-                    width: width,
+                    width: thumbSize * 2,
                     height: thumbSize,
                     alpha: 1.0,
                     backgroundAlpha: 0.5,
@@ -161,7 +161,7 @@ Checkbox = function(x,y,width,thumbSize) {
     this.thumbHalfSize = 0.5 * thumbSize;
 
     this.minThumbX = x + this.thumbHalfSize;
-    this.maxThumbX = x + width - this.thumbHalfSize;
+    this.maxThumbX = x + thumbSize * 2 - this.thumbHalfSize;
     this.thumbX = this.minThumbX;
 
     this.minValue = 0.0;
@@ -553,7 +553,7 @@ Panel = function(x, y) {
 
         var item = new PanelItem(name, setValue, getValue, displayValue, this.x, this.nextY, textWidth, valueWidth, rawHeight);
 
-        var checkbox = new Checkbox(this.widgetX, this.nextY, widgetWidth, rawHeight);
+        var checkbox = new Checkbox(this.widgetX, this.nextY, rawHeight);
  
         item.widget = checkbox;
         item.widget.onValueChanged = function(value) { item.setterFromWidget(value); };

examples/utilities/tools/renderEngineDebug.js

@@ -0,0 +1,92 @@
+//
+//  SunLightExample.js
+//  examples
+//  Sam Gateau
+//  Copyright 2015 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
+//
+
+Script.include("cookies.js");
+
+var panel = new Panel(10, 400);
+
+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) { },
+    function() { return Scene.getEngineNumFeedOpaqueItems(); },
+    function(value) { return (value); }
+);
+
+panel.newSlider("Num Drawn Opaques", 0, 1000, 
+    function(value) { },
+    function() { return Scene.getEngineNumDrawnOpaqueItems(); },
+    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, 1000, 
+    function(value) { },
+    function() { return Scene.getEngineNumFeedTransparentItems(); },
+    function(value) { return (value); }
+);
+
+panel.newSlider("Num Drawn Transparents", 0, 1000, 
+    function(value) { },
+    function() { return Scene.getEngineNumDrawnTransparentItems(); },
+    function(value) { return (value); }
+);
+
+var tickTackPeriod = 500;
+
+function updateCounters() {
+        panel.set("Num Feed Opaques", panel.get("Num Feed Opaques"));
+        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"));
+}
+Script.setInterval(updateCounters, tickTackPeriod);
+
+Controller.mouseMoveEvent.connect(function panelMouseMoveEvent(event) { return panel.mouseMoveEvent(event); });
+Controller.mousePressEvent.connect( function panelMousePressEvent(event) { return panel.mousePressEvent(event); });
+Controller.mouseReleaseEvent.connect(function(event) { return panel.mouseReleaseEvent(event); });
+
+function scriptEnding() {
+    panel.destroy();
+}
+Script.scriptEnding.connect(scriptEnding);

interface/src/Application.cpp

@@ -3519,6 +3519,12 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
         qDebug() << "renderArgs._trianglesRendered:" << renderArgs->_trianglesRendered;
         qDebug() << "renderArgs._quadsRendered:" << renderArgs->_quadsRendered;
         */
+        auto engineRC = _renderEngine->getRenderContext();
+        sceneInterface->setEngineFeedOpaqueItems(engineRC->_numFeedOpaqueItems);
+        sceneInterface->setEngineDrawnOpaqueItems(engineRC->_numDrawnOpaqueItems);
+
+        sceneInterface->setEngineFeedTransparentItems(engineRC->_numFeedTransparentItems);
+        sceneInterface->setEngineDrawnTransparentItems(engineRC->_numDrawnTransparentItems);
 
     }
 

libraries/render-utils/src/Model.cpp

@@ -918,6 +918,8 @@ bool Model::render(RenderArgs* renderArgs, float alpha) {
 }
 
 bool Model::renderCore(RenderArgs* args, float alpha) {
+  return true;
+  
     PROFILE_RANGE(__FUNCTION__);
     if (!_viewState) {
         return false;
@@ -2242,12 +2244,12 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
     }
 
   //  _transforms[0] = _viewState->getViewTransform();
-    args->_viewFrustum->evalViewTransform(_transforms[0]);
+   // args->_viewFrustum->evalViewTransform(_transforms[0]);
 
     // apply entity translation offset to the viewTransform  in one go (it's a preTranslate because viewTransform goes from world to eye space)
-    _transforms[0].preTranslate(-_translation);
+  //  _transforms[0].setTranslation(_translation);
 
-    batch.setViewTransform(_transforms[0]);
+   // batch.setViewTransform(_transforms[0]);
 
 
   //  const float OPAQUE_ALPHA_THRESHOLD = 0.5f;
@@ -2298,10 +2300,17 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran
     if (state.clusterMatrices.size() > 1) {
         GLBATCH(glUniformMatrix4fv)(locations->clusterMatrices, state.clusterMatrices.size(), false,
             (const float*)state.clusterMatrices.constData());
-        batch.setModelTransform(Transform());
+ //       batch.setModelTransform(Transform());
+       _transforms[0].setTranslation(_translation);
+
     } else {
-        batch.setModelTransform(Transform(state.clusterMatrices[0]));
+       _transforms[0] = Transform(state.clusterMatrices[0]);
+       _transforms[0].preTranslate(_translation);
+
+        //batch.setModelTransform(Transform(state.clusterMatrices[0]));
     }
+    batch.setModelTransform(_transforms[0]);
+
 
     if (mesh.blendshapes.isEmpty()) {
         batch.setInputFormat(networkMesh._vertexFormat);

libraries/render/src/render/DrawTask.cpp

@@ -223,12 +223,17 @@ template <> void render::jobRun(const DrawOpaque& job, const SceneContextPointer
     }
     ItemIDs& renderedItems = inItems;
 
+    renderContext->_numFeedOpaqueItems = renderedItems.size();
+
     ItemIDs culledItems;
     if (renderContext->_cullOpaque) {
         cullItems(sceneContext, renderContext, renderedItems, culledItems);
         renderedItems = culledItems;
     }
 
+    renderContext->_numDrawnOpaqueItems = renderedItems.size();
+
+
     ItemIDs sortedItems;
     if (renderContext->_sortOpaque) {
         depthSortItems(sceneContext, renderContext, true, renderedItems, sortedItems); // Sort Front to back opaque items!
@@ -277,16 +282,20 @@ template <> void render::jobRun(const DrawTransparent& job, const SceneContextPo
     ItemIDs inItems;
     inItems.reserve(items.size());
     for (auto id : items) {
-  //      inItems.push_back(id);
+        inItems.push_back(id);
     }
     ItemIDs& renderedItems = inItems;
 
+    renderContext->_numFeedTransparentItems = renderedItems.size();
+
     ItemIDs culledItems;
     if (renderContext->_cullTransparent) {
         cullItems(sceneContext, renderContext, inItems, culledItems);
         renderedItems = culledItems;
     }
 
+    renderContext->_numDrawnTransparentItems = renderedItems.size();
+
     ItemIDs sortedItems;
     if (renderContext->_sortTransparent) {
         depthSortItems(sceneContext, renderContext, false, renderedItems, sortedItems); // Sort Back to front transparent items!

libraries/render/src/render/Engine.h

@@ -37,6 +37,12 @@ public:
     bool _sortTransparent = true;
     bool _renderTransparent = true;
 
+    int _numFeedOpaqueItems = 0;
+    int _numDrawnOpaqueItems = 0;
+    
+    int _numFeedTransparentItems = 0;
+    int _numDrawnTransparentItems = 0;
+
     RenderContext() {}
 };
 typedef std::shared_ptr<RenderContext> RenderContextPointer;
@@ -67,6 +73,7 @@ public:
 
     // Push a RenderContext
     void setRenderContext(const RenderContext& renderContext);
+    RenderContextPointer getRenderContext() const { return _renderContext; }
 
     void addTask(const TaskPointer& task);
     const Tasks& getTasks() const { return _tasks; }

libraries/script-engine/src/SceneScriptingInterface.cpp

@@ -153,3 +153,10 @@ void SceneScriptingInterface::setEngineSortOpaque(bool sortOpaque) {
 void SceneScriptingInterface::setEngineSortTransparent(bool sortTransparent) {
     _engineSortOpaque = sortTransparent;
 }
+
+void SceneScriptingInterface::clearEngineCounters() {
+    _numFeedOpaqueItems = 0;
+    _numDrawnOpaqueItems = 0;
+    _numFeedTransparentItems = 0;
+    _numDrawnTransparentItems = 0;
+}

libraries/script-engine/src/SceneScriptingInterface.h

@@ -85,6 +85,18 @@ public:
     Q_INVOKABLE void setEngineSortTransparent(bool sortTransparent);
     Q_INVOKABLE bool doEngineSortTransparent() const { return _engineSortTransparent; }
 
+    void clearEngineCounters();
+    void setEngineDrawnOpaqueItems(int count) { _numDrawnOpaqueItems = count; }
+    Q_INVOKABLE int getEngineNumDrawnOpaqueItems() { return _numDrawnOpaqueItems; }
+    void setEngineDrawnTransparentItems(int count) { _numDrawnTransparentItems = count; }
+    Q_INVOKABLE int getEngineNumDrawnTransparentItems() { return _numDrawnTransparentItems; }
+
+    void setEngineFeedOpaqueItems(int count) { _numFeedOpaqueItems = count; }
+    Q_INVOKABLE int getEngineNumFeedOpaqueItems() { return _numFeedOpaqueItems; }
+    void setEngineFeedTransparentItems(int count) { _numFeedTransparentItems = count; }
+    Q_INVOKABLE int getEngineNumFeedTransparentItems() { return _numFeedTransparentItems; }
+
+
 signals:
     void shouldRenderAvatarsChanged(bool shouldRenderAvatars);
     void shouldRenderEntitiesChanged(bool shouldRenderEntities);
@@ -104,6 +116,10 @@ protected:
     bool _engineSortOpaque = true;
     bool _engineSortTransparent = true;
 
+    int _numFeedOpaqueItems = 0;
+    int _numDrawnOpaqueItems = 0;
+    int _numFeedTransparentItems = 0;
+    int _numDrawnTransparentItems = 0;
 };
 
 #endif // hifi_SceneScriptingInterface_h