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 (RenderCommand< 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 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 235 of file RenderManager.ixx.

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

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

243

244 renderTargetBatches_.reserve(DEFAULT_FRAMEBUFFER_POOL_CAPACITY);

245

246 }

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

258 void flush(UpdateContext& updateContext) {

259

260 for (auto renderTargetIdx : activeRenderTargetIndices_) {

261 auto& renderTargetBatch = renderTargetBatches_[renderTargetIdx];

262

263 renderBackend_.beginRenderTargetBatch(renderTargetBatch.handle);

264

265 for (auto viewportIdx : renderTargetBatch.activeIndices) {

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

267

268 renderBackend_.beginViewportBatch(viewportBatch.handle);

269

270 for (auto shaderIdx : viewportBatch.activeIndices ) {

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

272

273 renderBackend_.beginShaderBatch(shaderBatch.handle);

274

275 for (auto materialIdx : shaderBatch.activeIndices) {

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

277

278 renderBackend_.beginMaterialBatch(materialBatch.handle);

279

280 for (auto meshIdx : materialBatch.activeIndices) {

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

282

283 renderBackend_.beginMeshBatch(meshBatch.handle);

284

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

286

287 renderBackend_.endMeshBatch(meshBatch.handle);

288 } // materialBatch

289

290 renderBackend_.endMaterialBatch(materialBatch.handle);

291 } //shaderBatch

292

293 renderBackend_.endShaderBatch(shaderBatch.handle);

294 } // viewportBatch

295

296 renderBackend_.endViewportBatch(viewportBatch.handle);

297 } //renderTargetBatch

298

299 renderBackend_.endRenderTargetBatch(renderTargetBatch.handle);

300 }

301

302 for (auto idx : activeRenderTargetIndices_ ) {

303 renderTargetBatches_[idx].clear();

304 }

305 activeRenderTargetIndices_.clear();

306

307

308 }

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

358 void init(CommandHandlerRegistry& commandHandlerRegistry) noexcept {

359

360 commandHandlerRegistry.handleCommands<

361 RenderCommand<TMemberHandle>

362 >(*this);

363

364

365 };

submit()

template <typename TRenderBackend, typename TMemberHandle>

bool helios::engine::rendering::RenderManager< TRenderBackend, TMemberHandle >::submit (RenderCommand< 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 320 of file RenderManager.ixx.

320 bool submit(RenderCommand<TMemberHandle> renderCommand) noexcept {

321

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

323

324 auto& viewportHandle = sceneMemberRenderContext.viewportHandle;

325 auto& materialHandle = sceneMemberRenderContext.materialHandle;

326 auto& meshHandle = sceneMemberRenderContext.meshHandle;

327 auto& shaderHandle = sceneMemberRenderContext.shaderHandle;

328

329 auto renderTargetId = sceneMemberRenderContext.renderTargetHandle.entityId;

330

331 if (renderTargetBatches_.size() <= sceneMemberRenderContext.renderTargetHandle.entityId) {

332 renderTargetBatches_.resize(renderTargetId + 1);

333 }

334

335 auto& renderTargetBatch = renderTargetBatches_[renderTargetId];

336

337 if (!renderTargetBatch.isActive) {

338 renderTargetBatch.isActive = true;

339 renderTargetBatch.handle = sceneMemberRenderContext.renderTargetHandle;

340 activeRenderTargetIndices_.push_back(renderTargetId);

341 }

342

343 auto& viewportBatch = renderTargetBatch.getOrAdd(viewportHandle);

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

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

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

347

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

349

350 return true;

351 }

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

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.