diff --git a/examples/utilities/tools/cookies.js b/examples/utilities/tools/cookies.js index 0182bf8db0..136b5b7f82 100755 --- a/examples/utilities/tools/cookies.js +++ b/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); }; diff --git a/examples/utilities/tools/renderEngineDebug.js b/examples/utilities/tools/renderEngineDebug.js new file mode 100755 index 0000000000..9b4a60977e --- /dev/null +++ b/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); diff --git a/interface/src/Application.cpp b/interface/src/Application.cpp index 83da9c1854..76feb77076 100644 --- a/interface/src/Application.cpp +++ b/interface/src/Application.cpp @@ -3200,6 +3200,113 @@ namespace render { } } +// Background Render Data & rendering functions +class BackgroundRenderData { +public: + typedef render::Payload Payload; + typedef Payload::DataPointer Pointer; + + Stars _stars; + Environment* _environment; + + BackgroundRenderData(Environment* environment) : _environment(environment) { + } + + static render::ItemID _item; // unique WorldBoxRenderData +}; + +render::ItemID BackgroundRenderData::_item = 0; + +namespace render { + template <> const ItemKey payloadGetKey(const BackgroundRenderData::Pointer& stuff) { return ItemKey::Builder::background(); } + template <> const Item::Bound payloadGetBound(const BackgroundRenderData::Pointer& stuff) { return Item::Bound(); } + template <> void payloadRender(const BackgroundRenderData::Pointer& background, RenderArgs* args) { + + // Background rendering decision + auto skyStage = DependencyManager::get()->getSkyStage(); + auto skybox = model::SkyboxPointer(); + if (skyStage->getBackgroundMode() == model::SunSkyStage::NO_BACKGROUND) { + } else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_DOME) { + if (/*!selfAvatarOnly &&*/ Menu::getInstance()->isOptionChecked(MenuOption::Stars)) { + PerformanceTimer perfTimer("stars"); + PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), + "Application::payloadRender() ... stars..."); + if (!background->_stars.isStarsLoaded()) { + background->_stars.generate(STARFIELD_NUM_STARS, STARFIELD_SEED); + } + // should be the first rendering pass - w/o depth buffer / lighting + + // compute starfield alpha based on distance from atmosphere + float alpha = 1.0f; + bool hasStars = true; + + if (Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) { + // TODO: handle this correctly for zones + const EnvironmentData& closestData = background->_environment->getClosestData(args->_viewFrustum->getPosition()); // was theCamera instead of _viewFrustum + + if (closestData.getHasStars()) { + const float APPROXIMATE_DISTANCE_FROM_HORIZON = 0.1f; + const float DOUBLE_APPROXIMATE_DISTANCE_FROM_HORIZON = 0.2f; + + glm::vec3 sunDirection = (args->_viewFrustum->getPosition()/*getAvatarPosition()*/ - closestData.getSunLocation()) + / closestData.getAtmosphereOuterRadius(); + float height = glm::distance(args->_viewFrustum->getPosition()/*theCamera.getPosition()*/, closestData.getAtmosphereCenter()); + if (height < closestData.getAtmosphereInnerRadius()) { + // If we're inside the atmosphere, then determine if our keyLight is below the horizon + alpha = 0.0f; + + if (sunDirection.y > -APPROXIMATE_DISTANCE_FROM_HORIZON) { + float directionY = glm::clamp(sunDirection.y, + -APPROXIMATE_DISTANCE_FROM_HORIZON, APPROXIMATE_DISTANCE_FROM_HORIZON) + + APPROXIMATE_DISTANCE_FROM_HORIZON; + alpha = (directionY / DOUBLE_APPROXIMATE_DISTANCE_FROM_HORIZON); + } + + + } else if (height < closestData.getAtmosphereOuterRadius()) { + alpha = (height - closestData.getAtmosphereInnerRadius()) / + (closestData.getAtmosphereOuterRadius() - closestData.getAtmosphereInnerRadius()); + + if (sunDirection.y > -APPROXIMATE_DISTANCE_FROM_HORIZON) { + float directionY = glm::clamp(sunDirection.y, + -APPROXIMATE_DISTANCE_FROM_HORIZON, APPROXIMATE_DISTANCE_FROM_HORIZON) + + APPROXIMATE_DISTANCE_FROM_HORIZON; + alpha = (directionY / DOUBLE_APPROXIMATE_DISTANCE_FROM_HORIZON); + } + } + } else { + hasStars = false; + } + } + + // finally render the starfield + if (hasStars) { + background->_stars.render(args->_viewFrustum->getFieldOfView(), args->_viewFrustum->getAspectRatio(), args->_viewFrustum->getNearClip(), alpha); + } + + // draw the sky dome + if (/*!selfAvatarOnly &&*/ Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) { + PerformanceTimer perfTimer("atmosphere"); + PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), + "Application::displaySide() ... atmosphere..."); + background->_environment->renderAtmospheres(*(args->_viewFrustum)); + } + + } + } else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_BOX) { + PerformanceTimer perfTimer("skybox"); + + skybox = skyStage->getSkybox(); + if (skybox) { + gpu::Batch batch; + model::Skybox::render(batch, *(args->_viewFrustum), *skybox); + + gpu::GLBackend::renderBatch(batch, true); + glUseProgram(0); + } + } + } +} void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool selfAvatarOnly, bool billboard) { @@ -3272,86 +3379,19 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se glTexGenfv(GL_R, GL_EYE_PLANE, (const GLfloat*)&_shadowMatrices[i][2]); } + // THe pending changes collecting the changes here + render::PendingChanges pendingChanges; + // Background rendering decision - auto skyStage = DependencyManager::get()->getSkyStage(); - auto skybox = model::SkyboxPointer(); - if (skyStage->getBackgroundMode() == model::SunSkyStage::NO_BACKGROUND) { - } else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_DOME) { - if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Stars)) { - PerformanceTimer perfTimer("stars"); - PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), - "Application::displaySide() ... stars..."); - if (!_stars.isStarsLoaded()) { - _stars.generate(STARFIELD_NUM_STARS, STARFIELD_SEED); - } - // should be the first rendering pass - w/o depth buffer / lighting + if (BackgroundRenderData::_item == 0) { + auto backgroundRenderData = BackgroundRenderData::Pointer(new BackgroundRenderData(&_environment)); + auto backgroundRenderPayload = render::PayloadPointer(new BackgroundRenderData::Payload(backgroundRenderData)); - // compute starfield alpha based on distance from atmosphere - float alpha = 1.0f; - bool hasStars = true; + BackgroundRenderData::_item = _main3DScene->allocateID(); - if (Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) { - // TODO: handle this correctly for zones - const EnvironmentData& closestData = _environment.getClosestData(theCamera.getPosition()); + pendingChanges.resetItem(WorldBoxRenderData::_item, backgroundRenderPayload); + } else { - if (closestData.getHasStars()) { - const float APPROXIMATE_DISTANCE_FROM_HORIZON = 0.1f; - const float DOUBLE_APPROXIMATE_DISTANCE_FROM_HORIZON = 0.2f; - - glm::vec3 sunDirection = (getAvatarPosition() - closestData.getSunLocation()) - / closestData.getAtmosphereOuterRadius(); - float height = glm::distance(theCamera.getPosition(), closestData.getAtmosphereCenter()); - if (height < closestData.getAtmosphereInnerRadius()) { - // If we're inside the atmosphere, then determine if our keyLight is below the horizon - alpha = 0.0f; - - if (sunDirection.y > -APPROXIMATE_DISTANCE_FROM_HORIZON) { - float directionY = glm::clamp(sunDirection.y, - -APPROXIMATE_DISTANCE_FROM_HORIZON, APPROXIMATE_DISTANCE_FROM_HORIZON) - + APPROXIMATE_DISTANCE_FROM_HORIZON; - alpha = (directionY / DOUBLE_APPROXIMATE_DISTANCE_FROM_HORIZON); - } - - - } else if (height < closestData.getAtmosphereOuterRadius()) { - alpha = (height - closestData.getAtmosphereInnerRadius()) / - (closestData.getAtmosphereOuterRadius() - closestData.getAtmosphereInnerRadius()); - - if (sunDirection.y > -APPROXIMATE_DISTANCE_FROM_HORIZON) { - float directionY = glm::clamp(sunDirection.y, - -APPROXIMATE_DISTANCE_FROM_HORIZON, APPROXIMATE_DISTANCE_FROM_HORIZON) - + APPROXIMATE_DISTANCE_FROM_HORIZON; - alpha = (directionY / DOUBLE_APPROXIMATE_DISTANCE_FROM_HORIZON); - } - } - } else { - hasStars = false; - } - } - - // finally render the starfield - if (hasStars) { - _stars.render(_displayViewFrustum.getFieldOfView(), _displayViewFrustum.getAspectRatio(), _displayViewFrustum.getNearClip(), alpha); - } - - // draw the sky dome - if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) { - PerformanceTimer perfTimer("atmosphere"); - PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), - "Application::displaySide() ... atmosphere..."); - _environment.renderAtmospheres(theCamera); - } - - } - } else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_BOX) { - skybox = skyStage->getSkybox(); - if (skybox) { - gpu::Batch batch; - model::Skybox::render(batch, _viewFrustum, *skybox); - - gpu::GLBackend::renderBatch(batch, true); - glUseProgram(0); - } } if (Menu::getInstance()->isOptionChecked(MenuOption::Wireframe)) { @@ -3361,7 +3401,8 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se glEnable(GL_LIGHTING); glEnable(GL_DEPTH_TEST); - DependencyManager::get()->prepare(); + // Assuming nothing get's rendered through that + // DependencyManager::get()->prepare(); if (!selfAvatarOnly) { @@ -3388,10 +3429,11 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se renderArgs->_debugFlags = renderDebugFlags; _entities.render(renderArgs); - if (!Menu::getInstance()->isOptionChecked(MenuOption::Wireframe)) { + // This shouldn't matter anymore + /* if (!Menu::getInstance()->isOptionChecked(MenuOption::Wireframe)) { // Restaure polygon mode glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); - } + }*/ } // render the ambient occlusion effect if enabled @@ -3403,7 +3445,6 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se } } - render::PendingChanges pendingChanges; // Make sure the WorldBox is in the scene if (WorldBoxRenderData::_item == 0) { @@ -3423,6 +3464,26 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se }); } + if (!billboard) { + DependencyManager::get()->setAmbientLightMode(getRenderAmbientLight()); + auto skyStage = DependencyManager::get()->getSkyStage(); + DependencyManager::get()->setGlobalLight(skyStage->getSunLight()->getDirection(), skyStage->getSunLight()->getColor(), skyStage->getSunLight()->getIntensity(), skyStage->getSunLight()->getAmbientIntensity()); + DependencyManager::get()->setGlobalAtmosphere(skyStage->getAtmosphere()); + + auto skybox = model::SkyboxPointer(); + if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_BOX) { + skybox = skyStage->getSkybox(); + } + DependencyManager::get()->setGlobalSkybox(skybox); + + // Not needed anymore here, taken care off by the Engine + /* + PROFILE_RANGE("DeferredLighting"); + PerformanceTimer perfTimer("lighting"); + DependencyManager::get()->render();*/ + + } + { PerformanceTimer perfTimer("SceneProcessPendingChanges"); _main3DScene->enqueuePendingChanges(pendingChanges); @@ -3434,8 +3495,20 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se { PerformanceTimer perfTimer("EngineRun"); render::RenderContext renderContext; + + auto sceneInterface = DependencyManager::get(); + + 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; + renderArgs->_viewFrustum = getDisplayViewFrustum(); _renderEngine->setRenderContext(renderContext); // Before the deferred pass, let's try to use the render engine @@ -3446,20 +3519,15 @@ 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); } - if (!billboard) { - DependencyManager::get()->setAmbientLightMode(getRenderAmbientLight()); - auto skyStage = DependencyManager::get()->getSkyStage(); - DependencyManager::get()->setGlobalLight(skyStage->getSunLight()->getDirection(), skyStage->getSunLight()->getColor(), skyStage->getSunLight()->getIntensity(), skyStage->getSunLight()->getAmbientIntensity()); - DependencyManager::get()->setGlobalAtmosphere(skyStage->getAtmosphere()); - DependencyManager::get()->setGlobalSkybox(skybox); - - PROFILE_RANGE("DeferredLighting"); - PerformanceTimer perfTimer("lighting"); - DependencyManager::get()->render(); - } //Render the sixense lasers if (Menu::getInstance()->isOptionChecked(MenuOption::SixenseLasers)) { @@ -3709,7 +3777,7 @@ void Application::updateWindowTitle(){ void Application::clearDomainOctreeDetails() { qCDebug(interfaceapp) << "Clearing domain octree details..."; // reset the environment so that we don't erroneously end up with multiple - _environment.resetToDefault(); + // _environment.resetToDefault(); // reset our node to stats and node to jurisdiction maps... since these must be changing... _entityServerJurisdictions.lockForWrite(); diff --git a/interface/src/Application.h b/interface/src/Application.h index 604891d1c0..1a19800869 100644 --- a/interface/src/Application.h +++ b/interface/src/Application.h @@ -210,7 +210,7 @@ public: ViewFrustum* getShadowViewFrustum() { return &_shadowViewFrustum; } const OctreePacketProcessor& getOctreePacketProcessor() const { return _octreeProcessor; } EntityTreeRenderer* getEntities() { return &_entities; } - Environment* getEnvironment() { return &_environment; } + // Environment* getEnvironment() { return &_environment; } QUndoStack* getUndoStack() { return &_undoStack; } MainWindow* getWindow() { return _window; } OctreeQuery& getOctreeQuery() { return _octreeQuery; } @@ -535,7 +535,7 @@ private: QElapsedTimer _timerStart; QElapsedTimer _lastTimeUpdated; bool _justStarted; - Stars _stars; + // Stars _stars; ShapeManager _shapeManager; PhysicalEntitySimulation _entitySimulation; diff --git a/interface/src/Environment.cpp b/interface/src/Environment.cpp index a2b78c2ff5..9f197920d9 100644 --- a/interface/src/Environment.cpp +++ b/interface/src/Environment.cpp @@ -68,7 +68,7 @@ void Environment::resetToDefault() { _data[HifiSockAddr()][0]; } -void Environment::renderAtmospheres(Camera& camera) { +void Environment::renderAtmospheres(ViewFrustum& camera) { // get the lock for the duration of the call QMutexLocker locker(&_mutex); @@ -228,7 +228,7 @@ ProgramObject* Environment::createSkyProgram(const char* from, int* locations) { return program; } -void Environment::renderAtmosphere(Camera& camera, const EnvironmentData& data) { +void Environment::renderAtmosphere(ViewFrustum& camera, const EnvironmentData& data) { glm::vec3 center = data.getAtmosphereCenter(); glPushMatrix(); diff --git a/interface/src/Environment.h b/interface/src/Environment.h index 1a46a10175..c1b4171947 100644 --- a/interface/src/Environment.h +++ b/interface/src/Environment.h @@ -19,7 +19,7 @@ #include "EnvironmentData.h" -class Camera; +class ViewFrustum; class ProgramObject; class Environment { @@ -29,7 +29,7 @@ public: void init(); void resetToDefault(); - void renderAtmospheres(Camera& camera); + void renderAtmospheres(ViewFrustum& camera); void override(const EnvironmentData& overrideData) { _overrideData = overrideData; _environmentIsOverridden = true; } void endOverride() { _environmentIsOverridden = false; } @@ -46,7 +46,7 @@ private: ProgramObject* createSkyProgram(const char* from, int* locations); - void renderAtmosphere(Camera& camera, const EnvironmentData& data); + void renderAtmosphere(ViewFrustum& camera, const EnvironmentData& data); bool _initialized; ProgramObject* _skyFromAtmosphereProgram; diff --git a/interface/src/Util.cpp b/interface/src/Util.cpp index 1f217d92b9..c07c2877e8 100644 --- a/interface/src/Util.cpp +++ b/interface/src/Util.cpp @@ -34,6 +34,7 @@ using namespace std; void renderWorldBox() { + return; auto geometryCache = DependencyManager::get(); // Show edge of world diff --git a/interface/src/avatar/MyAvatar.cpp b/interface/src/avatar/MyAvatar.cpp index 9e020c9733..e216441b98 100644 --- a/interface/src/avatar/MyAvatar.cpp +++ b/interface/src/avatar/MyAvatar.cpp @@ -45,6 +45,9 @@ #include "Util.h" #include "InterfaceLogging.h" +#include "gpu/GLBackend.h" + + using namespace std; const glm::vec3 DEFAULT_UP_DIRECTION(0.0f, 1.0f, 0.0f); @@ -1485,7 +1488,8 @@ void MyAvatar::maybeUpdateBillboard() { return; } } - RenderArgs renderArgs; + gpu::Context context(new gpu::GLBackend()); + RenderArgs renderArgs(&context); QImage image = Application::getInstance()->renderAvatarBillboard(&renderArgs); _billboard.clear(); QBuffer buffer(&_billboard); diff --git a/libraries/entities-renderer/src/EntityTreeRenderer.cpp b/libraries/entities-renderer/src/EntityTreeRenderer.cpp index 7a02120ab9..43f340119b 100644 --- a/libraries/entities-renderer/src/EntityTreeRenderer.cpp +++ b/libraries/entities-renderer/src/EntityTreeRenderer.cpp @@ -525,9 +525,9 @@ void EntityTreeRenderer::render(RenderArgs* renderArgs) { Model::endScene(renderArgs); _tree->unlock(); - glPushMatrix(); - renderArgs->_context->render(batch); - glPopMatrix(); + // glPushMatrix(); + // renderArgs->_context->render(batch); + // glPopMatrix(); renderArgs->_batch = nullptr; diff --git a/libraries/gpu/src/gpu/Context.cpp b/libraries/gpu/src/gpu/Context.cpp index c888003b29..9cc6bb3cd7 100644 --- a/libraries/gpu/src/gpu/Context.cpp +++ b/libraries/gpu/src/gpu/Context.cpp @@ -34,5 +34,8 @@ bool Context::makeProgram(Shader& shader, const Shader::BindingSet& bindings) { void Context::render(Batch& batch) { _backend->render(batch); - // GLBackend::renderBatch(batch, true); } + +void Context::syncCache() { + _backend->syncCache(); +} \ No newline at end of file diff --git a/libraries/gpu/src/gpu/Context.h b/libraries/gpu/src/gpu/Context.h index 97ecf6b846..99021d2731 100644 --- a/libraries/gpu/src/gpu/Context.h +++ b/libraries/gpu/src/gpu/Context.h @@ -33,6 +33,7 @@ public: virtual~ Backend() {}; virtual void render(Batch& batch) = 0; + virtual void syncCache() = 0; class TransformObject { public: @@ -115,6 +116,7 @@ public: void render(Batch& batch); + void syncCache(); protected: Context(const Context& context); diff --git a/libraries/gpu/src/gpu/GLBackend.h b/libraries/gpu/src/gpu/GLBackend.h index da0fe77b24..d1ba7714e9 100644 --- a/libraries/gpu/src/gpu/GLBackend.h +++ b/libraries/gpu/src/gpu/GLBackend.h @@ -30,6 +30,12 @@ public: virtual void render(Batch& batch); + // This call synchronize the Full Backend cache with the current GLState + // THis is only intended to be used when mixing raw gl calls with the gpu api usage in order to sync + // the gpu::Backend state with the true gl state which has probably been messed up by these ugly naked gl calls + // Let's try to avoid to do that as much as possible! + virtual void syncCache(); + // Render Batch create a local Context and execute the batch with it // WARNING: // if syncCache is true, then the gpu::GLBackend will synchornize @@ -195,12 +201,6 @@ public: void do_setStateColorWriteMask(uint32 mask); - // This call synchronize the Full Backend cache with the current GLState - // THis is only intended to be used when mixing raw gl calls with the gpu api usage in order to sync - // the gpu::Backend state with the true gl state which has probably been messed up by these ugly naked gl calls - // Let's try to avoid to do that as much as possible! - void syncCache(); - protected: // Draw Stage diff --git a/libraries/render-utils/src/Model.cpp b/libraries/render-utils/src/Model.cpp index 4d52006677..41b9819c94 100644 --- a/libraries/render-utils/src/Model.cpp +++ b/libraries/render-utils/src/Model.cpp @@ -865,6 +865,9 @@ bool Model::addToScene(std::shared_ptr scene, render::PendingChan } 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); @@ -904,6 +907,7 @@ void Model::removeFromScene(std::shared_ptr scene, render::Pendin } _renderItems.clear(); _readyWhenAdded = false; + qDebug() << "Model::removeFromScene : " << this->getURL().toString(); } bool Model::render(RenderArgs* renderArgs, float alpha) { @@ -922,6 +926,8 @@ bool Model::render(RenderArgs* renderArgs, float alpha) { } bool Model::renderCore(RenderArgs* args, float alpha) { + return true; + PROFILE_RANGE(__FUNCTION__); if (!_viewState) { return false; @@ -2247,14 +2253,19 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran _transforms.push_back(Transform()); } - _transforms[0] = _viewState->getViewTransform(); - // 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); - batch.setViewTransform(_transforms[0]); + // _transforms[0] = _viewState->getViewTransform(); + // args->_viewFrustum->evalViewTransform(_transforms[0]); - const float OPAQUE_ALPHA_THRESHOLD = 0.5f; - const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f; - auto alphaThreshold = translucent ? TRANSPARENT_ALPHA_THRESHOLD : OPAQUE_ALPHA_THRESHOLD; // FIX ME + // apply entity translation offset to the viewTransform in one go (it's a preTranslate because viewTransform goes from world to eye space) + // _transforms[0].setTranslation(_translation); + + // batch.setViewTransform(_transforms[0]); + + + // const float OPAQUE_ALPHA_THRESHOLD = 0.5f; + // const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f; + // auto alphaThreshold = translucent ? TRANSPARENT_ALPHA_THRESHOLD : OPAQUE_ALPHA_THRESHOLD; // FIX ME + auto alphaThreshold = args->_alphaThreshold; //translucent ? TRANSPARENT_ALPHA_THRESHOLD : OPAQUE_ALPHA_THRESHOLD; // FIX ME const FBXGeometry& geometry = _geometry->getFBXGeometry(); const QVector& networkMeshes = _geometry->getMeshes(); @@ -2305,10 +2316,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); @@ -2331,7 +2349,7 @@ void Model::renderPart(RenderArgs* args, int meshIndex, int partIndex, bool tran model::MaterialPointer material = part._material; if (material == nullptr) { - qCDebug(renderutils) << "WARNING: material == nullptr!!!"; + // qCDebug(renderutils) << "WARNING: material == nullptr!!!"; } if (material != nullptr) { diff --git a/libraries/render-utils/src/RenderDeferredTask.cpp b/libraries/render-utils/src/RenderDeferredTask.cpp index 8ab5faace1..1fccb57cee 100755 --- a/libraries/render-utils/src/RenderDeferredTask.cpp +++ b/libraries/render-utils/src/RenderDeferredTask.cpp @@ -10,12 +10,34 @@ // #include "RenderDeferredTask.h" +#include "gpu/Context.h" + +#include + + using namespace render; +template <> void render::jobRun(const PrepareDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { + PerformanceTimer perfTimer("PrepareDeferred"); + DependencyManager::get()->prepare(); +} + +template <> void render::jobRun(const ResolveDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { + PerformanceTimer perfTimer("ResolveDeferred"); + DependencyManager::get()->render(); +} + + + RenderDeferredTask::RenderDeferredTask() : Task() { + _jobs.push_back(Job(PrepareDeferred())); + _jobs.push_back(Job(DrawBackground())); _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())); + } RenderDeferredTask::~RenderDeferredTask() { @@ -34,6 +56,8 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend return; } + renderContext->args->_context->syncCache(); + for (auto job : _jobs) { job.run(sceneContext, renderContext); } diff --git a/libraries/render-utils/src/RenderDeferredTask.h b/libraries/render-utils/src/RenderDeferredTask.h index 574dc651b1..318859e71c 100755 --- a/libraries/render-utils/src/RenderDeferredTask.h +++ b/libraries/render-utils/src/RenderDeferredTask.h @@ -14,6 +14,21 @@ #include "render/DrawTask.h" +#include "DeferredLightingEffect.h" + +class PrepareDeferred { +public: +}; +namespace render { +template <> void jobRun(const PrepareDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext); +} + +class ResolveDeferred { +public: +}; +namespace render { +template <> void jobRun(const ResolveDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext); +} class RenderDeferredTask : public render::Task { public: diff --git a/libraries/render/src/render/DrawTask.cpp b/libraries/render/src/render/DrawTask.cpp index 159f586c31..dd57a71fcf 100755 --- a/libraries/render/src/render/DrawTask.cpp +++ b/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() { @@ -56,6 +57,7 @@ Job::~Job() { } void render::cullItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDs& inItems, ItemIDs& outItems) { + PerformanceTimer perfTimer("cullItems"); assert(renderContext->args); assert(renderContext->args->_viewFrustum); @@ -114,6 +116,7 @@ struct BackToFrontSort { }; void render::depthSortItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, bool frontToBack, const ItemIDs& inItems, ItemIDs& outItems) { + PerformanceTimer perfTimer("depthSortItems"); assert(renderContext->args); assert(renderContext->args->_viewFrustum); @@ -152,6 +155,7 @@ void render::depthSortItems(const SceneContextPointer& sceneContext, const Rende } void render::renderItems(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDs& inItems) { + PerformanceTimer perfTimer("renderItems"); auto& scene = sceneContext->_scene; RenderArgs* args = renderContext->args; // render @@ -195,8 +199,16 @@ 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"); assert(renderContext->args); assert(renderContext->args->_viewFrustum); @@ -209,40 +221,57 @@ template <> void render::jobRun(const DrawOpaque& job, const SceneContextPointer for (auto id : items) { inItems.push_back(id); } + ItemIDs& renderedItems = inItems; + + renderContext->_numFeedOpaqueItems = renderedItems.size(); ItemIDs culledItems; - cullItems(sceneContext, renderContext, inItems, culledItems); - - ItemIDs sortedItems; - depthSortItems(sceneContext, renderContext, true, culledItems, sortedItems); // Sort Front to back opaque items! - - RenderArgs* args = renderContext->args; - gpu::Batch theBatch; - args->_batch = &theBatch; - - glm::mat4 proj; - args->_viewFrustum->evalProjectionMatrix(proj); - theBatch.setProjectionTransform(proj); - - 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; - theBatch._glDrawBuffers(bufferCount, buffers); + if (renderContext->_cullOpaque) { + cullItems(sceneContext, renderContext, renderedItems, culledItems); + renderedItems = culledItems; } - renderItems(sceneContext, renderContext, sortedItems); + renderContext->_numDrawnOpaqueItems = renderedItems.size(); - addClearStateCommands((*args->_batch)); - args->_context->render((*args->_batch)); - args->_batch = nullptr; + + ItemIDs sortedItems; + if (renderContext->_sortOpaque) { + depthSortItems(sceneContext, renderContext, true, renderedItems, sortedItems); // Sort Front to back opaque items! + renderedItems = sortedItems; + } + + 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; + } } template <> void render::jobRun(const DrawTransparent& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { + PerformanceTimer perfTimer("DrawTransparent"); assert(renderContext->args); assert(renderContext->args->_viewFrustum); @@ -255,33 +284,71 @@ template <> void render::jobRun(const DrawTransparent& job, const SceneContextPo for (auto id : items) { inItems.push_back(id); } + ItemIDs& renderedItems = inItems; + + renderContext->_numFeedTransparentItems = renderedItems.size(); ItemIDs culledItems; - cullItems(sceneContext, renderContext, inItems, culledItems); - - ItemIDs sortedItems; - depthSortItems(sceneContext, renderContext, false, culledItems, sortedItems); // Sort Back to front transparent items! - - RenderArgs* args = renderContext->args; - gpu::Batch theBatch; - args->_batch = &theBatch; - - renderContext->args->_renderMode = RenderArgs::NORMAL_RENDER_MODE; - { - GLenum buffers[3]; - int bufferCount = 0; - buffers[bufferCount++] = GL_COLOR_ATTACHMENT0; - theBatch._glDrawBuffers(bufferCount, buffers); + if (renderContext->_cullTransparent) { + cullItems(sceneContext, renderContext, inItems, culledItems); + renderedItems = culledItems; } - renderItems(sceneContext, renderContext, sortedItems); + renderContext->_numDrawnTransparentItems = renderedItems.size(); - addClearStateCommands((*args->_batch)); - args->_context->render((*args->_batch)); - args->_batch = nullptr; + ItemIDs sortedItems; + if (renderContext->_sortTransparent) { + depthSortItems(sceneContext, renderContext, false, renderedItems, sortedItems); // Sort Back to front transparent items! + renderedItems = sortedItems; + } + + if (renderContext->_renderTransparent) { + 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; + } + + + 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) { + PerformanceTimer perfTimer("DrawLight"); assert(renderContext->args); assert(renderContext->args->_viewFrustum); @@ -306,3 +373,37 @@ template <> void render::jobRun(const DrawLight& job, const SceneContextPointer& args->_context->render((*args->_batch)); args->_batch = nullptr; } + +template <> void render::jobRun(const DrawBackground& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) { + PerformanceTimer perfTimer("DrawBackground"); + assert(renderContext->args); + assert(renderContext->args->_viewFrustum); + + // render backgrounds + auto& scene = sceneContext->_scene; + auto& items = scene->getMasterBucket().at(ItemFilter::Builder::background()); + + + ItemIDs inItems; + inItems.reserve(items.size()); + for (auto id : items) { + inItems.push_back(id); + } + 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); + + renderItems(sceneContext, renderContext, inItems); + args->_context->render((*args->_batch)); + args->_batch = nullptr; + + // Force the context sync + args->_context->syncCache(); +} diff --git a/libraries/render/src/render/DrawTask.h b/libraries/render/src/render/DrawTask.h index 78d4d1bd8b..9572a68bf0 100755 --- a/libraries/render/src/render/DrawTask.h +++ b/libraries/render/src/render/DrawTask.h @@ -78,6 +78,16 @@ public: }; template <> void jobRun(const DrawLight& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext); +class DrawBackground { +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: diff --git a/libraries/render/src/render/Engine.h b/libraries/render/src/render/Engine.h index 247cb69c35..dbd193af29 100644 --- a/libraries/render/src/render/Engine.h +++ b/libraries/render/src/render/Engine.h @@ -30,6 +30,19 @@ class RenderContext { public: RenderArgs* args; + bool _cullOpaque = true; + bool _sortOpaque = true; + bool _renderOpaque = true; + bool _cullTransparent = true; + bool _sortTransparent = true; + bool _renderTransparent = true; + + int _numFeedOpaqueItems = 0; + int _numDrawnOpaqueItems = 0; + + int _numFeedTransparentItems = 0; + int _numDrawnTransparentItems = 0; + RenderContext() {} }; typedef std::shared_ptr RenderContextPointer; @@ -60,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; } diff --git a/libraries/render/src/render/Scene.cpp b/libraries/render/src/render/Scene.cpp index 93b8b4d7ef..8615f7cf7a 100644 --- a/libraries/render/src/render/Scene.cpp +++ b/libraries/render/src/render/Scene.cpp @@ -47,8 +47,8 @@ void ItemBucketMap::reset(const ItemID& id, const ItemKey& oldKey, const ItemKey void ItemBucketMap::allocateStandardOpaqueTranparentBuckets() { (*this)[ItemFilter::Builder::opaqueShape()]; (*this)[ItemFilter::Builder::transparentShape()]; - auto lightFilter = ItemFilter::Builder().withTypeLight().build(); - (*this)[lightFilter]; + (*this)[ItemFilter::Builder::light()]; + (*this)[ItemFilter::Builder::background()]; } diff --git a/libraries/render/src/render/Scene.h b/libraries/render/src/render/Scene.h index afacb25067..88ba2b478c 100644 --- a/libraries/render/src/render/Scene.h +++ b/libraries/render/src/render/Scene.h @@ -34,6 +34,7 @@ public: enum FlagBit { TYPE_SHAPE = 0, // Item is a Shape TYPE_LIGHT, // Item is a Light + TYPE_BACKGROUND, // Item is a Background TRANSLUCENT, // Transparent and not opaque, for some odd reason TRANSPARENCY doesn't work... VIEW_SPACE, // Transformed in view space, and not in world space DYNAMIC, // Dynamic and bound will change unlike static item @@ -62,6 +63,7 @@ public: Builder& withTypeShape() { _flags.set(TYPE_SHAPE); return (*this); } Builder& withTypeLight() { _flags.set(TYPE_LIGHT); return (*this); } + Builder& withTypeBackground() { _flags.set(TYPE_BACKGROUND); return (*this); } Builder& withTransparent() { _flags.set(TRANSLUCENT); return (*this); } Builder& withViewSpace() { _flags.set(VIEW_SPACE); return (*this); } Builder& withDynamic() { _flags.set(DYNAMIC); return (*this); } @@ -75,6 +77,7 @@ public: static ItemKey opaqueShape() { return Builder().withTypeShape().build(); } static ItemKey transparentShape() { return Builder().withTypeShape().withTransparent().build(); } static ItemKey light() { return Builder().withTypeLight().build(); } + static ItemKey background() { return Builder().withTypeBackground().build(); } }; bool isOpaque() const { return !_flags[TRANSLUCENT]; } @@ -126,6 +129,7 @@ public: Builder& withTypeShape() { _value.set(ItemKey::TYPE_SHAPE); _mask.set(ItemKey::TYPE_SHAPE); return (*this); } Builder& withTypeLight() { _value.set(ItemKey::TYPE_LIGHT); _mask.set(ItemKey::TYPE_LIGHT); return (*this); } + Builder& withTypeBackground() { _value.set(ItemKey::TYPE_BACKGROUND); _mask.set(ItemKey::TYPE_BACKGROUND); return (*this); } Builder& withOpaque() { _value.reset(ItemKey::TRANSLUCENT); _mask.set(ItemKey::TRANSLUCENT); return (*this); } Builder& withTransparent() { _value.set(ItemKey::TRANSLUCENT); _mask.set(ItemKey::TRANSLUCENT); return (*this); } @@ -154,6 +158,7 @@ public: static ItemFilter opaqueShape() { return Builder().withTypeShape().withOpaque().withWorldSpace().build(); } static ItemFilter transparentShape() { return Builder().withTypeShape().withTransparent().withWorldSpace().build(); } static ItemFilter light() { return Builder().withTypeLight().build(); } + static ItemFilter background() { return Builder().withTypeBackground().build(); } }; // Item Filter operator testing if a key pass the filter diff --git a/libraries/script-engine/src/SceneScriptingInterface.cpp b/libraries/script-engine/src/SceneScriptingInterface.cpp index ad76dbcc38..679ec1180f 100644 --- a/libraries/script-engine/src/SceneScriptingInterface.cpp +++ b/libraries/script-engine/src/SceneScriptingInterface.cpp @@ -128,4 +128,35 @@ void SceneScriptingInterface::setShouldRenderEntities(bool shouldRenderEntities) _shouldRenderEntities = shouldRenderEntities; emit shouldRenderEntitiesChanged(_shouldRenderEntities); } -} \ No newline at end of file +} + +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; +} + +void SceneScriptingInterface::clearEngineCounters() { + _numFeedOpaqueItems = 0; + _numDrawnOpaqueItems = 0; + _numFeedTransparentItems = 0; + _numDrawnTransparentItems = 0; +} diff --git a/libraries/script-engine/src/SceneScriptingInterface.h b/libraries/script-engine/src/SceneScriptingInterface.h index 50aaae83ff..b6dc4110c0 100644 --- a/libraries/script-engine/src/SceneScriptingInterface.h +++ b/libraries/script-engine/src/SceneScriptingInterface.h @@ -67,7 +67,36 @@ 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; } + + 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); @@ -79,6 +108,18 @@ 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; + + int _numFeedOpaqueItems = 0; + int _numDrawnOpaqueItems = 0; + int _numFeedTransparentItems = 0; + int _numDrawnTransparentItems = 0; }; #endif // hifi_SceneScriptingInterface_h diff --git a/libraries/shared/src/RenderArgs.h b/libraries/shared/src/RenderArgs.h index 0de4d4373e..aefaca8a31 100644 --- a/libraries/shared/src/RenderArgs.h +++ b/libraries/shared/src/RenderArgs.h @@ -119,6 +119,8 @@ public: int _translucentMeshPartsRendered; int _opaqueMeshPartsRendered; + + float _alphaThreshold = 0.5f; }; #endif // hifi_RenderArgs_h