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>
bool	submit (RenderInstanceBatchCommand< TMemberHandle > &&renderCommand) noexcept
	Queues an instanced draw batch 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 > &
	Ensures that the render-target and viewport batch nodes exist and are active. More...
template <typename TContextType>
auto &	meshBatchFor (TContextType &renderContext) noexcept
	Resolves the mesh batch for a render context and activates missing hierarchy nodes. More...

Private Member Attributes Index

template <typename TRenderBackend, typename TMemberHandle>
std::vector< RenderTargetBatch< TMemberHandle > >	renderTargetBatches_
	Top-level render-target batch storage indexed by handle entity id. More...
template <typename TRenderBackend, typename TMemberHandle>
std::vector< EntityId >	activeRenderTargetIndices_
	Active render-target indices used for frame-local flush traversal. More...
template <typename TRenderBackend, typename TMemberHandle>
TRenderBackend &	renderBackend_
	Backend instance that receives begin/end hooks and draw submissions. More...

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)
	Scoped logger used for debug and diagnostics output. More...

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 79 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 304 of file RenderManager.ixx.

304 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 311 of file RenderManager.ixx.

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

312

313 renderTargetBatches_.reserve(DEFAULT_FRAMEBUFFER_POOL_CAPACITY);

314

315 }

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 327 of file RenderManager.ixx.

327 void flush(UpdateContext& updateContext) {

328

329 for (auto renderTargetIdx : activeRenderTargetIndices_) {

330 auto& renderTargetBatch = renderTargetBatches_[renderTargetIdx];

331

332 renderBackend_.beginRenderTargetBatch(renderTargetBatch.handle);

333

334 for (auto viewportIdx : renderTargetBatch.activeIndices) {

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

336

337 renderBackend_.beginViewportBatch(viewportBatch.handle);

338

339 for (auto shaderIdx : viewportBatch.activeIndices ) {

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

341

342 renderBackend_.beginShaderBatch(shaderBatch.handle);

343

344 for (auto materialIdx : shaderBatch.activeIndices) {

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

346

347 renderBackend_.beginMaterialBatch(materialBatch.handle);

348

349 for (auto meshIdx : materialBatch.activeIndices) {

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

351

352 renderBackend_.beginMeshBatch(meshBatch.handle);

353

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

355 renderBackend_.template renderBatch<TMemberHandle>(meshBatch.instanceData);

356

357 renderBackend_.endMeshBatch(meshBatch.handle);

358 } // materialBatch

359

360 renderBackend_.endMaterialBatch(materialBatch.handle);

361 } //shaderBatch

362

363 renderBackend_.endShaderBatch(shaderBatch.handle);

364 } // viewportBatch

365

366 renderBackend_.endViewportBatch(viewportBatch.handle);

367 } //renderTargetBatch

368

369 renderBackend_.endRenderTargetBatch(renderTargetBatch.handle);

370 }

371

372 for (auto idx : activeRenderTargetIndices_ ) {

373 renderTargetBatches_[idx].clear();

374 }

375 activeRenderTargetIndices_.clear();

376

377

378 }

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 454 of file RenderManager.ixx.

454 void init(CommandHandlerRegistry& commandHandlerRegistry) noexcept {

455

456 commandHandlerRegistry.handleCommands<

457 RenderSceneMemberCommand<TMemberHandle>,

458 RenderInstanceBatchCommand<TMemberHandle>,

459 RenderSceneCommand<TMemberHandle>

460 >(*this);

461

462

463 };

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 were 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

Command containing scene-level render context.

Returns

true if the command was accepted.

Definition at line 392 of file RenderManager.ixx.

392 bool submit(RenderSceneCommand<TMemberHandle>&& renderSceneCommand) noexcept {

393

394 std::ignore = ensureViewportBatch(

395 renderSceneCommand.sceneRenderContext.renderTargetHandle,

396 renderSceneCommand.sceneRenderContext.viewportHandle

397 );

398

399 return true;

400 }

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 412 of file RenderManager.ixx.

412 bool submit(RenderSceneMemberCommand<TMemberHandle>&& renderCommand) noexcept {

413

414 auto renderContext = std::move(renderCommand.sceneMemberRenderContext);

415

416 auto& meshBatch = meshBatchFor(renderContext);

417

418 meshBatch.drawContexts.push_back(std::move(renderContext));

419

420 return true;

421 }

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

submit()

template <typename TRenderBackend, typename TMemberHandle>

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

