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
144
145
146
147
148
149
150
151
|
#pragma once
#ifndef DOXYGEN_GENERATING_OUTPUT
#define NCINE_INCLUDE_OPENGL
#include "../CommonHeaders.h"
#endif
#include "Material.h"
#include "../Primitives/Matrix4x4.h"
#include "GL/GLShaderUniforms.h"
#include "GL/GLShaderProgram.h"
#include "../Base/HashMap.h"
#include <memory>
namespace nCine
{
class BinaryShaderCache;
class RenderBuffersManager;
class RenderVaoPool;
class RenderCommandPool;
class RenderBatcher;
class Camera;
class Viewport;
/// Creates and handles application common OpenGL rendering resources
class RenderResources
{
/// The `Application` class needs to create and dispose the resources
friend class Application;
/// The `Viewport` class needs to set the current camera
friend class Viewport;
/// The `ScreenViewport` class needs to change the projection of the default camera
friend class ScreenViewport;
public:
RenderResources() = delete;
~RenderResources() = delete;
/// Vertex format structure for vertices with positions only
struct VertexFormatPos2
{
GLfloat position[2];
};
/// Vertex format structure for vertices with positions and texture coordinates
struct VertexFormatPos2Tex2
{
GLfloat position[2];
GLfloat texcoords[2];
};
/// Vertex format structure for vertices with positions and draw indices
struct VertexFormatPos2Index
{
GLfloat position[2];
std::int32_t drawindex;
};
/// Vertex format structure for vertices with positions, texture coordinates and draw indices
struct VertexFormatPos2Tex2Index
{
GLfloat position[2];
GLfloat texcoords[2];
std::int32_t drawindex;
};
/// Camera uniform data structure
struct CameraUniformData
{
CameraUniformData()
: camera(nullptr), updateFrameProjectionMatrix(0), updateFrameViewMatrix(0) {}
GLShaderUniforms shaderUniforms;
Camera* camera;
std::uint32_t updateFrameProjectionMatrix;
std::uint32_t updateFrameViewMatrix;
};
static inline BinaryShaderCache& GetBinaryShaderCache() {
return *binaryShaderCache_;
}
static inline RenderBuffersManager& GetBuffersManager() {
return *buffersManager_;
}
static inline RenderVaoPool& GetVaoPool() {
return *vaoPool_;
}
static inline RenderCommandPool& GetRenderCommandPool() {
return *renderCommandPool_;
}
static inline RenderBatcher& GetRenderBatcher() {
return *renderBatcher_;
}
static GLShaderProgram* GetShaderProgram(Material::ShaderProgramType shaderProgramType);
static GLShaderProgram* GetBatchedShader(const GLShaderProgram* shader);
static bool RegisterBatchedShader(const GLShaderProgram* shader, GLShaderProgram* batchedShader);
static bool UnregisterBatchedShader(const GLShaderProgram* shader);
static inline std::uint8_t* GetCameraUniformsBuffer() {
return cameraUniformsBuffer_;
}
static CameraUniformData* FindCameraUniformData(GLShaderProgram* shaderProgram);
static void InsertCameraUniformData(GLShaderProgram* shaderProgram, CameraUniformData&& cameraUniformData);
static bool RemoveCameraUniformData(GLShaderProgram* shaderProgram);
static inline const Camera* GetCurrentCamera() {
return currentCamera_;
}
static inline const Viewport* GetCurrentViewport() {
return currentViewport_;
}
static void SetDefaultAttributesParameters(GLShaderProgram& shaderProgram);
private:
#if defined(WITH_EMBEDDED_SHADERS)
static constexpr std::uint64_t EmbeddedShadersVersion = 2ull | (1ull << 63);
#endif
static std::unique_ptr<BinaryShaderCache> binaryShaderCache_;
static std::unique_ptr<RenderBuffersManager> buffersManager_;
static std::unique_ptr<RenderVaoPool> vaoPool_;
static std::unique_ptr<RenderCommandPool> renderCommandPool_;
static std::unique_ptr<RenderBatcher> renderBatcher_;
static constexpr std::uint32_t DefaultShaderProgramsCount = std::uint32_t(Material::ShaderProgramType::Custom);
static std::unique_ptr<GLShaderProgram> defaultShaderPrograms_[DefaultShaderProgramsCount];
static HashMap<const GLShaderProgram*, GLShaderProgram*> batchedShaders_;
static constexpr std::uint32_t UniformsBufferSize = 128; // two 4x4 float matrices
static std::uint8_t cameraUniformsBuffer_[UniformsBufferSize];
static HashMap<GLShaderProgram*, CameraUniformData> cameraUniformDataMap_;
static Camera* currentCamera_;
static std::unique_ptr<Camera> defaultCamera_;
static Viewport* currentViewport_;
static void SetCurrentCamera(Camera* camera);
static void UpdateCameraUniforms();
static void SetCurrentViewport(Viewport* viewport);
static void CreateMinimal();
static void Create();
static void Dispose();
static void RegisterDefaultBatchedShaders();
};
}
|
