/
OpenGLRenderSystem.h
143 lines (102 loc) · 4.37 KB
/
OpenGLRenderSystem.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#pragma once
#include "irender.h"
#include <sigc++/connection.h>
#include <map>
#include "imodule.h"
#include "backend/OpenGLStateManager.h"
#include "backend/OpenGLShader.h"
#include "backend/OpenGLStateLess.h"
#include "backend/TextRenderer.h"
#include "backend/SceneRenderer.h"
#include "render/GeometryStore.h"
namespace render
{
class GLProgramFactory;
typedef std::shared_ptr<GLProgramFactory> GLProgramFactoryPtr;
/**
* \brief
* Implementation of RenderSystem.
*/
class OpenGLRenderSystem final
: public RenderSystem,
public OpenGLStateManager
{
// Map of named Shader objects
std::map<std::string, OpenGLShaderPtr> _shaders;
// The set of registered render entities
std::set<IRenderEntityPtr> _entities;
// The set of registered render lights
std::set<RendererLightPtr> _lights;
// whether this module has been realised
bool _realised;
bool _shaderProgramsAvailable;
// The GL program manager to acquire vfps
GLProgramFactoryPtr _glProgramFactory;
// Current shader program in use
ShaderProgram _currentShaderProgram;
// Map of OpenGLState references, with access functions.
OpenGLStates _state_sorted;
using FontKey = std::pair<IGLFont::Style, std::size_t>;
std::map<FontKey, std::shared_ptr<TextRenderer>> _textRenderers;
// Render time
std::size_t _time;
sigc::signal<void> _sigExtensionsInitialised;
sigc::connection _materialDefsLoaded;
sigc::connection _materialDefsUnloaded;
sigc::connection _sharedContextCreated;
sigc::connection _sharedContextDestroyed;
GeometryStore _geometryStore;
// Renderer implementations, one for each view type/purpose
std::unique_ptr<SceneRenderer> _orthoRenderer;
std::unique_ptr<SceneRenderer> _editorPreviewRenderer;
std::unique_ptr<SceneRenderer> _lightingModeRenderer;
public:
OpenGLRenderSystem();
~OpenGLRenderSystem();
/* RenderSystem implementation */
ITextRenderer::Ptr captureTextRenderer(IGLFont::Style style, std::size_t size) override;
ShaderPtr capture(const std::string& name) override;
ShaderPtr capture(BuiltInShaderType type) override;
ShaderPtr capture(ColourShaderType type, const Colour4& colour) override;
void startFrame() override;
void endFrame() override;
IRenderResult::Ptr renderFullBrightScene(RenderViewType renderViewType, RenderStateFlags globalstate, const IRenderView& view) override;
IRenderResult::Ptr renderLitScene(RenderStateFlags globalFlagsMask, const IRenderView& view) override;
void realise() override;
void unrealise() override;
GLProgramFactory& getGLProgramFactory();
std::size_t getTime() const override;
void setTime(std::size_t milliSeconds) override;
ShaderProgram getCurrentShaderProgram() const override;
void setShaderProgram(ShaderProgram prog) override;
void extensionsInitialised() override;
sigc::signal<void> signal_extensionsInitialised() override;
bool shaderProgramsAvailable() const override;
void setShaderProgramsAvailable(bool available) override;
typedef std::set<Renderable*> Renderables;
Renderables m_renderables;
mutable bool m_traverseRenderablesMutex;
void addEntity(const IRenderEntityPtr& renderEntity) override;
void removeEntity(const IRenderEntityPtr& renderEntity) override;
void foreachEntity(const std::function<void(const IRenderEntityPtr&)>& functor) override;
void foreachLight(const std::function<void(const RendererLightPtr&)>& functor) override;
/* OpenGLStateManager implementation */
void insertSortedState(const OpenGLStates::value_type& val) override;
void eraseSortedState(const OpenGLStates::key_type& key) override;
// renderables
void attachRenderable(Renderable& renderable) override;
void detachRenderable(Renderable& renderable) override;
void forEachRenderable(const RenderableCallback& callback) const override;
void setMergeModeEnabled(bool enabled) override;
// RegisterableModule implementation
const std::string& getName() const override;
const StringSet& getDependencies() const override;
void initialiseModule(const IApplicationContext& ctx) override;
void shutdownModule() override;
IGeometryStore& getGeometryStore();
private:
IRenderResult::Ptr render(SceneRenderer& renderer, RenderStateFlags globalFlagsMask, const IRenderView& view);
void renderText();
ShaderPtr capture(const std::string& name, const std::function<OpenGLShaderPtr()>& createShader);
};
} // namespace