exposing some controls on the engine to js for debugging

interface/src/Application.cpp

@@ -3496,6 +3496,15 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
         PerformanceTimer perfTimer("EngineRun");
         render::RenderContext renderContext;
 
+        auto sceneInterface = DependencyManager::get<SceneScriptingInterface>();
+
+        renderContext._cullOpaque = sceneInterface->doEngineCullOpaque();
+        renderContext._sortOpaque = sceneInterface->doEngineSortOpaque();
+        renderContext._renderOpaque = sceneInterface->doEngineRenderOpaque();
+        renderContext._cullTransparent = sceneInterface->doEngineCullTransparent();
+        renderContext._sortTransparent = sceneInterface->doEngineSortTransparent();
+        renderContext._renderTransparent = sceneInterface->doEngineRenderTransparent();
+
         renderArgs->_shouldRender = LODManager::shouldRender;
 
         renderContext.args = renderArgs;

libraries/render-utils/src/Model.cpp

@@ -858,6 +858,9 @@ namespace render {
 
 bool Model::addToScene(std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
     bool somethingAdded = false;
+
+    qDebug() << "Model::addToScene : " << this->getURL().toString();
+
     // allow the attachments to add to scene
     foreach (Model* attachment, _attachments) {
         bool attachementSomethingAdded = attachment->addToScene(scene, pendingChanges);
@@ -894,6 +897,9 @@ void Model::removeFromScene(std::shared_ptr<render::Scene> scene, render::Pendin
         pendingChanges.removeItem(item);
     }
     _renderItems.clear();
+
+    qDebug() << "Model::removeFromScene : " << this->getURL().toString();
+
 }
 
 bool Model::render(RenderArgs* renderArgs, float alpha) {

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -34,6 +34,7 @@ RenderDeferredTask::RenderDeferredTask() : Task() {
    _jobs.push_back(Job(DrawOpaque()));
    _jobs.push_back(Job(DrawLight()));
    _jobs.push_back(Job(DrawTransparent()));
+   _jobs.push_back(Job(ResetGLState()));
    _jobs.push_back(Job(ResolveDeferred()));
 
 }

libraries/render/src/render/DrawTask.cpp

@@ -29,6 +29,7 @@ DrawSceneTask::DrawSceneTask() : Task() {
     _jobs.push_back(Job(DrawOpaque()));
     _jobs.push_back(Job(DrawLight()));
     _jobs.push_back(Job(DrawTransparent()));
+    _jobs.push_back(Job(ResetGLState()));
 }
 
 DrawSceneTask::~DrawSceneTask() {
@@ -198,6 +199,13 @@ void addClearStateCommands(gpu::Batch& batch) {
     batch._glUseProgram(0);
 }
 
+template <> void render::jobRun(const ResetGLState& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
+
+    gpu::Batch theBatch;
+    addClearStateCommands(theBatch);
+    assert(renderContext->args);
+    renderContext->args->_context->render(theBatch);
+}
 
 template <> void render::jobRun(const DrawOpaque& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
     PerformanceTimer perfTimer("DrawOpaque");
@@ -216,39 +224,44 @@ template <> void render::jobRun(const DrawOpaque& job, const SceneContextPointer
     ItemIDs& renderedItems = inItems;
 
     ItemIDs culledItems;
-    cullItems(sceneContext, renderContext, inItems, culledItems);
-    renderedItems = culledItems;
-
-    ItemIDs sortedItems;
-    depthSortItems(sceneContext, renderContext, true, culledItems, sortedItems); // Sort Front to back opaque items!
-    renderedItems = sortedItems;
-
-
-    RenderArgs* args = renderContext->args;
-    gpu::Batch batch;
-    args->_batch = &batch;
-
-    glm::mat4 projMat;
-    Transform viewMat;
-    args->_viewFrustum->evalProjectionMatrix(projMat);
-    args->_viewFrustum->evalViewTransform(viewMat);
-    batch.setProjectionTransform(projMat);
-    batch.setViewTransform(viewMat);
-
-    renderContext->args->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
-    {
-        GLenum buffers[3];
-        int bufferCount = 0;
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
-        batch._glDrawBuffers(bufferCount, buffers);
+    if (renderContext->_cullOpaque) {
+        cullItems(sceneContext, renderContext, renderedItems, culledItems);
+        renderedItems = culledItems;
     }
 
-    renderItems(sceneContext, renderContext, renderedItems);
+    ItemIDs sortedItems;
+    if (renderContext->_sortOpaque) {
+        depthSortItems(sceneContext, renderContext, true, renderedItems, sortedItems); // Sort Front to back opaque items!
+        renderedItems = sortedItems;
+    }
 
-    args->_context->render((*args->_batch));
-    args->_batch = nullptr;
+    if (renderContext->_renderOpaque) {
+        RenderArgs* args = renderContext->args;
+        gpu::Batch batch;
+        args->_batch = &batch;
+
+        glm::mat4 projMat;
+        Transform viewMat;
+        args->_viewFrustum->evalProjectionMatrix(projMat);
+        args->_viewFrustum->evalViewTransform(viewMat);
+        batch.setProjectionTransform(projMat);
+        batch.setViewTransform(viewMat);
+
+        renderContext->args->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
+        {
+            GLenum buffers[3];
+            int bufferCount = 0;
+            buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
+            buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
+            buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
+            batch._glDrawBuffers(bufferCount, buffers);
+        }
+
+        renderItems(sceneContext, renderContext, renderedItems);
+
+        args->_context->render((*args->_batch));
+        args->_batch = nullptr;
+    }
 }
 
 
@@ -269,55 +282,60 @@ template <> void render::jobRun(const DrawTransparent& job, const SceneContextPo
     ItemIDs& renderedItems = inItems;
 
     ItemIDs culledItems;
-    cullItems(sceneContext, renderContext, inItems, culledItems);
-    renderedItems = culledItems;
-
-    ItemIDs sortedItems;
-    depthSortItems(sceneContext, renderContext, false, culledItems, sortedItems); // Sort Back to front transparent items!
-    renderedItems = sortedItems;
-
-    RenderArgs* args = renderContext->args;
-    gpu::Batch batch;
-    args->_batch = &batch;
-
-    glm::mat4 projMat;
-    Transform viewMat;
-    args->_viewFrustum->evalProjectionMatrix(projMat);
-    args->_viewFrustum->evalViewTransform(viewMat);
-    batch.setProjectionTransform(projMat);
-    batch.setViewTransform(viewMat);
-
-    args->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
-
-    const float MOSTLY_OPAQUE_THRESHOLD = 0.75f;
-    const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f;
-
-    // render translucent meshes afterwards
-    {
-        GLenum buffers[2];
-        int bufferCount = 0;
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
-        batch._glDrawBuffers(bufferCount, buffers);
-        args->_alphaThreshold = MOSTLY_OPAQUE_THRESHOLD;
-     }
-
-    renderItems(sceneContext, renderContext, renderedItems);
-
-    {
-        GLenum buffers[3];
-        int bufferCount = 0;
-        buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
-        batch._glDrawBuffers(bufferCount, buffers);
-        args->_alphaThreshold = TRANSPARENT_ALPHA_THRESHOLD;
+    if (renderContext->_cullTransparent) {
+        cullItems(sceneContext, renderContext, inItems, culledItems);
+        renderedItems = culledItems;
     }
 
+    ItemIDs sortedItems;
+    if (renderContext->_sortTransparent) {
+        depthSortItems(sceneContext, renderContext, false, renderedItems, sortedItems); // Sort Back to front transparent items!
+        renderedItems = sortedItems;
+    }
 
-    renderItems(sceneContext, renderContext, renderedItems);
+    if (renderContext->_renderTransparent) {
+        RenderArgs* args = renderContext->args;
+        gpu::Batch batch;
+        args->_batch = &batch;
 
-    addClearStateCommands((*args->_batch));
-    args->_context->render((*args->_batch));
-    args->_batch = nullptr;
+        glm::mat4 projMat;
+        Transform viewMat;
+        args->_viewFrustum->evalProjectionMatrix(projMat);
+        args->_viewFrustum->evalViewTransform(viewMat);
+        batch.setProjectionTransform(projMat);
+        batch.setViewTransform(viewMat);
+
+        args->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
+
+        const float MOSTLY_OPAQUE_THRESHOLD = 0.75f;
+        const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f;
+
+        // render translucent meshes afterwards
+        {
+            GLenum buffers[2];
+            int bufferCount = 0;
+            buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
+            buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
+            batch._glDrawBuffers(bufferCount, buffers);
+            args->_alphaThreshold = MOSTLY_OPAQUE_THRESHOLD;
+         }
+
+        renderItems(sceneContext, renderContext, renderedItems);
+
+        {
+            GLenum buffers[3];
+            int bufferCount = 0;
+            buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
+            batch._glDrawBuffers(bufferCount, buffers);
+            args->_alphaThreshold = TRANSPARENT_ALPHA_THRESHOLD;
+        }
+
+
+        renderItems(sceneContext, renderContext, renderedItems);
+
+        args->_context->render((*args->_batch));
+        args->_batch = nullptr;
+    }
 }
 
 template <> void render::jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {

libraries/render/src/render/DrawTask.h

@@ -83,6 +83,11 @@ public:
 };
 template <> void jobRun(const DrawBackground& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
 
+class ResetGLState {
+public:
+};
+template <> void jobRun(const ResetGLState& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
+
 
 class DrawSceneTask : public Task {
 public:

libraries/render/src/render/Engine.h

@@ -30,6 +30,13 @@ class RenderContext {
 public:
     RenderArgs* args;
 
+    bool _cullOpaque = true;
+    bool _sortOpaque = true;
+    bool _renderOpaque = true;
+    bool _cullTransparent = true;
+    bool _sortTransparent = true;
+    bool _renderTransparent = true;
+
     RenderContext() {}
 };
 typedef std::shared_ptr<RenderContext> RenderContextPointer;

libraries/script-engine/src/SceneScriptingInterface.cpp

@@ -128,4 +128,28 @@ void SceneScriptingInterface::setShouldRenderEntities(bool shouldRenderEntities)
         _shouldRenderEntities = shouldRenderEntities;
         emit shouldRenderEntitiesChanged(_shouldRenderEntities);
     }
-}
+}
+
+void SceneScriptingInterface::setEngineRenderOpaque(bool renderOpaque) {
+    _engineRenderOpaque = renderOpaque;
+}
+
+void SceneScriptingInterface::setEngineRenderTransparent(bool renderTransparent) {
+    _engineRenderTransparent = renderTransparent;
+}
+
+void SceneScriptingInterface::setEngineCullOpaque(bool cullOpaque) {
+    _engineCullOpaque = cullOpaque;
+}
+
+void SceneScriptingInterface::setEngineCullTransparent(bool cullTransparent) {
+    _engineCullTransparent = cullTransparent;
+}
+
+void SceneScriptingInterface::setEngineSortOpaque(bool sortOpaque) {
+    _engineSortOpaque = sortOpaque;
+}
+
+void SceneScriptingInterface::setEngineSortTransparent(bool sortTransparent) {
+    _engineSortOpaque = sortTransparent;
+}

libraries/script-engine/src/SceneScriptingInterface.h

@@ -67,7 +67,24 @@ public:
     
     Q_INVOKABLE void setShouldRenderEntities(bool shouldRenderEntities);
     Q_INVOKABLE bool shouldRenderEntities() const { return _shouldRenderEntities; }
+
+
+    // Controlling the rendering engine
+    Q_INVOKABLE void setEngineRenderOpaque(bool renderOpaque);
+    Q_INVOKABLE bool doEngineRenderOpaque() const { return _engineRenderOpaque; }
+    Q_INVOKABLE void setEngineRenderTransparent(bool renderTransparent);
+    Q_INVOKABLE bool doEngineRenderTransparent() const { return _engineRenderTransparent; }
     
+    Q_INVOKABLE void setEngineCullOpaque(bool cullOpaque);
+    Q_INVOKABLE bool doEngineCullOpaque() const { return _engineCullOpaque; }
+    Q_INVOKABLE void setEngineCullTransparent(bool cullTransparent);
+    Q_INVOKABLE bool doEngineCullTransparent() const { return _engineCullTransparent; }
+
+    Q_INVOKABLE void setEngineSortOpaque(bool sortOpaque);
+    Q_INVOKABLE bool doEngineSortOpaque() const { return _engineSortOpaque; }
+    Q_INVOKABLE void setEngineSortTransparent(bool sortTransparent);
+    Q_INVOKABLE bool doEngineSortTransparent() const { return _engineSortTransparent; }
+
 signals:
     void shouldRenderAvatarsChanged(bool shouldRenderAvatars);
     void shouldRenderEntitiesChanged(bool shouldRenderEntities);
@@ -79,6 +96,14 @@ protected:
     
     bool _shouldRenderAvatars = true;
     bool _shouldRenderEntities = true;
+
+    bool _engineRenderOpaque = true;
+    bool _engineRenderTransparent = true;
+    bool _engineCullOpaque = true;
+    bool _engineCullTransparent = true;
+    bool _engineSortOpaque = true;
+    bool _engineSortTransparent = true;
+
 };
 
 #endif // hifi_SceneScriptingInterface_h