OpenGLShaderCompileManager Class Template

Manager that consumes shader compile commands and performs OpenGL compilation/linking. More...

Declaration

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>> class helios::opengl::OpenGLShaderCompileManager<THandle, TUniformCacheStrategy> { ... }

Public Member Typedefs Index

template < ... >
using	EngineRoleTag = ManagerRole
	Engine role marker used by runtime registries. More...

Public Constructors Index

template < ... >
OpenGLShaderCompileManager (RenderResourceWorld &renderResourceWorld, TUniformCacheStrategy &&uniformCacheStrategy)
	Constructs the manager with access to render-resource world storage. More...

Public Member Functions Index

template < ... >
void	flush (UpdateContext &updateContext) noexcept
	Compiles all queued shaders and clears processed command data. More...
template < ... >
bool	submit (const ShaderBatchCompileCommand< THandle > &command) noexcept
template < ... >
bool	submit (const ShaderCompileCommand< THandle > &command) noexcept
template < ... >
void	init (helios::engine::runtime::messaging::command::CommandHandlerRegistry &commandHandlerRegistry) noexcept
	Registers compile command handlers in the runtime world. More...

Private Member Functions Index

template < ... >
bool	load (const std::string &vertexShaderPath, const std::string &fragmentShaderPath, std::string &vertexShaderSource, std::string &fragmentShaderSource) noexcept
	Loads the specified vertex and fragment shader. More...
template < ... >
bool	compile (ShaderEntity shader) noexcept
	Compiles the vertex and fragment shader represented by this instance. More...

Private Member Attributes Index

template < ... >
BasicStringFileReader	stringFileReader_
template < ... >
RenderResourceWorld &	renderResourceWorld_
template < ... >
std::vector< ShaderHandle >	shaderHandles_
template < ... >
std::string	vertexShaderSource_
template < ... >
std::string	fragmentShaderSource_
template < ... >
TUniformCacheStrategy	uniformCacheStrategy_

Private Static Attributes Index

template < ... >
static const Logger &	logger_ = LogManager::loggerForScope(HELIOS_LOG_SCOPE)

Description

Manager that consumes shader compile commands and performs OpenGL compilation/linking.

Template Parameters

THandle	Shader handle type.
TCommandBuffer	Command buffer type for optional follow-up commands.

Definition at line 64 of file OpenGLShaderCompileManager.ixx.

Public Member Typedefs

EngineRoleTag

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

using helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::EngineRoleTag = ManagerRole

Engine role marker used by runtime registries.

Definition at line 212 of file OpenGLShaderCompileManager.ixx.

212 using EngineRoleTag = ManagerRole;

Public Constructors

OpenGLShaderCompileManager()

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::OpenGLShaderCompileManager (RenderResourceWorld & renderResourceWorld, TUniformCacheStrategy && uniformCacheStrategy)

inline explicit

Constructs the manager with access to render-resource world storage.

Parameters

renderResourceWorld

Render-resource world used to resolve shader entities.

Definition at line 200 of file OpenGLShaderCompileManager.ixx.

200 explicit OpenGLShaderCompileManager(

201 RenderResourceWorld& renderResourceWorld,

202 TUniformCacheStrategy&& uniformCacheStrategy

203 )

204 :

205 renderResourceWorld_(renderResourceWorld),

206 uniformCacheStrategy_(std::move(uniformCacheStrategy))

207 { }

Public Member Functions

flush()

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

void helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::flush (UpdateContext & updateContext)

inline noexcept

Compiles all queued shaders and clears processed command data.

Parameters

updateContext

Frame-local update context.

Definition at line 220 of file OpenGLShaderCompileManager.ixx.

