Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-04-22 16:13:28 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Replace RenderContext substructs with subclasses

Browse source
This commit is contained in:
Zach Pomerantz 2015-12-18 12:04:21 -08:00
parent d057239023
commit 674bfa4f37
4 changed files with 77 additions and 73 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -53,8 +53,8 @@ RenderDeferredTask::RenderDeferredTask() : Task() {
// CPU only, create the list of renderedOpaques items
_jobs.push_back(Job(new FetchItems::JobModel("FetchOpaque",
FetchItems([](const RenderContextPointer& context, int count) {
context->getItemsConfig()._opaque._numFeed = count;
auto& opaque = context->getItemsConfig()._opaque;
context->getItemsConfig().opaque.numFeed = count;
auto& opaque = context->getItemsConfig().opaque;
})
)));
_jobs.push_back(Job(new CullItemsOpaque::JobModel("CullOpaque", _jobs.back().getOutput())));
@ -65,7 +65,7 @@ RenderDeferredTask::RenderDeferredTask() : Task() {
_jobs.push_back(Job(new FetchItems::JobModel("FetchTransparent",
FetchItems(ItemFilter::Builder::transparentShape().withoutLayered(),
[](const RenderContextPointer& context, int count) {
context->getItemsConfig()._transparent._numFeed = count;
context->getItemsConfig().transparent.numFeed = count;
})
)));
_jobs.push_back(Job(new CullItemsTransparent::JobModel("CullTransparent", _jobs.back().getOutput())));
@ -166,8 +166,8 @@ void RenderDeferredTask::run(const SceneContextPointer& sceneContext, const Rend
setAntialiasingStatus(renderContext->getFxaaStatus());
setToneMappingExposure(renderContext->getTone()._exposure);
setToneMappingToneCurve(renderContext->getTone()._toneCurve);
setToneMappingExposure(renderContext->getTone().exposure);
setToneMappingToneCurve(renderContext->getTone().toneCurve);
renderContext->getArgs()->_context->syncCache();
@ -187,8 +187,8 @@ void DrawOpaqueDeferred::run(const SceneContextPointer& sceneContext, const Rend
batch.setStateScissorRect(args->_viewport);
args->_batch = &batch;
auto& opaque = renderContext->getItemsConfig()._opaque;
opaque._numDrawn = (int)inItems.size();
auto& opaque = renderContext->getItemsConfig().opaque;
opaque.numDrawn = (int)inItems.size();
glm::mat4 projMat;
Transform viewMat;
@ -202,7 +202,7 @@ void DrawOpaqueDeferred::run(const SceneContextPointer& sceneContext, const Rend
const float OPAQUE_ALPHA_THRESHOLD = 0.5f;
args->_alphaThreshold = OPAQUE_ALPHA_THRESHOLD;
}
renderItems(sceneContext, renderContext, inItems, opaque._maxDrawn);
renderItems(sceneContext, renderContext, inItems, opaque.maxDrawn);
args->_batch = nullptr;
});
}
@ -217,8 +217,8 @@ void DrawTransparentDeferred::run(const SceneContextPointer& sceneContext, const
batch.setStateScissorRect(args->_viewport);
args->_batch = &batch;
auto& transparent = renderContext->getItemsConfig()._transparent;
transparent._numDrawn = (int)inItems.size();
auto& transparent = renderContext->getItemsConfig().transparent;
transparent.numDrawn = (int)inItems.size();
glm::mat4 projMat;
Transform viewMat;
@ -231,7 +231,7 @@ void DrawTransparentDeferred::run(const SceneContextPointer& sceneContext, const
const float TRANSPARENT_ALPHA_THRESHOLD = 0.0f;
args->_alphaThreshold = TRANSPARENT_ALPHA_THRESHOLD;
renderItems(sceneContext, renderContext, inItems, transparent._maxDrawn);
renderItems(sceneContext, renderContext, inItems, transparent.maxDrawn);
args->_batch = nullptr;
});
}
@ -270,9 +270,9 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
inItems.emplace_back(id);
}
}
auto& overlay3D = renderContext->getItemsConfig()._overlay3D;
overlay3D._numFeed = (int)inItems.size();
overlay3D._numDrawn = (int)inItems.size();
auto& overlay3D = renderContext->getItemsConfig().overlay3D;
overlay3D.numFeed = (int)inItems.size();
overlay3D.numDrawn = (int)inItems.size();
if (!inItems.empty()) {
RenderArgs* args = renderContext->getArgs();
@ -304,7 +304,7 @@ void DrawOverlay3D::run(const SceneContextPointer& sceneContext, const RenderCon
batch.setPipeline(getOpaquePipeline());
batch.setResourceTexture(0, args->_whiteTexture);
renderItems(sceneContext, renderContext, inItems, renderContext->getItemsConfig()._overlay3D._maxDrawn);
renderItems(sceneContext, renderContext, inItems, renderContext->getItemsConfig().overlay3D.maxDrawn);
});
args->_batch = nullptr;
args->_whiteTexture.reset();

