Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-05 21:12:25 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge remote-tracking branch 'overte/master' into application

Browse source
This commit is contained in:
HifiExperiments 2024-10-25 13:37:22 -07:00
commit 7f4efafcb5
48 changed files with 229 additions and 262 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
interface/src/Application_Assets.cpp
View file

@ -483,7 +483,7 @@ bool Application::importSVOFromURL(const QString& urlString) {
bool Application::importFromZIP(const QString& filePath) {
qDebug() << "A zip file has been dropped in: " << filePath;
qApp->getFileDownloadInterface()->runUnzip(filePath, QUrl(), true, true, false);
qApp->getFileDownloadInterface()->runUnzip(filePath, QUrl(), true, true);
return true;
}

1
interface/src/Application_Setup.cpp
View file

@ -91,6 +91,7 @@
#include <scripting/DesktopScriptingInterface.h>
#include <scripting/HMDScriptingInterface.h>
#include <scripting/KeyboardScriptingInterface.h>
#include <scripting/SelectionScriptingInterface.h>
#include <scripting/TestScriptingInterface.h>
#include <scripting/TTSScriptingInterface.h>
#include <scripting/WindowScriptingInterface.h>

3
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
View file

@ -1748,9 +1748,8 @@ ShapePipelinePointer shapePipelineFactory(const ShapePlumber& plumber, const Sha
if (!std::get<2>(key)) {
_pipelines[std::make_tuple(std::get<0>(key), std::get<1>(key), std::get<2>(key), wireframe)] = std::make_shared<render::ShapePipeline>(pipeline, nullptr, nullptr, nullptr);
} else {
const auto& fadeEffect = DependencyManager::get<FadeEffect>();
_pipelines[std::make_tuple(std::get<0>(key), std::get<1>(key), std::get<2>(key), wireframe)] = std::make_shared<render::ShapePipeline>(pipeline, nullptr,
fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter());
FadeEffect::getBatchSetter(), FadeEffect::getItemUniformSetter());
}
}
}

2
libraries/entities-renderer/src/RenderableWebEntityItem.cpp
View file

