RenderManager Class Template

Collects render commands into hierarchical batches and forwards them to the backend. More...

Declaration

template <typename TRenderBackend, typename TMemberHandle> class helios::engine::rendering::RenderManager<TRenderBackend, TMemberHandle> { ... }

Public Member Typedefs Index

template <typename TRenderBackend, typename TMemberHandle>
using	EngineRoleTag = ManagerRole
	Runtime role tag used for engine manager registration. More...

Public Constructors Index

template <typename TRenderBackend, typename TMemberHandle>
RenderManager (TRenderBackend &renderBackend)
	Constructs the manager for a specific render backend. More...

Public Member Functions Index

template <typename TRenderBackend, typename TMemberHandle>
void	flush (UpdateContext &updateContext)
	Flushes all active render-target batches to the backend. More...
template <typename TRenderBackend, typename TMemberHandle>
bool	submit (RenderSceneCommand< TMemberHandle > renderSceneCommand) noexcept
	Queues one scene render context into the batch structure. More...
template <typename TRenderBackend, typename TMemberHandle>
bool	submit (RenderSceneMemberCommand< TMemberHandle > renderCommand) noexcept
	Queues one draw context into the hierarchical batch structure. More...
template <typename TRenderBackend, typename TMemberHandle>
void	init (CommandHandlerRegistry &commandHandlerRegistry) noexcept
	Registers this manager as handler for render commands. More...

Private Member Functions Index

template <typename TRenderBackend, typename TMemberHandle>
auto	ensureViewportBatch (RenderTargetHandle renderTargetHandle, ViewportHandle viewportHandle) -> ViewportBatch< TMemberHandle > &
	makes sure a ViewportBatch is available for the specified RenderTargetHandle and ViewportHandle. More...

Private Member Attributes Index

template <typename TRenderBackend, typename TMemberHandle>
std::vector< RenderTargetBatch< TMemberHandle > >	renderTargetBatches_
template <typename TRenderBackend, typename TMemberHandle>
std::vector< EntityId >	activeRenderTargetIndices_
template <typename TRenderBackend, typename TMemberHandle>
TRenderBackend &	renderBackend_

Private Static Functions Index

template <typename TBatch, typename TChildHandle>
static void	clearActive (TBatch *batch, std::vector< EntityId > &activeIndices, std::vector< TChildHandle > &batches)
	Clears active child batches and resets the parent batch active flag. More...
template <typename THandle, typename TChildBatch>
static TChildBatch &	addToBatch (const THandle handle, std::vector< TChildBatch > &batches, std::vector< EntityId > &activeIndices)
	Returns the existing child batch for a handle or activates a new one. More...

Private Static Attributes Index

template <typename TRenderBackend, typename TMemberHandle>
static auto &	logger_ = LogManager::loggerForScope(HELIOS_LOG_SCOPE)

Description

Collects render commands into hierarchical batches and forwards them to the backend.

Commands are grouped by render-target, viewport, shader, material, and mesh. flush(...) iterates this hierarchy and calls the corresponding backend batch hooks.

Template Parameters

TRenderBackend	Rendering backend type.
TMemberHandle	Renderable scene member handle type.

Definition at line 77 of file RenderManager.ixx.

Public Member Typedefs

EngineRoleTag

template <typename TRenderBackend, typename TMemberHandle>

using helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::EngineRoleTag = ManagerRole

Runtime role tag used for engine manager registration.

Definition at line 262 of file RenderManager.ixx.

262 using EngineRoleTag = ManagerRole;

Public Constructors

RenderManager()

template <typename TRenderBackend, typename TMemberHandle>

helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::RenderManager (TRenderBackend & renderBackend)

inline explicit

Constructs the manager for a specific render backend.

Parameters

renderBackend

Backend used to execute render passes.

Definition at line 269 of file RenderManager.ixx.

269 explicit RenderManager(TRenderBackend& renderBackend) : renderBackend_(renderBackend) {

270

271 renderTargetBatches_.reserve(DEFAULT_FRAMEBUFFER_POOL_CAPACITY);

272

273 }

Reference DEFAULT_FRAMEBUFFER_POOL_CAPACITY.

Public Member Functions

flush()

template <typename TRenderBackend, typename TMemberHandle>

void helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::flush (UpdateContext & updateContext)

inline

Flushes all active render-target batches to the backend.

Traverses active render targets and nested viewport/shader/material/mesh batches, executes backend begin/end hooks for each level, renders queued draw contexts, and clears all active batch indices afterwards.

Parameters

updateContext

Current frame update context.

Definition at line 285 of file RenderManager.ixx.