inline noexcept

Queues an instanced draw batch into the hierarchical batch structure.

Activates missing nodes for render target, viewport, shader, material, and mesh, then appends or moves instance payload into the mesh batch for later rendering in flush(...).

Parameters

renderCommand

Command containing instance batch context.

Returns

true if the command was accepted.

Definition at line 432 of file RenderManager.ixx.

432 bool submit(RenderInstanceBatchCommand<TMemberHandle>&&renderCommand) noexcept {

433

434 auto renderContext = std::move(renderCommand.instanceRenderBatchContext);

435

436 auto& meshBatch = meshBatchFor(renderContext);

437

438 if (meshBatch.instanceData.empty()) {

439 meshBatch.instanceData = std::move(renderContext.instanceData);

440 } else {

441 meshBatch.instanceData.reserve(meshBatch.instanceData.size() + renderContext.instanceData.size());

442 std::ranges::move(renderContext.instanceData, std::back_inserter(meshBatch.instanceData));

443 }

444

445 return true;

446 }

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

Ensures that the render-target and viewport batch nodes exist and are active.

Parameters

renderTargetHandle	Render target used as top-level batch key.
viewportHandle	Viewport used as second-level batch key.

Returns

Active viewport batch for the given handles.

Definition at line 256 of file RenderManager.ixx.

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

257 RenderTargetHandle renderTargetHandle, ViewportHandle viewportHandle) {

258

259 auto renderTargetId = renderTargetHandle.entityId;

260

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

262 renderTargetBatches_.resize(renderTargetId + 1);

263 }

264

265 auto& renderTargetBatch = renderTargetBatches_[renderTargetId];

266

267 if (!renderTargetBatch.isActive) {

268 renderTargetBatch.isActive = true;

269 renderTargetBatch.handle = renderTargetHandle;

270 activeRenderTargetIndices_.push_back(renderTargetId);

271 }

272

273 return renderTargetBatch.getOrAdd(viewportHandle);

274 };

meshBatchFor()

template <typename TContextType>

auto & helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::meshBatchFor (TContextType & renderContext)

inline noexcept

Resolves the mesh batch for a render context and activates missing hierarchy nodes.

Batches are scoped by render target and viewport. A viewport is bound to exactly one scene, so sceneHandle is not required as part of the batch key.

Template Parameters

TContextType

Context type exposing render target, viewport, shader, material, and mesh handles.

Parameters

renderContext

Render context used as batch key source.

Returns

Reference to the resolved mesh batch.

Definition at line 289 of file RenderManager.ixx.

289 auto& meshBatchFor(TContextType& renderContext) noexcept {

290

291 auto& viewportBatch = ensureViewportBatch(renderContext.renderTargetHandle, renderContext.viewportHandle);

292 auto& shaderBatch = viewportBatch.getOrAdd(renderContext.shaderHandle);

293 auto& materialBatch = shaderBatch.getOrAdd(renderContext.materialHandle);

294 auto& meshBatch = materialBatch.getOrAdd(renderContext.meshHandle);

295

296 return meshBatch;

297 }

Private Member Attributes

activeRenderTargetIndices_

template <typename TRenderBackend, typename TMemberHandle>

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

Active render-target indices used for frame-local flush traversal.

Definition at line 242 of file RenderManager.ixx.

242 std::vector<EntityId> activeRenderTargetIndices_;

renderBackend_

template <typename TRenderBackend, typename TMemberHandle>

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

Backend instance that receives begin/end hooks and draw submissions.

Definition at line 247 of file RenderManager.ixx.

247 TRenderBackend& renderBackend_;

renderTargetBatches_

template <typename TRenderBackend, typename TMemberHandle>

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

Top-level render-target batch storage indexed by handle entity id.

Definition at line 237 of file RenderManager.ixx.

237 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 110 of file RenderManager.ixx.

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

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

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

113 }

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

115

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

117 batch.handle = handle;

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

119 activeIndices.push_back(handle.entityId);

120 }

121

122 return batch;

123 }

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 91 of file RenderManager.ixx.

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

92 batch->isActive = false;

93 for (auto idx: activeIndices) {

94 batches[idx].clear();

95 }

96 activeIndices.clear();

97 }

Private Static Attributes

logger_

template <typename TRenderBackend, typename TMemberHandle>

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

static

Scoped logger used for debug and diagnostics output.

Definition at line 231 of file RenderManager.ixx.

231 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.