Mirrors/overte-Armored-Dragon
3
0
Fork 0
mirror of https://github.com/Armored-Dragon/overte.git synced 2025-03-11 16:13:16 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add Job::Config to Draw

Browse source
This commit is contained in:
Zach Pomerantz 2016-01-22 15:17:05 -08:00
parent 9064438bf0
commit f1b7807db7
4 changed files with 56 additions and 101 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -103,7 +103,7 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
addJob<PrepareDeferred>("PrepareDeferred"); addJob<PrepareDeferred>("PrepareDeferred");
// Render opaque objects in DeferredBuffer // Render opaque objects in DeferredBuffer
addJob<DrawOpaqueDeferred>("DrawOpaqueDeferred", opaques, shapePlumber); addJob<DrawDeferred>("DrawOpaqueDeferred", opaques, shapePlumber);
// Once opaque is all rendered create stencil background // Once opaque is all rendered create stencil background
addJob<DrawStencilDeferred>("DrawOpaqueStencil"); addJob<DrawStencilDeferred>("DrawOpaqueStencil");
@ -127,9 +127,9 @@ RenderDeferredTask::RenderDeferredTask(CullFunctor cullFunctor) {
_antialiasingJobIndex = (int)_jobs.size() - 1; _antialiasingJobIndex = (int)_jobs.size() - 1;
enableJob(_antialiasingJobIndex, false); enableJob(_antialiasingJobIndex, false);
// Render transparent objects forward in LigthingBuffer // Render transparent objects forward in LightingBuffer
addJob<DrawTransparentDeferred>("DrawTransparentDeferred", transparents, shapePlumber); addJob<DrawDeferred>("DrawTransparentDeferred", transparents, shapePlumber);
// Lighting Buffer ready for tone mapping // Lighting Buffer ready for tone mapping
addJob<ToneMappingDeferred>("ToneMapping"); addJob<ToneMappingDeferred>("ToneMapping");
_toneMappingJobIndex = (int)_jobs.size() - 1; _toneMappingJobIndex = (int)_jobs.size() - 1;
@ -209,18 +209,19 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend
} }
}; };
void DrawOpaqueDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems) { void DrawDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems) {
assert(renderContext->getArgs()); assert(renderContext->getArgs());
assert(renderContext->getArgs()->_viewFrustum); assert(renderContext->getArgs()->_viewFrustum);
auto& config = std::static_pointer_cast<Config>(renderContext->jobConfig);
RenderArgs* args = renderContext->getArgs(); RenderArgs* args = renderContext->getArgs();
gpu::doInBatch(args->_context, [&](gpu::Batch& batch) { gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
batch.setViewportTransform(args->_viewport); batch.setViewportTransform(args->_viewport);
batch.setStateScissorRect(args->_viewport); batch.setStateScissorRect(args->_viewport);
args->_batch = &batch; args->_batch = &batch;
auto& opaque = renderContext->getItemsConfig().opaque; config->numDrawn = (int)inItems.size();
opaque.numDrawn = (int)inItems.size();
glm::mat4 projMat; glm::mat4 projMat;
Transform viewMat; Transform viewMat;
@ -230,33 +231,7 @@ void DrawOpaqueDeferred::run(const SceneContextPointer& sceneContext, const Rend
batch.setProjectionTransform(projMat); batch.setProjectionTransform(projMat);
batch.setViewTransform(viewMat); batch.setViewTransform(viewMat);
renderShapes(sceneContext, renderContext, _shapePlumber, inItems, opaque.maxDrawn); renderShapes(sceneContext, renderContext, _shapePlumber, inItems, config->maxDrawn);
args->_batch = nullptr;
});
}
void DrawTransparentDeferred::run(const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext, const ItemIDsBounds& inItems) {
assert(renderContext->getArgs());
assert(renderContext->getArgs()->_viewFrustum);
RenderArgs* args = renderContext->getArgs();
gpu::doInBatch(args->_context, [&](gpu::Batch& batch) {
batch.setViewportTransform(args->_viewport);
batch.setStateScissorRect(args->_viewport);
args->_batch = &batch;
auto& transparent = renderContext->getItemsConfig().transparent;
transparent.numDrawn = (int)inItems.size();
glm::mat4 projMat;
Transform viewMat;
args->_viewFrustum->evalProjectionMatrix(projMat);
args->_viewFrustum->evalViewTransform(viewMat);
batch.setProjectionTransform(projMat);
batch.setViewTransform(viewMat);
renderShapes(sceneContext, renderContext, _shapePlumber, inItems, transparent.maxDrawn);
args->_batch = nullptr; args->_batch = nullptr;
}); });
} }
@ -287,6 +262,7 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
auto& scene = sceneContext->_scene; auto& scene = sceneContext->_scene;
auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape().withLayered()); auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape().withLayered());
auto& config = std::static_pointer_cast<Config>(renderContext->jobConfig);
ItemIDsBounds inItems; ItemIDsBounds inItems;
inItems.reserve(items.size()); inItems.reserve(items.size());
@ -296,9 +272,8 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
inItems.emplace_back(id); inItems.emplace_back(id);
} }
} }
auto& overlay3D = renderContext->getItemsConfig().overlay3D; config->numItems = (int)inItems.size();
overlay3D.numFeed = (int)inItems.size(); config->numDrawn = (int)inItems.size();
overlay3D.numDrawn = (int)inItems.size();
if (!inItems.empty()) { if (!inItems.empty()) {
RenderArgs* args = renderContext->getArgs(); RenderArgs* args = renderContext->getArgs();
@ -330,7 +305,7 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
batch.setPipeline(getOpaquePipeline()); batch.setPipeline(getOpaquePipeline());
batch.setResourceTexture(0, args->_whiteTexture); batch.setResourceTexture(0, args->_whiteTexture);
renderShapes(sceneContext, renderContext, _shapePlumber, inItems, renderContext->getItemsConfig().overlay3D.maxDrawn); renderShapes(sceneContext, renderContext, _shapePlumber, inItems, config->maxDrawn);
}); });
args->_batch = nullptr; args->_batch = nullptr;
args->_whiteTexture.reset(); args->_whiteTexture.reset();