220 void flush(UpdateContext& updateContext) noexcept {

221

222 if (shaderHandles_.empty()) {

223 return;

224 }

225

226 for (const auto& sourceHandle : shaderHandles_) {

227 auto shaderEntity = renderResourceWorld_.findEntity<THandle>(sourceHandle);

228

229 if (!shaderEntity) {

230 logger_.error("Could not find shader source");

231 assert(false && "Could not find shader source");

232 continue;

233 }

234

235 if (!compile(*shaderEntity)) {

236 logger_.error("Could not compile shader");

237 } else {

238 shaderEntity->template remove<ShaderSourceComponent<THandle>>();

239 uniformCacheStrategy_.template cacheUniforms<UniformScope::Pass>(shaderEntity->handle(), renderResourceWorld_, updateContext);

240 uniformCacheStrategy_.template cacheUniforms<UniformScope::Draw>(shaderEntity->handle(), renderResourceWorld_, updateContext);

241 }

242 }

243

244 shaderHandles_.clear();

245 }

init()

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

void helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::init (helios::engine::runtime::messaging::command::CommandHandlerRegistry & commandHandlerRegistry)

inline noexcept

Registers compile command handlers in the runtime world.

Parameters

commandHandlerRegistry

Registry used for command-handler registration.

Definition at line 264 of file OpenGLShaderCompileManager.ixx.

264 void init(helios::engine::runtime::messaging::command::CommandHandlerRegistry& commandHandlerRegistry) noexcept {

265 commandHandlerRegistry.registerHandler<ShaderCompileCommand<THandle>>(*this);

266 commandHandlerRegistry.registerHandler<ShaderBatchCompileCommand<THandle>>(*this);

267 }

submit()

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

bool helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::submit (const ShaderBatchCompileCommand< THandle > & command)

inline noexcept

Definition at line 247 of file OpenGLShaderCompileManager.ixx.

247 bool submit(const ShaderBatchCompileCommand<THandle>& command) noexcept {

248 for (const auto& shaderHandle : command.shaderHandles) {

249 shaderHandles_.push_back(shaderHandle);

250 }

251 return true;

252 }

submit()

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

bool helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::submit (const ShaderCompileCommand< THandle > & command)

inline noexcept

Definition at line 254 of file OpenGLShaderCompileManager.ixx.

254 bool submit(const ShaderCompileCommand<THandle>& command) noexcept {

255 shaderHandles_.push_back(command.shaderHandle);

256 return true;

257 }

Private Member Functions

compile()

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

bool helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::compile (ShaderEntity shader)

inline noexcept

Compiles the vertex and fragment shader represented by this instance.

Returns

true if compilation succeeded, otherwise false.

Exceptions

if	compilation failed.

Definition at line 111 of file OpenGLShaderCompileManager.ixx.

111 bool compile(ShaderEntity shader) noexcept {

112

113 using Handle = typename ShaderEntity::Handle_type;

114

115 logger_.info("Compiling shader...");

116

117 if (shader.template get<OpenGLShaderComponent<Handle>>()) {

118 logger_.error("Shader already has a ShaderComponent");

119 assert(false && "Shader already has a ShaderComponent");

120 return false;

121 }

122

123 auto* shaderSourceComponent = shader.template get<ShaderSourceComponent<Handle>>();

124

125

126 const bool loaded = load(

127 shaderSourceComponent->vertexShaderPath,

128 shaderSourceComponent->fragmentShaderPath,

129 vertexShaderSource_, fragmentShaderSource_);

130

131 if (!loaded) {

132 logger_.error("Could not load shader files");

133 assert(false && "Could not load shader files");

134 return false;

135 }

136

137 const GLchar* vertexSrc = vertexShaderSource_.c_str();

138 const GLchar* fragmentSrc = fragmentShaderSource_.c_str();

139

140 const unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);

141 glShaderSource(vertexShader, 1, &vertexSrc, nullptr);

142 glCompileShader(vertexShader);

143

144 const unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

145 glShaderSource(fragmentShader, 1, &fragmentSrc, nullptr);

146 glCompileShader(fragmentShader);

147

148 int success;

149 char infoLog[512];

150

151 glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);

152 if (!success) {

153 glGetShaderInfoLog(vertexShader, 512, nullptr, infoLog);

154 logger_.error("Vertex Shader Compilation failed.");

155 assert(false && "Vertex Shader Compilation failed.");

156 return false;

157 }