10
libraries/render-utils/src/RenderScriptingInterface.cpp
View file

@ -15,18 +15,18 @@ RenderScriptingInterface::RenderScriptingInterface() {};
void RenderScriptingInterface::setEngineToneMappingToneCurve(const QString& toneCurve) {
if (toneCurve == QString("None")) {
_tone._toneCurve = 0;
_tone.toneCurve = 0;
} else if (toneCurve == QString("Gamma22")) {
_tone._toneCurve = 1;
_tone.toneCurve = 1;
} else if (toneCurve == QString("Reinhard")) {
_tone._toneCurve = 2;
_tone.toneCurve = 2;
} else if (toneCurve == QString("Filmic")) {
_tone._toneCurve = 3;
_tone.toneCurve = 3;
}
}
QString RenderScriptingInterface::getEngineToneMappingToneCurve() const {
switch (_tone._toneCurve) {
switch (_tone.toneCurve) {
case 0:
return QString("None");
case 1:

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

@ -22,35 +22,35 @@ class RenderScriptingInterface : public QObject, public Dependency {
SINGLETON_DEPENDENCY
public:
Q_INVOKABLE void setEngineRenderOpaque(bool renderOpaque) { _items._opaque._render = renderOpaque; };
Q_INVOKABLE bool doEngineRenderOpaque() const { return _items._opaque._render; }
Q_INVOKABLE void setEngineRenderTransparent(bool renderTransparent) { _items._transparent._render = renderTransparent; };
Q_INVOKABLE bool doEngineRenderTransparent() const { return _items._transparent._render; }
Q_INVOKABLE void setEngineRenderOpaque(bool renderOpaque) { _items.opaque.render = renderOpaque; };
Q_INVOKABLE bool doEngineRenderOpaque() const { return _items.opaque.render; }
Q_INVOKABLE void setEngineRenderTransparent(bool renderTransparent) { _items.transparent.render = renderTransparent; };
Q_INVOKABLE bool doEngineRenderTransparent() const { return _items.transparent.render; }
Q_INVOKABLE void setEngineCullOpaque(bool cullOpaque) { _items._opaque._cull = cullOpaque; };
Q_INVOKABLE bool doEngineCullOpaque() const { return _items._opaque._cull; }
Q_INVOKABLE void setEngineCullTransparent(bool cullTransparent) { _items._transparent._cull = cullTransparent; };
Q_INVOKABLE bool doEngineCullTransparent() const { return _items._transparent._cull; }
Q_INVOKABLE void setEngineCullOpaque(bool cullOpaque) { _items.opaque.cull = cullOpaque; };
Q_INVOKABLE bool doEngineCullOpaque() const { return _items.opaque.cull; }
Q_INVOKABLE void setEngineCullTransparent(bool cullTransparent) { _items.transparent.cull = cullTransparent; };
Q_INVOKABLE bool doEngineCullTransparent() const { return _items.transparent.cull; }
Q_INVOKABLE void setEngineSortOpaque(bool sortOpaque) { _items._opaque._sort = sortOpaque; };
Q_INVOKABLE bool doEngineSortOpaque() const { return _items._opaque._sort; }
Q_INVOKABLE void setEngineSortTransparent(bool sortTransparent) { _items._transparent._sort = sortTransparent; };
Q_INVOKABLE bool doEngineSortTransparent() const { return _items._transparent._sort; }
Q_INVOKABLE void setEngineSortOpaque(bool sortOpaque) { _items.opaque.sort = sortOpaque; };
Q_INVOKABLE bool doEngineSortOpaque() const { return _items.opaque.sort; }
Q_INVOKABLE void setEngineSortTransparent(bool sortTransparent) { _items.transparent.sort = sortTransparent; };
Q_INVOKABLE bool doEngineSortTransparent() const { return _items.transparent.sort; }
Q_INVOKABLE int getEngineNumDrawnOpaqueItems() { return _items._opaque._numDrawn; }
Q_INVOKABLE int getEngineNumDrawnTransparentItems() { return _items._transparent._numDrawn; }
Q_INVOKABLE int getEngineNumDrawnOverlay3DItems() { return _items._overlay3D._numDrawn; }
Q_INVOKABLE int getEngineNumDrawnOpaqueItems() { return _items.opaque.numDrawn; }
Q_INVOKABLE int getEngineNumDrawnTransparentItems() { return _items.transparent.numDrawn; }
Q_INVOKABLE int getEngineNumDrawnOverlay3DItems() { return _items.overlay3D.numDrawn; }
Q_INVOKABLE int getEngineNumFeedOpaqueItems() { return _items._opaque._numFeed; }
Q_INVOKABLE int getEngineNumFeedTransparentItems() { return _items._transparent._numFeed; }
Q_INVOKABLE int getEngineNumFeedOverlay3DItems() { return _items._overlay3D._numFeed; }
Q_INVOKABLE int getEngineNumFeedOpaqueItems() { return _items.opaque.numFeed; }
Q_INVOKABLE int getEngineNumFeedTransparentItems() { return _items.transparent.numFeed; }
Q_INVOKABLE int getEngineNumFeedOverlay3DItems() { return _items.overlay3D.numFeed; }
Q_INVOKABLE void setEngineMaxDrawnOpaqueItems(int count) { _items._opaque._maxDrawn = count; }
Q_INVOKABLE int getEngineMaxDrawnOpaqueItems() { return _items._opaque._maxDrawn; }
Q_INVOKABLE void setEngineMaxDrawnTransparentItems(int count) { _items._transparent._maxDrawn = count; }
Q_INVOKABLE int getEngineMaxDrawnTransparentItems() { return _items._transparent._maxDrawn; }
Q_INVOKABLE void setEngineMaxDrawnOverlay3DItems(int count) { _items._overlay3D._maxDrawn = count; }
Q_INVOKABLE int getEngineMaxDrawnOverlay3DItems() { return _items._overlay3D._maxDrawn; }
Q_INVOKABLE void setEngineMaxDrawnOpaqueItems(int count) { _items.opaque.maxDrawn = count; }
Q_INVOKABLE int getEngineMaxDrawnOpaqueItems() { return _items.opaque.maxDrawn; }
Q_INVOKABLE void setEngineMaxDrawnTransparentItems(int count) { _items.transparent.maxDrawn = count; }
Q_INVOKABLE int getEngineMaxDrawnTransparentItems() { return _items.transparent.maxDrawn; }
Q_INVOKABLE void setEngineMaxDrawnOverlay3DItems(int count) { _items.overlay3D.maxDrawn = count; }
Q_INVOKABLE int getEngineMaxDrawnOverlay3DItems() { return _items.overlay3D.maxDrawn; }
Q_INVOKABLE void setEngineDeferredDebugMode(int mode) { _deferredDebugMode = mode; }
Q_INVOKABLE int getEngineDeferredDebugMode() { return _deferredDebugMode; }
@ -63,12 +63,12 @@ class RenderScriptingInterface : public QObject, public Dependency {
Q_INVOKABLE void setEngineDisplayHitEffect(bool display) { _drawHitEffect = display; }
Q_INVOKABLE bool doEngineDisplayHitEffect() { return _drawHitEffect; }
Q_INVOKABLE void setEngineToneMappingExposure(float exposure) { _tone._exposure = exposure; }
Q_INVOKABLE float getEngineToneMappingExposure() const { return _tone._exposure; }
Q_INVOKABLE void setEngineToneMappingExposure(float exposure) { _tone.exposure = exposure; }
Q_INVOKABLE float getEngineToneMappingExposure() const { return _tone.exposure; }
Q_INVOKABLE void setEngineToneMappingToneCurve(const QString& curve);
Q_INVOKABLE QString getEngineToneMappingToneCurve() const;
int getEngineToneMappingToneCurveValue() const { return _tone._toneCurve; }
int getEngineToneMappingToneCurveValue() const { return _tone.toneCurve; }
inline int getDrawStatus() { return _drawStatus; }
inline bool getDrawHitEffect() { return _drawHitEffect; }

56
libraries/render/src/render/Engine.h
View file

@ -32,59 +32,63 @@ const int showNetworkStatusFlag = 2;
class RenderContext {
public:
struct ItemsConfig {
class ItemsConfig {
public:
inline void setCounts(const ItemsConfig& items) {
_opaque.setCounts(items._opaque);
_transparent.setCounts(items._transparent);
_overlay3D.setCounts(items._overlay3D);
opaque.setCounts(items.opaque);
transparent.setCounts(items.transparent);
overlay3D.setCounts(items.overlay3D);
};
struct Counter {
class Counter {
public:
Counter() {};
Counter(const Counter& counter) {
_numFeed = _numDrawn = 0;
_maxDrawn = counter._maxDrawn;
numFeed = numDrawn = 0;
maxDrawn = counter.maxDrawn;
};
inline void setCounts(const Counter& counter) {
_numFeed = counter._numFeed;
_numDrawn = counter._numDrawn;
numFeed = counter.numFeed;
numDrawn = counter.numDrawn;
};
int _numFeed = 0;
int _numDrawn = 0;
int _maxDrawn = -1;
int numFeed = 0;
int numDrawn = 0;
int maxDrawn = -1;
};
struct State : public Counter {
bool _render = true;
bool _cull = true;
bool _sort = true;
class State : public Counter {
public:
bool render = true;
bool cull = true;
bool sort = true;
Counter _counter{};
Counter counter{};
};
// TODO: Store state/counter in a map instead of manually enumerated members
State _opaque{};
State _transparent{};
Counter _overlay3D{};
// TODO: If member count increases, store counters in a map instead of multiple members
State opaque{};
State transparent{};
Counter overlay3D{};
};
struct Tone {
int _toneCurve = 3;
float _exposure = 0.0;
class Tone {
public:
int toneCurve = 3;
float exposure = 0.0;
};
RenderContext(RenderArgs* args, ItemsConfig items, Tone tone) : _args{args}, _items{items}, _tone{tone} {};
RenderContext() : RenderContext(nullptr, {}, {}) {};
inline RenderArgs* getArgs() { return _args; }
inline ItemsConfig& getItemsConfig() { return _items; }
inline Tone& getTone() { return _tone; }
inline int getDrawStatus() { return _drawStatus; }
inline bool getDrawHitEffect() { return _drawHitEffect; }
inline bool getOcclusionStatus() { return _occlusionStatus; }
inline bool getFxaaStatus() { return _fxaaStatus; }
inline ItemsConfig& getItemsConfig() { return _items; }
inline Tone& getTone() { return _tone; }
void setOptions(int drawStatus, bool drawHitEffect, bool occlusion, bool fxaa, bool showOwned);
// Debugging