54
libraries/render-utils/src/RenderDeferredTask.h
View file

@ -64,26 +64,32 @@ public:
ToneMappingEffect _toneMappingEffect; ToneMappingEffect _toneMappingEffect;
}; };
class DrawOpaqueDeferred { class DrawConfig : public render::Job::Config {
Q_OBJECT
public: public:
DrawOpaqueDeferred(render::ShapePlumberPointer shapePlumber) : _shapePlumber{ shapePlumber } {} Q_PROPERTY(int numDrawn READ getNumDrawn)
void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const render::ItemIDsBounds& inItems); Q_PROPERTY(int maxDrawn MEMBER maxDrawn NOTIFY dirty)
int getNumDrawn() { return numDrawn; }
using JobModel = render::Job::ModelI<DrawOpaqueDeferred, render::ItemIDsBounds>; int numDrawn{ 0 };
int maxDrawn{ -1 };
protected: signals:
render::ShapePlumberPointer _shapePlumber; void dirty();
}; };
class DrawTransparentDeferred { class DrawDeferred {
public: public:
DrawTransparentDeferred(render::ShapePlumberPointer shapePlumber) : _shapePlumber{ shapePlumber } {} using Config = DrawConfig;
void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const render::ItemIDsBounds& inItems); using JobModel = render::Job::ModelI<DrawDeferred, render::ItemIDsBounds, Config>;
using JobModel = render::Job::ModelI<DrawTransparentDeferred, render::ItemIDsBounds>; DrawDeferred(render::ShapePlumberPointer shapePlumber) : _shapePlumber{ shapePlumber } {}
void configure(const Config& config) { _maxDrawn = config.maxDrawn; }
void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext, const render::ItemIDsBounds& inItems);
protected: protected:
render::ShapePlumberPointer _shapePlumber; render::ShapePlumberPointer _shapePlumber;
int _maxDrawn{ -1 };
}; };
class DrawStencilDeferred { class DrawStencilDeferred {
@ -105,18 +111,38 @@ public:
using JobModel = render::Job::Model<DrawBackgroundDeferred>; using JobModel = render::Job::Model<DrawBackgroundDeferred>;
}; };
class DrawOverlay3DConfig : public render::Job::Config {
Q_OBJECT
public:
Q_PROPERTY(int numItems READ getNumItems)
Q_PROPERTY(int numDrawn READ getNumDrawn)
Q_PROPERTY(int maxDrawn MEMBER maxDrawn NOTIFY dirty)
int getNumItems() { return numItems; }
int getNumDrawn() { return numDrawn; }
int numItems{ 0 };
int numDrawn{ 0 };
int maxDrawn{ -1 };
signals:
void dirty();
};
class DrawOverlay3D { class DrawOverlay3D {
public: public:
DrawOverlay3D(render::ShapePlumberPointer shapePlumber) : _shapePlumber{ shapePlumber } {} using Config = DrawOverlay3DConfig;
static const gpu::PipelinePointer& getOpaquePipeline(); using JobModel = render::Job::Model<DrawOverlay3D, Config>;
DrawOverlay3D(render::ShapePlumberPointer shapePlumber) : _shapePlumber{ shapePlumber } {}
void configure(const Config& config) { _maxDrawn = config.maxDrawn; }
void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext); void run(const render::SceneContextPointer& sceneContext, const render::RenderContextPointer& renderContext);
using JobModel = render::Job::Model<DrawOverlay3D>; static const gpu::PipelinePointer& getOpaquePipeline();
protected: protected:
static gpu::PipelinePointer _opaquePipeline; //lazy evaluation hence mutable static gpu::PipelinePointer _opaquePipeline; //lazy evaluation hence mutable
render::ShapePlumberPointer _shapePlumber; render::ShapePlumberPointer _shapePlumber;
int _maxDrawn{ -1 };
}; };
class Blit { class Blit {

4
libraries/render/src/render/Context.cpp
View file

@ -13,11 +13,11 @@
using namespace render; using namespace render;
RenderContext::RenderContext(ItemsConfig items, Tone tone, AmbientOcclusion ao, int drawStatus, bool drawHitEffect, glm::vec4 deferredDebugSize, int deferredDebugMode) RenderContext::RenderContext(AmbientOcclusion ao, int drawStatus, bool drawHitEffect, glm::vec4 deferredDebugSize, int deferredDebugMode)
: _deferredDebugMode{ deferredDebugMode }, _deferredDebugSize{ deferredDebugSize }, : _deferredDebugMode{ deferredDebugMode }, _deferredDebugSize{ deferredDebugSize },
_args{ nullptr }, _args{ nullptr },
_drawStatus{ drawStatus }, _drawHitEffect{ drawHitEffect }, _drawStatus{ drawStatus }, _drawHitEffect{ drawHitEffect },
_items{ items }, _tone{ tone }, _ambientOcclusion{ ao } {} _ambientOcclusion{ ao } {}
void RenderContext::setOptions(bool occlusion, bool fxaa, bool showOwned, bool shadowMap) { void RenderContext::setOptions(bool occlusion, bool fxaa, bool showOwned, bool shadowMap) {
_occlusionStatus = occlusion; _occlusionStatus = occlusion;

48
libraries/render/src/render/Context.h
View file

@ -32,48 +32,6 @@ class JobConfig;
class RenderContext { class RenderContext {
public: public:
class ItemsConfig {
public:
class Counter {
public:
Counter() {}
Counter(const Counter& counter) : maxDrawn { counter.maxDrawn } {}
void setCounts(const Counter& counter) {
numFeed = counter.numFeed;
numDrawn = counter.numDrawn;
};
int numFeed { 0 };
int numDrawn { 0 };
int maxDrawn { -1 };
};
class State : public Counter {
public:
bool render { true };
bool cull { true };
bool sort { true };
Counter counter{};
};
ItemsConfig(State opaqueState, State transparentState, Counter overlay3DCounter)
: opaque{ opaqueState }, transparent{ transparentState }, overlay3D{ overlay3DCounter } {}
ItemsConfig() : ItemsConfig{ {}, {}, {} } {}
// TODO: If member count increases, store counters in a map instead of multiple members
State opaque{};
State transparent{};
Counter overlay3D{};
};
class Tone {
public:
int toneCurve = 1; // Means just Gamma 2.2 correction
float exposure = 0.0;
};
class AmbientOcclusion { class AmbientOcclusion {
public: public:
int resolutionLevel { 1 }; int resolutionLevel { 1 };
@ -90,13 +48,11 @@ public:
double gpuTime { 0.0 }; double gpuTime { 0.0 };
}; };
RenderContext(ItemsConfig items, Tone tone, AmbientOcclusion ao, int drawStatus, bool drawHitEffect, glm::vec4 deferredDebugSize, int deferredDebugMode); RenderContext(AmbientOcclusion ao, int drawStatus, bool drawHitEffect, glm::vec4 deferredDebugSize, int deferredDebugMode);
RenderContext() {}; RenderContext() {};
void setArgs(RenderArgs* args) { _args = args; } void setArgs(RenderArgs* args) { _args = args; }
RenderArgs* getArgs() { return _args; } RenderArgs* getArgs() { return _args; }
ItemsConfig& getItemsConfig() { return _items; }
Tone& getTone() { return _tone; }
AmbientOcclusion& getAmbientOcclusion() { return _ambientOcclusion; } AmbientOcclusion& getAmbientOcclusion() { return _ambientOcclusion; }
int getDrawStatus() { return _drawStatus; } int getDrawStatus() { return _drawStatus; }
bool getDrawHitEffect() { return _drawHitEffect; } bool getDrawHitEffect() { return _drawHitEffect; }
@ -120,8 +76,6 @@ protected:
bool _fxaaStatus { false }; bool _fxaaStatus { false };
bool _shadowMapStatus { false }; bool _shadowMapStatus { false };
ItemsConfig _items;
Tone _tone;
AmbientOcclusion _ambientOcclusion; AmbientOcclusion _ambientOcclusion;
}; };
typedef std::shared_ptr<RenderContext> RenderContextPointer; typedef std::shared_ptr<RenderContext> RenderContextPointer;