285 void flush(UpdateContext& updateContext) {

286

287 for (auto renderTargetIdx : activeRenderTargetIndices_) {

288 auto& renderTargetBatch = renderTargetBatches_[renderTargetIdx];

289

290 renderBackend_.beginRenderTargetBatch(renderTargetBatch.handle);

291

292 for (auto viewportIdx : renderTargetBatch.activeIndices) {

293 auto& viewportBatch = renderTargetBatch.batches[viewportIdx];

294

295 renderBackend_.beginViewportBatch(viewportBatch.handle);

296

297 for (auto shaderIdx : viewportBatch.activeIndices ) {

298 auto& shaderBatch = viewportBatch.batches[shaderIdx];

299

300 renderBackend_.beginShaderBatch(shaderBatch.handle);

301

302 for (auto materialIdx : shaderBatch.activeIndices) {

303 auto& materialBatch = shaderBatch.batches[materialIdx];

304

305 renderBackend_.beginMaterialBatch(materialBatch.handle);

306

307 for (auto meshIdx : materialBatch.activeIndices) {

308 auto& meshBatch = materialBatch.batches[meshIdx];

309

310 renderBackend_.beginMeshBatch(meshBatch.handle);

311

312 renderBackend_.template renderBatch<TMemberHandle>(meshBatch.drawContexts);

313

314 renderBackend_.endMeshBatch(meshBatch.handle);

315 } // materialBatch

316

317 renderBackend_.endMaterialBatch(materialBatch.handle);

318 } //shaderBatch

319

320 renderBackend_.endShaderBatch(shaderBatch.handle);

321 } // viewportBatch

322

323 renderBackend_.endViewportBatch(viewportBatch.handle);

324 } //renderTargetBatch

325

326 renderBackend_.endRenderTargetBatch(renderTargetBatch.handle);

327 }

328

329 for (auto idx : activeRenderTargetIndices_ ) {

330 renderTargetBatches_[idx].clear();

331 }

332 activeRenderTargetIndices_.clear();

333

334

335 }

Reference helios::engine::rendering::registerComponents.

init()

template <typename TRenderBackend, typename TMemberHandle>

void helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::init (CommandHandlerRegistry & commandHandlerRegistry)

inline noexcept

Registers this manager as handler for render commands.

Parameters

commandHandlerRegistry

Command handler registry used at runtime.

Definition at line 395 of file RenderManager.ixx.

395 void init(CommandHandlerRegistry& commandHandlerRegistry) noexcept {

396

397 commandHandlerRegistry.handleCommands<

398 RenderSceneMemberCommand<TMemberHandle>,

399 RenderSceneCommand<TMemberHandle>

400 >(*this);

401

402

403 };

submit()

template <typename TRenderBackend, typename TMemberHandle>

bool helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::submit (RenderSceneCommand< TMemberHandle > renderSceneCommand)

inline noexcept

Queues one scene render context into the batch structure.

Ensure that the ViewportBatch is available for the next flush(). In case all Scene Members where culled, i.e. the shader/material/mesh batches are empty, viewport batches are sent to the graphics backend for making sure no artifacts are left in the viewport from the previous render operation, if any.

Parameters

renderSceneCommand

Returns

Definition at line 349 of file RenderManager.ixx.

349 bool submit(RenderSceneCommand<TMemberHandle> renderSceneCommand) noexcept {

350

351 std::ignore = ensureViewportBatch(

352 renderSceneCommand.sceneRenderContext.renderTargetHandle,

353 renderSceneCommand.sceneRenderContext.viewportHandle

354 );

355

356 return true;

357 }

Reference helios::engine::rendering::registerComponents.

submit()

template <typename TRenderBackend, typename TMemberHandle>

bool helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::submit (RenderSceneMemberCommand< TMemberHandle > renderCommand)

inline noexcept

Queues one draw context into the hierarchical batch structure.

Activates missing nodes for render target, viewport, shader, material, and mesh, then appends the draw context to the mesh batch for later rendering in flush(...).

Parameters

renderCommand

Command containing per-member render context.

Returns

true if the command was accepted.

Definition at line 369 of file RenderManager.ixx.

369 bool submit(RenderSceneMemberCommand<TMemberHandle> renderCommand) noexcept {

370

371 auto& sceneMemberRenderContext = std::move(renderCommand.sceneMemberRenderContext);

372

373 auto& renderTargetHandle = sceneMemberRenderContext.renderTargetHandle;

374 auto& viewportHandle = sceneMemberRenderContext.viewportHandle;

375 auto& materialHandle = sceneMemberRenderContext.materialHandle;

376 auto& meshHandle = sceneMemberRenderContext.meshHandle;

377 auto& shaderHandle = sceneMemberRenderContext.shaderHandle;

378

379 auto& viewportBatch = ensureViewportBatch(renderTargetHandle, viewportHandle);

380 auto& shaderBatch = viewportBatch.getOrAdd(shaderHandle);

381 auto& materialBatch = shaderBatch.getOrAdd(materialHandle);

382 auto& meshBatch = materialBatch.getOrAdd(meshHandle);

383

384 meshBatch.drawContexts.push_back(std::move(sceneMemberRenderContext));

385

386 return true;

387 }