158

159 glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);

160 if (!success) {

161 glGetShaderInfoLog(fragmentShader, 512, nullptr, infoLog);

162 logger_.error("Fragment Shader Compilation failed.");

163 assert(false && "Fragment Shader Compilation failed.");

164 return false;

165 }

166

167 auto progId = glCreateProgram();

168

169 glAttachShader(progId, vertexShader);

170 glAttachShader(progId, fragmentShader);

171 glLinkProgram(progId);

172

173 glGetProgramiv(progId, GL_LINK_STATUS, &success);

174 if (!success) {

175 glGetProgramInfoLog(progId, 512, nullptr, infoLog);

176 logger_.error("Program linking failed.");

177 assert(false && "Program linking failed.");

178 return false;

179 }

180

181 auto& shaderComponent = shader.add<OpenGLShaderComponent<THandle>>();

182 shaderComponent.programId = progId;

183

184 glDeleteShader(vertexShader);

185 glDeleteShader(fragmentShader);

186

187 vertexShaderSource_.clear();

188 fragmentShaderSource_.clear();

189

190 return true;

191 }

load()

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

bool helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::load (const std::string & vertexShaderPath, const std::string & fragmentShaderPath, std::string & vertexShaderSource, std::string & fragmentShaderSource)

inline noexcept

Loads the specified vertex and fragment shader.

Returns

true if loading succeeded, otherwise false.

Exceptions

if	loading the specified files failed.

Definition at line 88 of file OpenGLShaderCompileManager.ixx.

88 bool load(

89 const std::string& vertexShaderPath,

90 const std::string& fragmentShaderPath,

91 std::string& vertexShaderSource,

92 std::string& fragmentShaderSource

93 ) noexcept {

94

95 const bool frag = stringFileReader_.readInto(fragmentShaderPath, fragmentShaderSource);

96 const bool vert = stringFileReader_.readInto(vertexShaderPath, vertexShaderSource);

97

98 assert(frag && vert && "Could not load shader files");

99

100 return frag && vert;

101 }

Private Member Attributes

fragmentShaderSource_

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

std::string helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::fragmentShaderSource_

Definition at line 74 of file OpenGLShaderCompileManager.ixx.

74 std::string fragmentShaderSource_;

renderResourceWorld_

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

RenderResourceWorld& helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::renderResourceWorld_

Definition at line 68 of file OpenGLShaderCompileManager.ixx.

68 RenderResourceWorld& renderResourceWorld_;

shaderHandles_

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

std::vector<ShaderHandle> helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::shaderHandles_

Definition at line 70 of file OpenGLShaderCompileManager.ixx.

70 std::vector<ShaderHandle> shaderHandles_;

stringFileReader_

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

BasicStringFileReader helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::stringFileReader_

Definition at line 66 of file OpenGLShaderCompileManager.ixx.

66 BasicStringFileReader stringFileReader_;

uniformCacheStrategy_

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

TUniformCacheStrategy helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::uniformCacheStrategy_

Definition at line 79 of file OpenGLShaderCompileManager.ixx.

79 TUniformCacheStrategy uniformCacheStrategy_;

vertexShaderSource_

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

std::string helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::vertexShaderSource_

Definition at line 72 of file OpenGLShaderCompileManager.ixx.

72 std::string vertexShaderSource_;

Private Static Attributes

logger_

template <typename THandle, typename TUniformCacheStrategy = NullUniformCacheStrategy<THandle>>

const Logger& helios::opengl::OpenGLShaderCompileManager< THandle, TUniformCacheStrategy >::logger_ = LogManager::loggerForScope(HELIOS_LOG_SCOPE)

static

Definition at line 77 of file OpenGLShaderCompileManager.ixx.

77 inline static const Logger& logger_ = LogManager::loggerForScope(HELIOS_LOG_SCOPE);

---

The documentation for this class was generated from the following file:

• OpenGLShaderCompileManager.ixx

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.