@ -171,7 +171,7 @@ void WebEntityRenderer::doRenderUpdateSynchronousTyped(const ScenePointer& scene
_dpi = entity->getDpi();
_color = entity->getColor();
_alpha = entity->getAlpha();
_wantsKeyboardFocus = entity->wantsKeyboardFocus();
_wantsKeyboardFocus = entity->getWantsKeyboardFocus();
_pulseProperties = entity->getPulseProperties();
if (_contentType == ContentType::NoContent) {

1
libraries/entities/src/EntityItem.h.in
View file

@ -397,7 +397,6 @@ public:
QUuid getOwningAvatarIDForProperties() const;
virtual bool wantsHandControllerPointerEvents() const { return false; }
virtual bool wantsKeyboardFocus() const { return false; }
virtual void setProxyWindow(QWindow* proxyWindow) {}
virtual QObject* getEventHandler() { return nullptr; }

4
libraries/render-utils/src/AmbientOcclusionEffect.cpp
View file

@ -842,6 +842,8 @@ void AmbientOcclusionEffect::run(const render::RenderContextPointer& renderConte
config->setGPUBatchRunTime(_gpuTimer->getGPUAverage(), _gpuTimer->getBatchAverage());
}
gpu::PipelinePointer DebugAmbientOcclusion::_debugPipeline;
void DebugAmbientOcclusion::configure(const Config& config) {
_showCursorPixel = config.showCursorPixel;
@ -851,7 +853,7 @@ void DebugAmbientOcclusion::configure(const Config& config) {
}
}
const gpu::PipelinePointer& DebugAmbientOcclusion::getDebugPipeline() {
gpu::PipelinePointer& DebugAmbientOcclusion::getDebugPipeline() {
if (!_debugPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::ssao_debugOcclusion);
gpu::StatePointer state = std::make_shared<gpu::State>();

4
libraries/render-utils/src/AmbientOcclusionEffect.h
View file

@ -283,9 +283,9 @@ private:
};
gpu::StructBuffer<Parameters> _parametersBuffer;
const gpu::PipelinePointer& getDebugPipeline();
static gpu::PipelinePointer& getDebugPipeline();
gpu::PipelinePointer _debugPipeline;
static gpu::PipelinePointer _debugPipeline;
bool _showCursorPixel { false };
};

18
libraries/render-utils/src/AntialiasingEffect.cpp
View file

@ -40,6 +40,9 @@ namespace gr {
#if !ANTIALIASING_USE_TAA
gpu::PipelinePointer Antialiasing::_antialiasingPipeline;
gpu::PipelinePointer Antialiasing::_blendPipeline;
Antialiasing::Antialiasing() {
_geometryId = DependencyManager::get<GeometryCache>()->allocateID();
}
@ -144,6 +147,10 @@ void AntialiasingConfig::setAAMode(int mode) {
emit dirty();
}
gpu::PipelinePointer Antialiasing::_antialiasingPipeline;
gpu::PipelinePointer Antialiasing::_blendPipeline;
gpu::PipelinePointer Antialiasing::_debugBlendPipeline;
Antialiasing::Antialiasing(bool isSharpenEnabled) :
_isSharpenEnabled{ isSharpenEnabled } {
}
@ -154,7 +161,7 @@ Antialiasing::~Antialiasing() {
_antialiasingTextures[1].reset();
}
const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline(const render::RenderContextPointer& renderContext) {
gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline() {
if (!_antialiasingPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::taa);
@ -169,7 +176,7 @@ const gpu::PipelinePointer& Antialiasing::getAntialiasingPipeline(const render::
return _antialiasingPipeline;
}
const gpu::PipelinePointer& Antialiasing::getBlendPipeline() {
gpu::PipelinePointer& Antialiasing::getBlendPipeline() {
if (!_blendPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::fxaa_blend);
gpu::StatePointer state = std::make_shared<gpu::State>();
@ -180,7 +187,7 @@ const gpu::PipelinePointer& Antialiasing::getBlendPipeline() {
return _blendPipeline;
}
const gpu::PipelinePointer& Antialiasing::getDebugBlendPipeline() {
gpu::PipelinePointer& Antialiasing::getDebugBlendPipeline() {
if (!_debugBlendPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::taa_blend);
gpu::StatePointer state = std::make_shared<gpu::State>();
@ -260,7 +267,6 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const
batch.setViewportTransform(args->_viewport);
// TAA step
getAntialiasingPipeline(renderContext);
batch.setResourceFramebufferSwapChainTexture(ru::Texture::TaaHistory, _antialiasingBuffers, 0);
batch.setResourceTexture(ru::Texture::TaaSource, sourceBuffer->getRenderBuffer(0));
batch.setResourceTexture(ru::Texture::TaaVelocity, velocityBuffer->getVelocityTexture());
@ -269,9 +275,9 @@ void Antialiasing::run(const render::RenderContextPointer& renderContext, const
batch.setUniformBuffer(ru::Buffer::TaaParams, _params);
batch.setUniformBuffer(ru::Buffer::DeferredFrameTransform, deferredFrameTransform->getFrameTransformBuffer());
batch.setFramebufferSwapChain(_antialiasingBuffers, 1);
batch.setPipeline(getAntialiasingPipeline(renderContext));
batch.setPipeline(getAntialiasingPipeline());
batch.draw(gpu::TRIANGLE_STRIP, 4);
// Blend step

20
libraries/render-utils/src/AntialiasingEffect.h
View file

@ -213,18 +213,18 @@ public:
void configure(const Config& config);
void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
const gpu::PipelinePointer& getAntialiasingPipeline(const render::RenderContextPointer& renderContext);
const gpu::PipelinePointer& getBlendPipeline();
const gpu::PipelinePointer& getDebugBlendPipeline();
static gpu::PipelinePointer& getAntialiasingPipeline();
static gpu::PipelinePointer& getBlendPipeline();
static gpu::PipelinePointer& getDebugBlendPipeline();
private:
gpu::FramebufferSwapChainPointer _antialiasingBuffers;
gpu::TexturePointer _antialiasingTextures[2];
gpu::BufferPointer _blendParamsBuffer;
gpu::PipelinePointer _antialiasingPipeline;
gpu::PipelinePointer _blendPipeline;
gpu::PipelinePointer _debugBlendPipeline;
static gpu::PipelinePointer _antialiasingPipeline;
static gpu::PipelinePointer _blendPipeline;
static gpu::PipelinePointer _debugBlendPipeline;
TAAParamsBuffer _params;
AntialiasingConfig::Mode _mode{ AntialiasingConfig::TAA };
@ -251,8 +251,8 @@ public:
void configure(const Config& config) {}
void run(const render::RenderContextPointer& renderContext, const gpu::FramebufferPointer& sourceBuffer);
const gpu::PipelinePointer& getAntialiasingPipeline();
const gpu::PipelinePointer& getBlendPipeline();
static gpu::PipelinePointer& getAntialiasingPipeline();
static gpu::PipelinePointer& getBlendPipeline();
private:
gpu::FramebufferPointer _antialiasingBuffer;
@ -260,8 +260,8 @@ private:
gpu::TexturePointer _antialiasingTexture;
gpu::BufferPointer _paramsBuffer;
gpu::PipelinePointer _antialiasingPipeline;
gpu::PipelinePointer _blendPipeline;
static gpu::PipelinePointer _antialiasingPipeline;
static gpu::PipelinePointer _blendPipeline;
int _geometryId { 0 };
};
#endif

5
libraries/render-utils/src/BloomEffect.cpp
View file

@ -19,6 +19,11 @@
#define BLOOM_BLUR_LEVEL_COUNT 3
gpu::PipelinePointer BloomThreshold::_pipeline;
gpu::PipelinePointer BloomApply::_pipeline;
gpu::PipelinePointer BloomDraw::_pipeline;
gpu::PipelinePointer DebugBloom::_pipeline;
BloomThreshold::BloomThreshold(unsigned int downsamplingFactor) {
assert(downsamplingFactor > 0);
_parameters.edit()._sampleCount = downsamplingFactor;

8
libraries/render-utils/src/BloomEffect.h
View file

@ -43,8 +43,8 @@ private:
#include "BloomThreshold.shared.slh"
static gpu::PipelinePointer _pipeline;
gpu::FramebufferPointer _outputBuffer;
gpu::PipelinePointer _pipeline;
gpu::StructBuffer<Parameters> _parameters;
};
@ -68,7 +68,7 @@ private:
#include "BloomApply.shared.slh"
gpu::PipelinePointer _pipeline;
static gpu::PipelinePointer _pipeline;
gpu::StructBuffer<Parameters> _parameters;
};
@ -83,7 +83,7 @@ public:
private:
gpu::PipelinePointer _pipeline;
static gpu::PipelinePointer _pipeline;
};
class DebugBloomConfig : public render::Job::Config {
@ -125,7 +125,7 @@ public:
void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
private:
gpu::PipelinePointer _pipeline;
static gpu::PipelinePointer _pipeline;
gpu::BufferPointer _params;
DebugBloomConfig::Mode _mode;
};

7
libraries/render-utils/src/DebugDeferredBuffer.cpp
View file

@ -250,6 +250,9 @@ static std::string getFileContent(const std::string& fileName, const std::string
return defaultContent;
}
DebugDeferredBuffer::StandardPipelines DebugDeferredBuffer::_pipelines;
DebugDeferredBuffer::CustomPipelines DebugDeferredBuffer::_customPipelines;
#include <QStandardPaths> // TODO REMOVE: Temporary until UI
DebugDeferredBuffer::DebugDeferredBuffer() {
// TODO REMOVE: Temporary until UI
@ -334,7 +337,7 @@ std::string DebugDeferredBuffer::getShaderSourceCode(Mode mode, const std::strin
return std::string();
}
bool DebugDeferredBuffer::pipelineNeedsUpdate(Mode mode, const std::string& customFile) const {
bool DebugDeferredBuffer::pipelineNeedsUpdate(Mode mode, const std::string& customFile) {
if (mode != CustomMode) {
return !_pipelines[mode];
}
@ -351,7 +354,7 @@ bool DebugDeferredBuffer::pipelineNeedsUpdate(Mode mode, const std::string& cust
return true;
}
const gpu::PipelinePointer& DebugDeferredBuffer::getPipeline(Mode mode, const std::string& customFile) {
gpu::PipelinePointer& DebugDeferredBuffer::getPipeline(Mode mode, const std::string& customFile) {
if (pipelineNeedsUpdate(mode, customFile)) {
static_assert(shader::render_utils::program::debug_deferred_buffer != 0, "Validate debug deferred program");

12
libraries/render-utils/src/DebugDeferredBuffer.h
View file

@ -107,18 +107,18 @@ private:
struct CustomPipeline {
gpu::PipelinePointer pipeline;
mutable QFileInfo info;
QFileInfo info;
};
using StandardPipelines = std::array<gpu::PipelinePointer, NumModes>;
using CustomPipelines = std::unordered_map<std::string, CustomPipeline>;
bool pipelineNeedsUpdate(Mode mode, const std::string& customFile = std::string()) const;
const gpu::PipelinePointer& getPipeline(Mode mode, const std::string& customFile = std::string());
std::string getShaderSourceCode(Mode mode, const std::string& customFile = std::string());
static bool pipelineNeedsUpdate(Mode mode, const std::string& customFile = std::string());
static gpu::PipelinePointer& getPipeline(Mode mode, const std::string& customFile = std::string());
static std::string getShaderSourceCode(Mode mode, const std::string& customFile = std::string());
ParametersBuffer _parameters;
StandardPipelines _pipelines;
CustomPipelines _customPipelines;
static StandardPipelines _pipelines;
static CustomPipelines _customPipelines;
int _geometryId{ 0 };
};

61
libraries/render-utils/src/FadeEffect.cpp
View file

@ -17,33 +17,36 @@
#include "render-utils/ShaderConstants.h"
#include <PathUtils.h>
gpu::TexturePointer FadeEffect::_maskMap;
FadeEffect::FadeEffect() {
auto texturePath = PathUtils::resourcesPath() + "images/fadeMask.png";
_maskMap = DependencyManager::get<TextureCache>()->getImageTexture(texturePath, image::TextureUsage::STRICT_TEXTURE);
std::once_flag once;
std::call_once(once, [] {
auto texturePath = PathUtils::resourcesPath() + "images/fadeMask.png";
_maskMap = DependencyManager::get<TextureCache>()->getImageTexture(texturePath, image::TextureUsage::STRICT_TEXTURE);
});
}
void FadeEffect::build(render::Task::TaskConcept& task, const task::Varying& editableItems) {
void FadeEffect::build(JobModel& task, const render::Varying& inputs, render::Varying& outputs) {
auto editedFadeCategory = task.addJob<FadeJob>("Fade");
auto& fadeJob = task._jobs.back();
_configurations = fadeJob.get<FadeJob>().getConfigurationBuffer();
const auto fadeEditInput = FadeEditJob::Input(editableItems, editedFadeCategory).asVarying();
const auto fadeEditInput = FadeEditJob::Input(inputs, editedFadeCategory).asVarying();
task.addJob<FadeEditJob>("FadeEdit", fadeEditInput);
}
render::ShapePipeline::BatchSetter FadeEffect::getBatchSetter() const {
return [this](const render::ShapePipeline& shapePipeline, gpu::Batch& batch, render::Args*) {
render::ShapePipeline::BatchSetter FadeEffect::getBatchSetter() {
return [](const render::ShapePipeline& shapePipeline, gpu::Batch& batch, render::Args*) {
batch.setResourceTexture(render_utils::slot::texture::FadeMask, _maskMap);
batch.setUniformBuffer(render_utils::slot::buffer::FadeParameters, _configurations);
batch.setUniformBuffer(render_utils::slot::buffer::FadeParameters, FadeJob::getConfigurationBuffer());
};
}
render::ShapePipeline::ItemSetter FadeEffect::getItemUniformSetter() const {
render::ShapePipeline::ItemSetter FadeEffect::getItemUniformSetter() {
return [](const render::ShapePipeline& shapePipeline, render::Args* args, const render::Item& item) {
if (!render::TransitionStage::isIndexInvalid(item.getTransitionId())) {
const auto& scene = args->_scene;
const auto& batch = args->_batch;
auto transitionStage = scene->getStage<render::TransitionStage>(render::TransitionStage::getName());
auto transitionStage = scene->getStage<render::TransitionStage>();
auto& transitionState = transitionStage->getTransition(item.getTransitionId());
if (transitionState.paramsBuffer._size != sizeof(gpu::StructBuffer<FadeObjectParams>)) {
@ -71,39 +74,3 @@ render::ShapePipeline::ItemSetter FadeEffect::getItemUniformSetter() const {
}
};
}
render::ShapePipeline::ItemSetter FadeEffect::getItemStoredSetter() {
return [this](const render::ShapePipeline& shapePipeline, render::Args* args, const render::Item& item) {
if (!render::TransitionStage::isIndexInvalid(item.getTransitionId())) {
auto scene = args->_scene;
auto transitionStage = scene->getStage<render::TransitionStage>(render::TransitionStage::getName());
auto& transitionState = transitionStage->getTransition(item.getTransitionId());
const auto fadeCategory = FadeJob::transitionToCategory[transitionState.eventType];
_lastCategory = fadeCategory;
_lastThreshold = transitionState.threshold;
_lastNoiseOffset = transitionState.noiseOffset;
_lastBaseOffset = transitionState.baseOffset;
_lastBaseInvSize = transitionState.baseInvSize;
}
};
}
void FadeEffect::packToAttributes(const int category, const float threshold, const glm::vec3& noiseOffset,
const glm::vec3& baseOffset, const glm::vec3& baseInvSize,
glm::vec4& packedData1, glm::vec4& packedData2, glm::vec4& packedData3) {
packedData1.x = noiseOffset.x;
packedData1.y = noiseOffset.y;
packedData1.z = noiseOffset.z;
packedData1.w = (float)(category+0.1f); // GLSL hack so that casting back from float to int in fragment shader returns the correct value.
packedData2.x = baseOffset.x;
packedData2.y = baseOffset.y;
packedData2.z = baseOffset.z;
packedData2.w = threshold;
packedData3.x = baseInvSize.x;
packedData3.y = baseInvSize.y;
packedData3.z = baseInvSize.z;
packedData3.w = 0.f;
}

40
libraries/render-utils/src/FadeEffect.h
View file

@ -11,44 +11,22 @@
#ifndef hifi_render_utils_FadeEffect_h
#define hifi_render_utils_FadeEffect_h
#include <DependencyManager.h>
#include <render/Engine.h>
class FadeEffect : public Dependency {
SINGLETON_DEPENDENCY;
class FadeEffect {
public:
using Input = render::ItemBounds;
using JobModel = render::Task::ModelI<FadeEffect, render::ItemBounds>;
void build(render::Task::TaskConcept& task, const task::Varying& editableItems);
FadeEffect();
render::ShapePipeline::BatchSetter getBatchSetter() const;
render::ShapePipeline::ItemSetter getItemUniformSetter() const;
render::ShapePipeline::ItemSetter getItemStoredSetter();
void build(JobModel& task, const render::Varying& inputs, render::Varying& outputs);
int getLastCategory() const { return _lastCategory; }
float getLastThreshold() const { return _lastThreshold; }
const glm::vec3& getLastNoiseOffset() const { return _lastNoiseOffset; }
const glm::vec3& getLastBaseOffset() const { return _lastBaseOffset; }
const glm::vec3& getLastBaseInvSize() const { return _lastBaseInvSize; }
static void packToAttributes(const int category, const float threshold, const glm::vec3& noiseOffset,
const glm::vec3& baseOffset, const glm::vec3& baseInvSize,
glm::vec4& packedData1, glm::vec4& packedData2, glm::vec4& packedData3);
static render::ShapePipeline::BatchSetter getBatchSetter();
static render::ShapePipeline::ItemSetter getItemUniformSetter();
private:
gpu::BufferView _configurations;
gpu::TexturePointer _maskMap;
// The last fade set through the stored item setter
int _lastCategory { 0 };
float _lastThreshold { 0.f };
glm::vec3 _lastNoiseOffset { 0.f, 0.f, 0.f };
glm::vec3 _lastBaseOffset { 0.f, 0.f, 0.f };
glm::vec3 _lastBaseInvSize { 1.f, 1.f, 1.f };
explicit FadeEffect();
virtual ~FadeEffect() { }
static gpu::TexturePointer _maskMap;
};
#endif // hifi_render_utils_FadeEffect_h

8
libraries/render-utils/src/FadeEffectJobs.cpp
View file

@ -531,6 +531,8 @@ void FadeConfig::load(const QString& configFilePath) {
}
}
FadeJob::FadeConfigurationBuffer FadeJob::_configurations;
FadeJob::FadeJob() {
_previousTime = usecTimestampNow();
}
@ -558,15 +560,15 @@ void FadeJob::configure(const Config& config) {
void FadeJob::run(const render::RenderContextPointer& renderContext, FadeJob::Output& output) {
Config* jobConfig = static_cast<Config*>(renderContext->jobConfig.get());
output = (FadeCategory)jobConfig->editedCategory;
auto scene = renderContext->args->_scene;
auto transitionStage = scene->getStage<render::TransitionStage>(render::TransitionStage::getName());
auto transitionStage = scene->getStage<render::TransitionStage>();
uint64_t now = usecTimestampNow();
const double deltaTime = (int64_t(now) - int64_t(_previousTime)) / double(USECS_PER_SECOND);
render::Transaction transaction;
bool isFirstItem = true;
bool hasTransaction = false;
output = (FadeCategory) jobConfig->editedCategory;
// And now update fade effect
for (auto transitionId : *transitionStage) {

4
libraries/render-utils/src/FadeEffectJobs.h
View file

@ -207,7 +207,7 @@ public:
void configure(const Config& config);
void run(const render::RenderContextPointer& renderContext, FadeJob::Output& output);
gpu::BufferView getConfigurationBuffer() const { return _configurations; }
static gpu::BufferView getConfigurationBuffer() { return _configurations; }
private:
@ -219,7 +219,7 @@ private:
};
using FadeConfigurationBuffer = gpu::StructBuffer<FadeConfiguration>;
FadeConfigurationBuffer _configurations;
static FadeConfigurationBuffer _configurations;
float _thresholdScale[FADE_CATEGORY_COUNT];
uint64_t _previousTime{ 0 };

5
libraries/render-utils/src/GeometryCache.cpp
View file

@ -725,9 +725,8 @@ render::ShapePipelinePointer GeometryCache::getShapePipeline(bool textured, bool
render::ShapePipelinePointer GeometryCache::getFadingShapePipeline(bool textured, bool transparent, bool unlit, bool depthBias, bool forward,
graphics::MaterialKey::CullFaceMode cullFaceMode) {
auto fadeEffect = DependencyManager::get<FadeEffect>();
auto fadeBatchSetter = fadeEffect->getBatchSetter();
auto fadeItemSetter = fadeEffect->getItemUniformSetter();
auto fadeBatchSetter = FadeEffect::getBatchSetter();
auto fadeItemSetter = FadeEffect::getItemUniformSetter();
return std::make_shared<render::ShapePipeline>(getSimplePipeline(textured, transparent, unlit, depthBias, true, true, forward, cullFaceMode), nullptr,
[fadeBatchSetter, fadeItemSetter](const render::ShapePipeline& shapePipeline, gpu::Batch& batch, render::Args* args) {
batch.setResourceTexture(gr::Texture::MaterialAlbedo, DependencyManager::get<TextureCache>()->getWhiteTexture());

15
libraries/render-utils/src/HighlightEffect.cpp
View file

@ -156,7 +156,7 @@ void DrawHighlightMask::run(const render::RenderContextPointer& renderContext, c
_boundsBuffer = std::make_shared<gpu::Buffer>(sizeof(render::ItemBound));
}
auto highlightStage = renderContext->_scene->getStage<render::HighlightStage>(render::HighlightStage::getName());
auto highlightStage = renderContext->_scene->getStage<render::HighlightStage>();
auto highlightId = _sharedParameters->_highlightIds[_highlightPassIndex];
if (!inShapes.empty() && !render::HighlightStage::isIndexInvalid(highlightId)) {
@ -244,7 +244,7 @@ void DrawHighlight::run(const render::RenderContextPointer& renderContext, const
if (sceneDepthBuffer) {
auto args = renderContext->args;
auto highlightStage = renderContext->_scene->getStage<render::HighlightStage>(render::HighlightStage::getName());
auto highlightStage = renderContext->_scene->getStage<render::HighlightStage>();
auto highlightId = _sharedParameters->_highlightIds[_highlightPassIndex];
if (!render::HighlightStage::isIndexInvalid(highlightId)) {
auto& highlight = highlightStage->getHighlight(highlightId);
@ -311,6 +311,8 @@ const gpu::PipelinePointer& DrawHighlight::getPipeline(const render::HighlightSt
return style.isFilled() ? _pipelineFilled : _pipeline;
}
gpu::PipelinePointer DebugHighlight::_depthPipeline;
DebugHighlight::DebugHighlight() {
_geometryDepthId = DependencyManager::get<GeometryCache>()->allocateID();
}
@ -396,7 +398,7 @@ void DebugHighlight::initializePipelines() {
_depthPipeline = gpu::Pipeline::create(program, state);
}
const gpu::PipelinePointer& DebugHighlight::getDepthPipeline() {
gpu::PipelinePointer& DebugHighlight::getDepthPipeline() {
if (!_depthPipeline) {
initializePipelines();
}
@ -406,7 +408,7 @@ const gpu::PipelinePointer& DebugHighlight::getDepthPipeline() {
void SelectionToHighlight::run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs) {
auto scene = renderContext->_scene;
auto highlightStage = scene->getStage<render::HighlightStage>(render::HighlightStage::getName());
auto highlightStage = scene->getStage<render::HighlightStage>();
auto outlines = inputs.get0();
auto framebuffer = inputs.get1();
@ -479,8 +481,7 @@ void DrawHighlightTask::build(JobModel& task, const render::Varying& inputs, ren
std::call_once(once, [] {
auto state = std::make_shared<gpu::State>();
state->setColorWriteMask(false, false, false, false);
auto fadeEffect = DependencyManager::get<FadeEffect>();
initZPassPipelines(*shapePlumber, state, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter());
initZPassPipelines(*shapePlumber, state, FadeEffect::getBatchSetter(), FadeEffect::getItemUniformSetter());
});
auto sharedParameters = std::make_shared<HighlightSharedParameters>();
@ -568,7 +569,7 @@ void AppendNonMetaOutlines::run(const render::RenderContextPointer& renderContex
void HighlightCleanup::run(const render::RenderContextPointer& renderContext, const Inputs& inputs) {
auto scene = renderContext->_scene;
auto highlightStage = scene->getStage<render::HighlightStage>(render::HighlightStage::getName());
auto highlightStage = scene->getStage<render::HighlightStage>();
for (auto index : inputs.get0()) {
std::string selectionName = highlightStage->getHighlight(index)._selectionName;

6
libraries/render-utils/src/HighlightEffect.h
View file

@ -186,12 +186,12 @@ public:
private:
gpu::PipelinePointer _depthPipeline;
static gpu::PipelinePointer _depthPipeline;
int _geometryDepthId{ 0 };
bool _isDisplayEnabled{ false };
const gpu::PipelinePointer& getDepthPipeline();
void initializePipelines();
static gpu::PipelinePointer& getDepthPipeline();
static void initializePipelines();
};
class DrawHighlightTask {

13
libraries/render-utils/src/LightClusters.cpp
View file

@ -575,10 +575,9 @@ void LightClusteringPass::run(const render::RenderContextPointer& renderContext,
config->setNumClusteredLightReferences(clusteringStats.z);
}
DebugLightClusters::DebugLightClusters() {
}
gpu::PipelinePointer DebugLightClusters::_drawClusterGrid;
gpu::PipelinePointer DebugLightClusters::_drawClusterFromDepth;
gpu::PipelinePointer DebugLightClusters::_drawClusterContent;
void DebugLightClusters::configure(const Config& config) {
doDrawGrid = config.doDrawGrid;
@ -587,7 +586,7 @@ void DebugLightClusters::configure(const Config& config) {
}
const gpu::PipelinePointer DebugLightClusters::getDrawClusterGridPipeline() {
gpu::PipelinePointer DebugLightClusters::getDrawClusterGridPipeline() {
if (!_drawClusterGrid) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::lightClusters_drawGrid);
auto state = std::make_shared<gpu::State>();
@ -603,7 +602,7 @@ const gpu::PipelinePointer DebugLightClusters::getDrawClusterGridPipeline() {
return _drawClusterGrid;
}
const gpu::PipelinePointer DebugLightClusters::getDrawClusterFromDepthPipeline() {
gpu::PipelinePointer DebugLightClusters::getDrawClusterFromDepthPipeline() {
if (!_drawClusterFromDepth) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::lightClusters_drawClusterFromDepth);
auto state = std::make_shared<gpu::State>();
@ -617,7 +616,7 @@ const gpu::PipelinePointer DebugLightClusters::getDrawClusterFromDepthPipeline()
return _drawClusterFromDepth;
}
const gpu::PipelinePointer DebugLightClusters::getDrawClusterContentPipeline() {
gpu::PipelinePointer DebugLightClusters::getDrawClusterContentPipeline() {
if (!_drawClusterContent) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::lightClusters_drawClusterContent);
auto state = std::make_shared<gpu::State>();

16
libraries/render-utils/src/LightClusters.h
View file

@ -217,23 +217,25 @@ public:
using Config = DebugLightClustersConfig;
using JobModel = render::Job::ModelI<DebugLightClusters, Inputs, Config>;
DebugLightClusters();
DebugLightClusters() {}
void configure(const Config& config);
void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
protected:
static gpu::PipelinePointer _drawClusterGrid;
static gpu::PipelinePointer _drawClusterFromDepth;
static gpu::PipelinePointer _drawClusterContent;
gpu::BufferPointer _gridBuffer;
gpu::PipelinePointer _drawClusterGrid;
gpu::PipelinePointer _drawClusterFromDepth;
gpu::PipelinePointer _drawClusterContent;
const gpu::PipelinePointer getDrawClusterGridPipeline();
const gpu::PipelinePointer getDrawClusterFromDepthPipeline();
const gpu::PipelinePointer getDrawClusterContentPipeline();
bool doDrawGrid { false };
bool doDrawClusterFromDepth { false };
bool doDrawContent { false };
static gpu::PipelinePointer getDrawClusterGridPipeline();
static gpu::PipelinePointer getDrawClusterFromDepthPipeline();
static gpu::PipelinePointer getDrawClusterContentPipeline();
};
#endif

5
libraries/render-utils/src/RenderCommonTask.cpp
View file

@ -357,9 +357,8 @@ public:
state->setDepthTest(true, true, gpu::LESS_EQUAL);
PrepareStencil::testMaskDrawShape(*state);
auto fadeEffect = DependencyManager::get<FadeEffect>();
initMirrorPipelines(*_forwardPipelines, state, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter(), true);
initMirrorPipelines(*_deferredPipelines, state, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter(), false);
initMirrorPipelines(*_forwardPipelines, state, FadeEffect::getBatchSetter(), FadeEffect::getItemUniformSetter(), true);
initMirrorPipelines(*_deferredPipelines, state, FadeEffect::getBatchSetter(), FadeEffect::getItemUniformSetter(), false);
});
}

9
libraries/render-utils/src/RenderDeferredTask.cpp
View file

@ -101,12 +101,11 @@ void RenderDeferredTask::configure(const Config& config) {
}
void RenderDeferredTask::build(JobModel& task, const render::Varying& input, render::Varying& output, render::CullFunctor cullFunctor, size_t depth) {
static auto fadeEffect = DependencyManager::get<FadeEffect>();
// Prepare the ShapePipelines
static ShapePlumberPointer shapePlumber = std::make_shared<ShapePlumber>();
static std::once_flag once;
std::call_once(once, [] {
initDeferredPipelines(*shapePlumber, fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter());
initDeferredPipelines(*shapePlumber, FadeEffect::getBatchSetter(), FadeEffect::getItemUniformSetter());
});
const auto& inputs = input.get<Input>();
@ -146,7 +145,9 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
// Shadow Stage Frame
const auto shadowFrame = shadowTaskOutputs[1];
fadeEffect->build(task, opaques);
if (depth == 0) {
task.addJob<FadeEffect>("FadeEffect", opaques);
}
const auto jitter = task.addJob<JitterSample>("JitterCam");
@ -256,7 +257,7 @@ void RenderDeferredTask::build(JobModel& task, const render::Varying& input, ren
const auto toneMappedBuffer = task.addJob<ToneMapAndResample>("ToneMapping", toneMappingInputs);
// Debugging task is happening in the "over" layer after tone mapping and just before HUD
{ // Debug the bounds of the rendered items, still look at the zbuffer
if (depth == 0) { // Debug the bounds of the rendered items, still look at the zbuffer
const auto extraDebugBuffers = RenderDeferredTaskDebug::ExtraBuffers(linearDepthTarget, surfaceGeometryFramebuffer, ambientOcclusionFramebuffer, ambientOcclusionUniforms, scatteringResource, velocityBuffer);
const auto debugInputs = RenderDeferredTaskDebug::Input(fetchedItems, shadowTaskOutputs, lightingStageInputs, lightClusters, prepareDeferredOutputs, extraDebugBuffers,
deferredFrameTransform, jitter, lightingModel).asVarying();

8
libraries/render-utils/src/RenderForwardTask.cpp
View file

@ -26,7 +26,6 @@
#include "render-utils/ShaderConstants.h"
#include "StencilMaskPass.h"
#include "ZoneRenderer.h"
#include "FadeEffect.h"
#include "ToneMapAndResampleTask.h"
#include "BackgroundStage.h"
#include "FramebufferCache.h"
@ -72,7 +71,6 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
task.addJob<SetRenderMethod>("SetRenderMethodTask", render::Args::FORWARD);
// Prepare the ShapePipelines
auto fadeEffect = DependencyManager::get<FadeEffect>();
static ShapePlumberPointer shapePlumber = std::make_shared<ShapePlumber>();
static std::once_flag once;
std::call_once(once, [] {
@ -112,9 +110,6 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
const auto& zones = lightingStageInputs[1];
// First job, alter faded
fadeEffect->build(task, opaques);
// GPU jobs: Start preparing the main framebuffer
const auto scaledPrimaryFramebuffer = task.addJob<PreparePrimaryFramebufferMSAA>("PreparePrimaryBufferForward");
@ -161,8 +156,7 @@ void RenderForwardTask::build(JobModel& task, const render::Varying& input, rend
task.addJob<DrawLayered3D>("DrawInFrontOpaque", inFrontOpaquesInputs, true);
task.addJob<DrawLayered3D>("DrawInFrontTransparent", inFrontTransparentsInputs, false);
{ // Debug the bounds of the rendered items, still look at the zbuffer
if (depth == 0) { // Debug the bounds of the rendered items, still look at the zbuffer
task.addJob<DrawBounds>("DrawMetaBounds", metas);
task.addJob<DrawBounds>("DrawBounds", opaques);
task.addJob<DrawBounds>("DrawTransparentBounds", transparents);

3
libraries/render-utils/src/RenderShadowTask.cpp
View file

@ -50,8 +50,7 @@ void RenderShadowTask::build(JobModel& task, const render::Varying& input, rende
static ShapePlumberPointer shapePlumber = std::make_shared<ShapePlumber>();
static std::once_flag once;
std::call_once(once, [] {
auto fadeEffect = DependencyManager::get<FadeEffect>();
initZPassPipelines(*shapePlumber, std::make_shared<gpu::State>(), fadeEffect->getBatchSetter(), fadeEffect->getItemUniformSetter());
initZPassPipelines(*shapePlumber, std::make_shared<gpu::State>(), FadeEffect::getBatchSetter(), FadeEffect::getItemUniformSetter());
});
const auto setupOutput = task.addJob<RenderShadowSetup>("ShadowSetup", input);

4
libraries/render-utils/src/StencilMaskPass.cpp
View file

@ -17,6 +17,10 @@
using namespace render;
gpu::PipelinePointer PrepareStencil::_meshStencilPipeline;
gpu::PipelinePointer PrepareStencil::_paintStencilPipeline;
graphics::MeshPointer PrepareStencil::_mesh;
void PrepareStencil::configure(const Config& config) {
_maskMode = config.maskMode;
}

12
libraries/render-utils/src/StencilMaskPass.h
View file

@ -59,14 +59,14 @@ public:
static void testMaskDrawShapeNoAA(gpu::State& state);
private:
gpu::PipelinePointer _meshStencilPipeline;
gpu::PipelinePointer getMeshStencilPipeline();
static gpu::PipelinePointer _meshStencilPipeline;
static gpu::PipelinePointer getMeshStencilPipeline();
gpu::PipelinePointer _paintStencilPipeline;
gpu::PipelinePointer getPaintStencilPipeline();
static gpu::PipelinePointer _paintStencilPipeline;
static gpu::PipelinePointer getPaintStencilPipeline();
graphics::MeshPointer _mesh;
graphics::MeshPointer getMesh();
static graphics::MeshPointer _mesh;
static graphics::MeshPointer getMesh();
StencilMaskMode _maskMode { StencilMaskMode::NONE };
};

13
libraries/render-utils/src/SubsurfaceScattering.cpp
View file

@ -411,8 +411,8 @@ gpu::TexturePointer SubsurfaceScatteringResource::generateScatteringSpecularBeck
return beckmannMap;
}
DebugSubsurfaceScattering::DebugSubsurfaceScattering() {
}
gpu::PipelinePointer DebugSubsurfaceScattering::_scatteringPipeline;
gpu::PipelinePointer DebugSubsurfaceScattering::_showLUTPipeline;
void DebugSubsurfaceScattering::configure(const Config& config) {
@ -427,8 +427,6 @@ void DebugSubsurfaceScattering::configure(const Config& config) {
_debugParams->setSubData(0, _debugCursorTexcoord);
}
gpu::PipelinePointer DebugSubsurfaceScattering::getScatteringPipeline() {
if (!_scatteringPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::subsurfaceScattering_drawScattering);
@ -440,8 +438,6 @@ gpu::PipelinePointer DebugSubsurfaceScattering::getScatteringPipeline() {
return _scatteringPipeline;
}
gpu::PipelinePointer _showLUTPipeline;
gpu::PipelinePointer DebugSubsurfaceScattering::getShowLUTPipeline() {
if (!_showLUTPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::gpu::program::drawUnitQuatTextureOpaque);
@ -452,14 +448,12 @@ gpu::PipelinePointer DebugSubsurfaceScattering::getShowLUTPipeline() {
return _showLUTPipeline;
}
void DebugSubsurfaceScattering::run(const render::RenderContextPointer& renderContext, const Inputs& inputs) {
assert(renderContext->args);
assert(renderContext->args->hasViewFrustum());
RenderArgs* args = renderContext->args;
auto& frameTransform = inputs.get0();
auto& deferredFramebuffer = inputs.get1();
@ -477,8 +471,6 @@ void DebugSubsurfaceScattering::run(const render::RenderContextPointer& renderCo
auto scatteringTable = scatteringResource->getScatteringTable();
auto scatteringSpecular = scatteringResource->getScatteringSpecular();
auto lightStage = renderContext->_scene->getStage<LightStage>();
assert(lightStage);
// const auto light = DependencyManager::get<DeferredLightingEffect>()->getLightStage()->getLight(0);
@ -491,7 +483,6 @@ void DebugSubsurfaceScattering::run(const render::RenderContextPointer& renderCo
gpu::doInBatch("DebugSubsurfaceScattering::run", args->_context, [=](gpu::Batch& batch) {
batch.enableStereo(false);
auto viewportSize = std::min(args->_viewport.z, args->_viewport.w) >> 1;
auto offsetViewport = viewportSize * 0.1;

11
libraries/render-utils/src/SubsurfaceScattering.h
View file

@ -167,18 +167,19 @@ public:
using Config = DebugSubsurfaceScatteringConfig;
using JobModel = render::Job::ModelI<DebugSubsurfaceScattering, Inputs, Config>;
DebugSubsurfaceScattering();
DebugSubsurfaceScattering() {}
void configure(const Config& config);
void run(const render::RenderContextPointer& renderContext, const Inputs& inputs);
private:
gpu::PipelinePointer _scatteringPipeline;
gpu::PipelinePointer getScatteringPipeline();
static gpu::PipelinePointer _scatteringPipeline;
static gpu::PipelinePointer getScatteringPipeline();
static gpu::PipelinePointer _showLUTPipeline;
static gpu::PipelinePointer getShowLUTPipeline();
gpu::PipelinePointer _showLUTPipeline;
gpu::PipelinePointer getShowLUTPipeline();
gpu::BufferPointer _debugParams;
bool _showProfile{ false };
bool _showLUT{ false };

21
libraries/render-utils/src/SurfaceGeometryPass.cpp
View file

@ -137,9 +137,8 @@ gpu::TexturePointer LinearDepthFramebuffer::getHalfNormalTexture() {
return _halfNormalTexture;
}
LinearDepthPass::LinearDepthPass() {
}
gpu::PipelinePointer LinearDepthPass::_linearDepthPipeline;
gpu::PipelinePointer LinearDepthPass::_downsamplePipeline;
void LinearDepthPass::configure(const Config& config) {
}
@ -179,8 +178,8 @@ void LinearDepthPass::run(const render::RenderContextPointer& renderContext, con
outputs.edit3() = halfLinearDepthTexture;
outputs.edit4() = halfNormalTexture;
auto linearDepthPipeline = getLinearDepthPipeline(renderContext);
auto downsamplePipeline = getDownsamplePipeline(renderContext);
auto linearDepthPipeline = getLinearDepthPipeline();
auto downsamplePipeline = getDownsamplePipeline();
auto depthViewport = args->_viewport;
auto halfViewport = depthViewport >> 1;
@ -222,8 +221,7 @@ void LinearDepthPass::run(const render::RenderContextPointer& renderContext, con
config->setGPUBatchRunTime(_gpuTimer->getGPUAverage(), _gpuTimer->getBatchAverage());
}
const gpu::PipelinePointer& LinearDepthPass::getLinearDepthPipeline(const render::RenderContextPointer& renderContext) {
const gpu::PipelinePointer& LinearDepthPass::getLinearDepthPipeline() {
gpu::ShaderPointer program;
if (!_linearDepthPipeline) {
program = gpu::Shader::createProgram(shader::render_utils::program::surfaceGeometry_makeLinearDepth);
@ -243,8 +241,7 @@ const gpu::PipelinePointer& LinearDepthPass::getLinearDepthPipeline(const render
return _linearDepthPipeline;
}
const gpu::PipelinePointer& LinearDepthPass::getDownsamplePipeline(const render::RenderContextPointer& renderContext) {
const gpu::PipelinePointer& LinearDepthPass::getDownsamplePipeline() {
if (!_downsamplePipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::surfaceGeometry_downsampleDepthNormal);
@ -366,6 +363,8 @@ void SurfaceGeometryFramebuffer::setResolutionLevel(int resolutionLevel) {
}
}
gpu::PipelinePointer SurfaceGeometryPass::_curvaturePipeline;
SurfaceGeometryPass::SurfaceGeometryPass() :
_diffusePass(false)
{
@ -454,7 +453,7 @@ void SurfaceGeometryPass::run(const render::RenderContextPointer& renderContext,
outputs.edit2() = curvatureFramebuffer;
outputs.edit3() = lowCurvatureFramebuffer;
auto curvaturePipeline = getCurvaturePipeline(renderContext);
auto curvaturePipeline = getCurvaturePipeline();
auto diffuseVPipeline = _diffusePass.getBlurVPipeline();
auto diffuseHPipeline = _diffusePass.getBlurHPipeline();
@ -532,7 +531,7 @@ void SurfaceGeometryPass::run(const render::RenderContextPointer& renderContext,
config->setGPUBatchRunTime(_gpuTimer->getGPUAverage(), _gpuTimer->getBatchAverage());
}
const gpu::PipelinePointer& SurfaceGeometryPass::getCurvaturePipeline(const render::RenderContextPointer& renderContext) {
const gpu::PipelinePointer& SurfaceGeometryPass::getCurvaturePipeline() {
if (!_curvaturePipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::surfaceGeometry_makeCurvature);

20
libraries/render-utils/src/SurfaceGeometryPass.h
View file

@ -73,21 +73,19 @@ public:
using Config = LinearDepthPassConfig;
using JobModel = render::Job::ModelIO<LinearDepthPass, Inputs, Outputs, Config>;
LinearDepthPass();
LinearDepthPass() {}
void configure(const Config& config);
void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
private:
typedef gpu::BufferView UniformBufferView;
LinearDepthFramebufferPointer _linearDepthFramebuffer;
const gpu::PipelinePointer& getLinearDepthPipeline(const render::RenderContextPointer& renderContext);
gpu::PipelinePointer _linearDepthPipeline;
static const gpu::PipelinePointer& getLinearDepthPipeline();
static gpu::PipelinePointer _linearDepthPipeline;
const gpu::PipelinePointer& getDownsamplePipeline(const render::RenderContextPointer& renderContext);
gpu::PipelinePointer _downsamplePipeline;
static const gpu::PipelinePointer& getDownsamplePipeline();
static gpu::PipelinePointer _downsamplePipeline;
gpu::RangeTimerPointer _gpuTimer;
};
@ -194,16 +192,14 @@ private:
};
gpu::BufferView _parametersBuffer;
SurfaceGeometryFramebufferPointer _surfaceGeometryFramebuffer;
const gpu::PipelinePointer& getCurvaturePipeline(const render::RenderContextPointer& renderContext);
static const gpu::PipelinePointer& getCurvaturePipeline();
static gpu::PipelinePointer _curvaturePipeline;
gpu::PipelinePointer _curvaturePipeline;
render::BlurGaussianDepthAware _diffusePass;
gpu::RangeTimerPointer _gpuTimer;
};

1
libraries/render-utils/src/ToneMapAndResampleTask.h
View file

@ -67,7 +67,6 @@ protected:
gpu::FramebufferPointer _destinationFrameBuffer;
private:
gpu::PipelinePointer _blitLightBuffer;
float _exposure { 0.0f };
bool _debug { false };

7
libraries/render-utils/src/VelocityBufferPass.cpp
View file

@ -81,8 +81,7 @@ gpu::TexturePointer VelocityFramebuffer::getVelocityTexture() {
return _velocityTexture;
}
VelocityBufferPass::VelocityBufferPass() {
}
gpu::PipelinePointer VelocityBufferPass::_cameraMotionPipeline;
void VelocityBufferPass::configure(const Config& config) {
}
@ -114,7 +113,7 @@ void VelocityBufferPass::run(const render::RenderContextPointer& renderContext,
outputs.edit1() = velocityFBO;
outputs.edit2() = velocityTexture;
auto cameraMotionPipeline = getCameraMotionPipeline(renderContext);
auto cameraMotionPipeline = getCameraMotionPipeline();
auto fullViewport = args->_viewport;
@ -144,7 +143,7 @@ void VelocityBufferPass::run(const render::RenderContextPointer& renderContext,
}
const gpu::PipelinePointer& VelocityBufferPass::getCameraMotionPipeline(const render::RenderContextPointer& renderContext) {
const gpu::PipelinePointer& VelocityBufferPass::getCameraMotionPipeline() {
if (!_cameraMotionPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::velocityBuffer_cameraMotion);
gpu::StatePointer state = std::make_shared<gpu::State>();

6
libraries/render-utils/src/VelocityBufferPass.h
View file

@ -69,7 +69,7 @@ public:
using Config = VelocityBufferPassConfig;
using JobModel = render::Job::ModelIO<VelocityBufferPass, Inputs, Outputs, Config>;
VelocityBufferPass();
VelocityBufferPass() {}
void configure(const Config& config);
void run(const render::RenderContextPointer& renderContext, const Inputs& inputs, Outputs& outputs);
@ -79,8 +79,8 @@ private:
VelocityFramebufferPointer _velocityFramebuffer;
const gpu::PipelinePointer& getCameraMotionPipeline(const render::RenderContextPointer& renderContext);
gpu::PipelinePointer _cameraMotionPipeline;
static const gpu::PipelinePointer& getCameraMotionPipeline();
static gpu::PipelinePointer _cameraMotionPipeline;
gpu::RangeTimerPointer _gpuTimer;
};

4
libraries/render-utils/src/ZoneRenderer.cpp
View file

@ -93,6 +93,10 @@ void SetupZones::run(const RenderContextPointer& context, const Input& input) {
ambientOcclusionStage->_currentFrame.pushAmbientOcclusion(INVALID_INDEX);
}
gpu::PipelinePointer DebugZoneLighting::_keyLightPipeline;
gpu::PipelinePointer DebugZoneLighting::_ambientPipeline;
gpu::PipelinePointer DebugZoneLighting::_backgroundPipeline;
const gpu::PipelinePointer& DebugZoneLighting::getKeyLightPipeline() {
if (!_keyLightPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render_utils::program::zone_drawKeyLight);

12
libraries/render-utils/src/ZoneRenderer.h
View file

@ -83,13 +83,13 @@ public:
protected:
gpu::PipelinePointer _keyLightPipeline;
gpu::PipelinePointer _ambientPipeline;
gpu::PipelinePointer _backgroundPipeline;
static gpu::PipelinePointer _keyLightPipeline;
static gpu::PipelinePointer _ambientPipeline;
static gpu::PipelinePointer _backgroundPipeline;
const gpu::PipelinePointer& getKeyLightPipeline();
const gpu::PipelinePointer& getAmbientPipeline();
const gpu::PipelinePointer& getBackgroundPipeline();
static const gpu::PipelinePointer& getKeyLightPipeline();
static const gpu::PipelinePointer& getAmbientPipeline();
static const gpu::PipelinePointer& getBackgroundPipeline();
};

6
libraries/render/src/render/BlurTask.cpp
View file

@ -195,6 +195,9 @@ bool BlurInOutResource::updateResources(const gpu::FramebufferPointer& sourceFra
return true;
}
gpu::PipelinePointer BlurGaussian::_blurVPipeline;
gpu::PipelinePointer BlurGaussian::_blurHPipeline;
BlurGaussian::BlurGaussian() {
_parameters = std::make_shared<BlurParams>();
}
@ -294,7 +297,8 @@ void BlurGaussian::run(const RenderContextPointer& renderContext, const Inputs&
});
}
gpu::PipelinePointer BlurGaussianDepthAware::_blurVPipeline;
gpu::PipelinePointer BlurGaussianDepthAware::_blurHPipeline;
BlurGaussianDepthAware::BlurGaussianDepthAware(bool generateOutputFramebuffer, const BlurParamsPointer& params) :
_inOutResources(generateOutputFramebuffer, 1U),

16
libraries/render/src/render/BlurTask.h
View file

@ -129,11 +129,11 @@ protected:
BlurParamsPointer _parameters;
gpu::PipelinePointer _blurVPipeline;
gpu::PipelinePointer _blurHPipeline;
static gpu::PipelinePointer _blurVPipeline;
static gpu::PipelinePointer _blurHPipeline;
gpu::PipelinePointer getBlurVPipeline();
gpu::PipelinePointer getBlurHPipeline();
static gpu::PipelinePointer getBlurVPipeline();
static gpu::PipelinePointer getBlurHPipeline();
BlurInOutResource _inOutResources;
};
@ -163,12 +163,12 @@ public:
const BlurParamsPointer& getParameters() const { return _parameters; }
gpu::PipelinePointer getBlurVPipeline();
gpu::PipelinePointer getBlurHPipeline();
static gpu::PipelinePointer getBlurVPipeline();
static gpu::PipelinePointer getBlurHPipeline();
protected:
gpu::PipelinePointer _blurVPipeline;
gpu::PipelinePointer _blurHPipeline;
static gpu::PipelinePointer _blurVPipeline;
static gpu::PipelinePointer _blurHPipeline;
BlurInOutResource _inOutResources;
BlurParamsPointer _parameters;

18
libraries/render/src/render/DrawSceneOctree.cpp
View file

@ -24,6 +24,18 @@
using namespace render;
gpu::PipelinePointer DrawSceneOctree::_drawCellBoundsPipeline;
gpu::PipelinePointer DrawSceneOctree::_drawLODReticlePipeline;
gpu::PipelinePointer DrawSceneOctree::_drawItemBoundPipeline;
gpu::Stream::FormatPointer DrawSceneOctree::_cellBoundsFormat = std::make_shared<gpu::Stream::Format>();
DrawSceneOctree::DrawSceneOctree() {
std::once_flag once;
std::call_once(once, [] {
_cellBoundsFormat->setAttribute(0, 0, gpu::Element(gpu::VEC4, gpu::INT32, gpu::XYZW), 0, gpu::Stream::PER_INSTANCE);
});
}
const gpu::PipelinePointer DrawSceneOctree::getDrawCellBoundsPipeline() {
if (!_drawCellBoundsPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render::program::drawCellBounds);
@ -36,9 +48,6 @@ const gpu::PipelinePointer DrawSceneOctree::getDrawCellBoundsPipeline() {
// Good to go add the brand new pipeline
_drawCellBoundsPipeline = gpu::Pipeline::create(program, state);
_cellBoundsFormat = std::make_shared<gpu::Stream::Format>();
_cellBoundsFormat->setAttribute(0, 0, gpu::Element(gpu::VEC4, gpu::INT32, gpu::XYZW), 0, gpu::Stream::PER_INSTANCE);
_cellBoundsBuffer = std::make_shared<gpu::Buffer>();
}
return _drawCellBoundsPipeline;
}
@ -62,7 +71,6 @@ void DrawSceneOctree::configure(const Config& config) {
_showEmptyCells = config.showEmptyCells;
}
void DrawSceneOctree::run(const RenderContextPointer& renderContext, const ItemSpatialTree::ItemSelection& inSelection) {
assert(renderContext->args);
assert(renderContext->args->hasViewFrustum());
@ -132,6 +140,8 @@ void DrawSceneOctree::run(const RenderContextPointer& renderContext, const ItemS
});
}
gpu::PipelinePointer DrawItemSelection::_drawItemBoundPipeline;
const gpu::PipelinePointer DrawItemSelection::getDrawItemBoundPipeline() {
if (!_drawItemBoundPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render::program::drawItemBounds);

22
libraries/render/src/render/DrawSceneOctree.h
View file

@ -50,11 +50,11 @@ namespace render {
};
class DrawSceneOctree {
gpu::PipelinePointer _drawCellBoundsPipeline;
gpu::PipelinePointer _drawLODReticlePipeline;
gpu::PipelinePointer _drawItemBoundPipeline;
gpu::BufferPointer _cellBoundsBuffer;
gpu::Stream::FormatPointer _cellBoundsFormat;
static gpu::PipelinePointer _drawCellBoundsPipeline;
static gpu::PipelinePointer _drawLODReticlePipeline;
static gpu::PipelinePointer _drawItemBoundPipeline;
static gpu::Stream::FormatPointer _cellBoundsFormat;
gpu::BufferPointer _cellBoundsBuffer { std::make_shared<gpu::Buffer>() };
bool _showVisibleCells; // initialized by Config
bool _showEmptyCells; // initialized by Config
@ -63,14 +63,14 @@ namespace render {
using Config = DrawSceneOctreeConfig;
using JobModel = Job::ModelI<DrawSceneOctree, ItemSpatialTree::ItemSelection, Config>;
DrawSceneOctree() {}
DrawSceneOctree();
void configure(const Config& config);
void run(const RenderContextPointer& renderContext, const ItemSpatialTree::ItemSelection& selection);
const gpu::PipelinePointer getDrawCellBoundsPipeline();
const gpu::PipelinePointer getDrawLODReticlePipeline();
const gpu::PipelinePointer getDrawItemBoundPipeline();
static const gpu::PipelinePointer getDrawCellBoundsPipeline();
static const gpu::PipelinePointer getDrawLODReticlePipeline();
static const gpu::PipelinePointer getDrawItemBoundPipeline();
};
@ -105,7 +105,7 @@ namespace render {
};
class DrawItemSelection {
gpu::PipelinePointer _drawItemBoundPipeline;
static gpu::PipelinePointer _drawItemBoundPipeline;
gpu::BufferPointer _boundsBufferInside;
gpu::BufferPointer _boundsBufferInsideSubcell;
gpu::BufferPointer _boundsBufferPartial;
@ -125,7 +125,7 @@ namespace render {
void configure(const Config& config);
void run(const RenderContextPointer& renderContext, const ItemSpatialTree::ItemSelection& selection);
const gpu::PipelinePointer getDrawItemBoundPipeline();
static const gpu::PipelinePointer getDrawItemBoundPipeline();
};
}

6
libraries/render/src/render/DrawStatus.cpp
View file

@ -32,6 +32,10 @@ void DrawStatusConfig::dirtyHelper() {
emit dirty();
}
gpu::PipelinePointer DrawStatus::_drawItemBoundsPipeline;
gpu::PipelinePointer DrawStatus::_drawItemStatusPipeline;
gpu::Stream::FormatPointer DrawStatus::_vertexFormat;
const gpu::PipelinePointer DrawStatus::getDrawItemBoundsPipeline() {
if (!_drawItemBoundsPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render::program::drawItemBounds);
@ -149,7 +153,7 @@ void DrawStatus::run(const RenderContextPointer& renderContext, const Input& inp
// We have a transition. Show this icon.
status.setScale(1.0f);
// Is this a valid transition ID according to FadeJob?
auto transitionStage = scene->getStage<TransitionStage>(TransitionStage::getName());
auto transitionStage = scene->getStage<TransitionStage>();
if (transitionStage) {
if (transitionStage->isTransitionUsed(transitionID)) {
// Valid, active transition

11
libraries/render/src/render/DrawStatus.h
View file

@ -52,8 +52,8 @@ namespace render {
void configure(const Config& config);
void run(const RenderContextPointer& renderContext, const Input& input);
const gpu::PipelinePointer getDrawItemBoundsPipeline();
const gpu::PipelinePointer getDrawItemStatusPipeline();
static const gpu::PipelinePointer getDrawItemBoundsPipeline();
static const gpu::PipelinePointer getDrawItemStatusPipeline();
void setStatusIconMap(const gpu::TexturePointer& map);
const gpu::TexturePointer getStatusIconMap() const;
@ -63,13 +63,12 @@ namespace render {
bool _showNetwork { false }; // initialized by Config
bool _showFade { false }; // initialized by Config
gpu::Stream::FormatPointer _drawItemFormat;
gpu::PipelinePointer _drawItemBoundsPipeline;
gpu::PipelinePointer _drawItemStatusPipeline;
static gpu::PipelinePointer _drawItemBoundsPipeline;
static gpu::PipelinePointer _drawItemStatusPipeline;
static gpu::Stream::FormatPointer _vertexFormat;
gpu::BufferPointer _boundsBuffer;
gpu::BufferPointer _instanceBuffer;
gpu::Stream::FormatPointer _vertexFormat;
gpu::TexturePointer _statusIconMap;
};
}

2
libraries/render/src/render/DrawTask.cpp
View file

@ -155,6 +155,8 @@ void DrawLight::run(const RenderContextPointer& renderContext, const ItemBounds&
config->setNumDrawn((int)inLights.size());
}
gpu::PipelinePointer DrawBounds::_boundsPipeline;
const gpu::PipelinePointer DrawBounds::getPipeline() {
if (!_boundsPipeline) {
gpu::ShaderPointer program = gpu::Shader::createProgram(shader::render::program::drawItemBounds);

4
libraries/render/src/render/DrawTask.h
View file

@ -63,8 +63,8 @@ public:
const Inputs& items);
private:
const gpu::PipelinePointer getPipeline();
gpu::PipelinePointer _boundsPipeline;
static const gpu::PipelinePointer getPipeline();
static gpu::PipelinePointer _boundsPipeline;
gpu::BufferPointer _drawBuffer;
gpu::BufferPointer _paramsBuffer;
};

12
libraries/render/src/render/Scene.cpp
View file

@ -382,7 +382,7 @@ void Scene::updateItems(const Transaction::Updates& transactions) {
}
void Scene::resetTransitionItems(const Transaction::TransitionResets& transactions) {
auto transitionStage = getStage<TransitionStage>(TransitionStage::getName());
auto transitionStage = getStage<TransitionStage>();
if (!transitionStage) {
return;
@ -425,7 +425,7 @@ void Scene::removeTransitionItems(const Transaction::TransitionRemoves& transact
}
void Scene::queryTransitionItems(const Transaction::TransitionQueries& transactions) {
auto transitionStage = getStage<TransitionStage>(TransitionStage::getName());
auto transitionStage = getStage<TransitionStage>();
if (!transitionStage) {
return;
@ -467,7 +467,7 @@ void Scene::resetTransitionFinishedOperator(const Transaction::TransitionFinishe
}
void Scene::resetHighlights(const Transaction::HighlightResets& transactions) {
auto outlineStage = getStage<HighlightStage>(HighlightStage::getName());
auto outlineStage = getStage<HighlightStage>();
if (outlineStage) {
for (auto& transaction : transactions) {
const auto& selectionName = std::get<0>(transaction);
@ -484,7 +484,7 @@ void Scene::resetHighlights(const Transaction::HighlightResets& transactions) {
}
void Scene::removeHighlights(const Transaction::HighlightRemoves& transactions) {
auto outlineStage = getStage<HighlightStage>(HighlightStage::getName());
auto outlineStage = getStage<HighlightStage>();
if (outlineStage) {
for (auto& selectionName : transactions) {
auto outlineId = outlineStage->getHighlightIdBySelection(selectionName);
@ -497,7 +497,7 @@ void Scene::removeHighlights(const Transaction::HighlightRemoves& transactions)
}
void Scene::queryHighlights(const Transaction::HighlightQueries& transactions) {
auto outlineStage = getStage<HighlightStage>(HighlightStage::getName());
auto outlineStage = getStage<HighlightStage>();
if (outlineStage) {
for (auto& transaction : transactions) {
const auto& selectionName = std::get<0>(transaction);
@ -551,7 +551,7 @@ void Scene::setItemTransition(ItemID itemId, Index transitionId) {
}
void Scene::removeItemTransition(ItemID itemId) {
auto transitionStage = getStage<TransitionStage>(TransitionStage::getName());
auto transitionStage = getStage<TransitionStage>();
if (!transitionStage) {
return;
}

2
libraries/task/src/task/Task.h
View file

@ -332,7 +332,7 @@ public:
void run(const ContextPointer& jobContext) override {
auto config = std::static_pointer_cast<C>(Concept::_config);
if (config->isEnabled()) {
for (auto job : TaskConcept::_jobs) {
for (auto& job : TaskConcept::_jobs) {
job.run(jobContext);
if (jobContext->taskFlow.doAbortTask()) {
jobContext->taskFlow.reset();

1
scripts/developer/utilities/lib/jet/jet.js
View file

@ -100,7 +100,6 @@ function job_print_functor(printout, showProps, showInOuts, maxDepth) {
}
}
if (showInOuts) {
printout("jsdkfkjdskflj")
var inouts = job_inoutKeys(job);
for (var p=0; p < inouts.length;p++) {
var prop = job[inouts[p]]