Reference helios::engine::rendering::registerComponents.

Private Member Functions

ensureViewportBatch()

template <typename TRenderBackend, typename TMemberHandle>

ViewportBatch< TMemberHandle > & helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::ensureViewportBatch (RenderTargetHandle renderTargetHandle, ViewportHandle viewportHandle)

inline

makes sure a ViewportBatch is available for the specified RenderTargetHandle and ViewportHandle.

Parameters

renderTargetHandle
viewportHandle

Returns

Definition at line 237 of file RenderManager.ixx.

237 [[nodiscard]] ViewportBatch<TMemberHandle>& ensureViewportBatch(

238 RenderTargetHandle renderTargetHandle, ViewportHandle viewportHandle) {

239

240 auto renderTargetId = renderTargetHandle.entityId;

241

242 if (renderTargetBatches_.size() <= renderTargetHandle.entityId) {

243 renderTargetBatches_.resize(renderTargetId + 1);

244 }

245

246 auto& renderTargetBatch = renderTargetBatches_[renderTargetId];

247

248 if (!renderTargetBatch.isActive) {

249 renderTargetBatch.isActive = true;

250 renderTargetBatch.handle = renderTargetHandle;

251 activeRenderTargetIndices_.push_back(renderTargetId);

252 }

253

254 return renderTargetBatch.getOrAdd(viewportHandle);

255 };

Private Member Attributes

activeRenderTargetIndices_

template <typename TRenderBackend, typename TMemberHandle>

std::vector<EntityId> helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::activeRenderTargetIndices_

Definition at line 225 of file RenderManager.ixx.

225 std::vector<EntityId> activeRenderTargetIndices_;

renderBackend_

template <typename TRenderBackend, typename TMemberHandle>

TRenderBackend& helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::renderBackend_

Definition at line 227 of file RenderManager.ixx.

227 TRenderBackend& renderBackend_;

renderTargetBatches_

template <typename TRenderBackend, typename TMemberHandle>

std::vector<RenderTargetBatch<TMemberHandle> > helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::renderTargetBatches_

Definition at line 224 of file RenderManager.ixx.

224 std::vector<RenderTargetBatch<TMemberHandle>> renderTargetBatches_;

Private Static Functions

addToBatch()

template <typename THandle, typename TChildBatch>

TChildBatch & helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::addToBatch (const THandle handle, std::vector< TChildBatch > & batches, std::vector< EntityId > & activeIndices)

inline static

Returns the existing child batch for a handle or activates a new one.

Template Parameters

THandle	Handle type used as index source.
TChildBatch	Child batch type.

Parameters

handle	Handle selecting the batch slot.
batches	Child batch storage.
activeIndices	Active child indices list.

Returns

Reference to the active child batch.

Definition at line 108 of file RenderManager.ixx.

108 static TChildBatch& addToBatch(const THandle handle, std::vector<TChildBatch>& batches, std::vector<EntityId>& activeIndices) {

109 if (handle.entityId >= batches.size()) {

110 batches.resize(handle.entityId + 1);

111 }

112 auto& batch = batches[handle.entityId];

113

114 if (!batches[handle.entityId].isActive) {

115 batch.handle = handle;

116 batches[handle.entityId].isActive = true;

117 activeIndices.push_back(handle.entityId);

118 }

119

120 return batch;

121 }

clearActive()

template <typename TBatch, typename TChildHandle>

void helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::clearActive (TBatch * batch, std::vector< EntityId > & activeIndices, std::vector< TChildHandle > & batches)

inline static

Clears active child batches and resets the parent batch active flag.

Template Parameters

TBatch	Parent batch type.
TChildHandle	Child batch element type.

Parameters

batch	Parent batch to reset.
activeIndices	Active child indices to clear.
batches	Child batch storage.

Definition at line 89 of file RenderManager.ixx.

89 static void clearActive(TBatch* batch, std::vector<EntityId>& activeIndices, std::vector<TChildHandle>& batches) {

90 batch->isActive = false;

91 for (auto idx: activeIndices) {

92 batches[idx].clear();

93 }

94 activeIndices.clear();

95 }

Private Static Attributes

logger_

template <typename TRenderBackend, typename TMemberHandle>

auto& helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::logger_ = LogManager::loggerForScope(HELIOS_LOG_SCOPE)

static

Definition at line 221 of file RenderManager.ixx.

221 inline static auto& logger_ = LogManager::loggerForScope(HELIOS_LOG_SCOPE);

---

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

• RenderManager.ixx

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.