SceneRenderSystem.ixx File

Extracts visible scene members into render commands per viewport. More...

Included Headers

#include <concepts> #include <cassert> #include <tuple> #include "helios-engine-config.h" #include <helios.engine.util.log> #include <helios.engine.rendering.viewport.concepts.IsViewportHandle> #include <helios.engine.core.types.ComponentTypeTags> #include <helios.engine.scene.concepts.IsFrustumCullerLike> #include <helios.engine.scene.SceneMemberVisibilityRegistry> #include <helios.engine.runtime.messaging.command.concepts.IsCommandBufferLike> #include <helios.engine.runtime.world.tags.SystemRole> #include <helios.engine.scene.types> #include <helios.engine.scene.components> #include <helios.engine.rendering.common.commands> #include <helios.engine.rendering.renderTarget.components.RenderTargetBindingComponent> #include <helios.engine.rendering.common.components> #include <helios.engine.spatial.components> #include <helios.math> #include <helios.ecs.components.Active> #include <helios.engine.runtime.messaging.command.NullCommandBuffer> #include <helios.engine.runtime.world.UpdateContext>

Namespaces Index

namespace	helios
namespace	engine
namespace	scene
namespace	systems

Classes Index

class	SceneRenderSystem<TOwnerHandle, TMemberHandle, TCullingStrategy, TCommandBuffer>
	System that extracts per-member render contexts for active viewports. More...

Macro Definitions Index

#define	HELIOS_LOG_SCOPE   "helios::engine::scene::systems::SceneRenderSystem"

Description

Extracts visible scene members into render commands per viewport.

Macro Definitions

HELIOS_LOG_SCOPE

#define HELIOS_LOG_SCOPE   "helios::engine::scene::systems::SceneRenderSystem"

Definition at line 57 of file SceneRenderSystem.ixx.

57#define HELIOS_LOG_SCOPE "helios::engine::scene::systems::SceneRenderSystem"

File Listing

The file content with the documentation metadata removed is:

1

5module;

6

7#include <concepts>

8#include <cassert>

9#include <tuple>

10#include "helios-engine-config.h"

11

12export module helios.engine.scene.systems.SceneRenderSystem;

13

14import helios.engine.rendering.viewport.concepts.IsViewportHandle;

15

16import helios.engine.scene.SceneMemberVisibilityRegistry;

17import helios.engine.scene.types;

18import helios.engine.scene.components;

19import helios.engine.scene.concepts.IsFrustumCullerLike;

20

21import helios.engine.rendering.common.components;

22import helios.engine.rendering.common.commands;

23

24import helios.engine.rendering.renderTarget.components.RenderTargetBindingComponent;

25

26import helios.engine.spatial.components;

27

28import helios.engine.runtime.world.UpdateContext;

29import helios.engine.runtime.messaging.command.NullCommandBuffer;

30import helios.engine.runtime.messaging.command.concepts.IsCommandBufferLike;

31import helios.engine.runtime.world.tags.SystemRole;

32

33import helios.ecs.components.Active;

34

35

36import helios.engine.util.log;

37

38import helios.math;

39import helios.engine.core.types.ComponentTypeTags;

40

41using namespace helios::engine::core::types;

42using namespace helios::engine::scene;

43using namespace helios::engine::scene::types;

44using namespace helios::engine::scene::concepts;

45using namespace helios::engine::scene::components;

46using namespace helios::ecs::components;

47using namespace helios::engine::rendering::common::components;

48using namespace helios::engine::rendering::viewport::concepts;

49using namespace helios::engine::rendering::renderTarget::components;

50using namespace helios::engine::scene::types;

51using namespace helios::engine::runtime::messaging::command::concepts;

52using namespace helios::engine::spatial::components;

53using namespace helios::engine::rendering::common::commands;

54using namespace helios::engine::rendering::common::components;

55using namespace helios::engine::runtime::messaging::command;

56

57#define HELIOS_LOG_SCOPE "helios::engine::scene::systems::SceneRenderSystem"

58export namespace helios::engine::scene::systems {

59

73 template<

74 typename TOwnerHandle,

75 typename TMemberHandle,

76 typename TCullingStrategy,

77 typename TCommandBuffer = NullCommandBuffer

78 >

79 requires IsViewportHandle<TOwnerHandle> &&

80 IsFrustumCullerLike<TCullingStrategy, typename TCullingStrategy::MemberHandle_type> &&

81 std::same_as<typename TCullingStrategy::MemberHandle_type, TMemberHandle> &&

82 IsCommandBufferLike<TCommandBuffer>

83 class SceneRenderSystem {

84

85 TCullingStrategy cullingStrategy_;

86

87 static inline auto& logger_ = helios::engine::util::log::LogManager::loggerForScope(HELIOS_LOG_SCOPE);

88

89 SceneMemberVisibilityRegistry<TMemberHandle>& visibilityRegistry_;

90 public:

91

93 using EngineRoleTag = helios::engine::runtime::world::tags::SystemRole;

94

96 using CommandBuffer_type = TCommandBuffer;

97

105 explicit SceneRenderSystem(TCullingStrategy cullingStrategy, SceneMemberVisibilityRegistry<TMemberHandle>& visibilityRegistry)

106 : cullingStrategy_(std::move(cullingStrategy)), visibilityRegistry_(visibilityRegistry) {}

107

114 void update(helios::engine::runtime::world::UpdateContext& updateContext, TCommandBuffer& cmdBuffer) noexcept {

115

116

117 for (auto [viewportEntity, fbc, sbc, cbc, viewportActive] : updateContext.view<

118 TOwnerHandle,

119 RenderTargetBindingComponent<TOwnerHandle>,

120 SceneBindingComponent<TOwnerHandle>,

121 CameraBindingComponent<TOwnerHandle>,

122 Active<TOwnerHandle>

123 >().whereEnabled()) {

124

125 const auto sceneHandle = sbc->targetHandle();

126 const auto cameraHandle = cbc->targetHandle();

127

128 const auto camera = updateContext.find<TMemberHandle>(cameraHandle);

129 if (!camera) {

130 assert(false && "Camera not found");

131 logger_.error("Camera not found");

132 continue;

133 }

134 auto* pmc = camera->template get<ProjectionMatrixComponent<TMemberHandle>>();

135 if (!pmc) {

136 assert(pmc && "Camera had no ProjectionMatrixComponent");

137 logger_.error("Camera had no ProjectionMatrixComponent");

138 continue;

139 }

140 auto* lac = camera->template get<ViewMatrixComponent<TMemberHandle>>();

141 if (!lac) {

142 assert(lac && "Camera had no ViewMatrixComponent");

143 logger_.error("Camera had no ViewMatrixComponent");

144 continue;

145 }

146

147 auto* pcc = camera->template get<PerspectiveCameraComponent<TMemberHandle>>();

148 auto frustumPlanes = helios::math::frustumPlanes(

149 pcc->fovY(), pcc->aspectRatio(), pcc->zNear(), pcc->zFar(), lac->value()

150 );

151

152 auto cullingContext = CullingContext<TMemberHandle>{frustumPlanes, pmc->value(), lac->value()};

153

154 cmdBuffer.template add<RenderSceneCommand<TMemberHandle>>(

155 SceneRenderContext<TMemberHandle>{

156 fbc->targetHandle(),

157 viewportEntity.handle(),

158 sceneHandle

159 });

160

161

162

163#if HELIOS_DEBUG

164 std::size_t available = 0;

165 std::size_t used = 0;

166#endif

167

168 for (auto [

169 memberEntity,

170 smc,

171 rpc,

172 transformWorld,

173 boundsWorld,

174 memberActive

175 ] : updateContext.view<

176 TMemberHandle,

177 SceneMemberComponent<TMemberHandle>,

178 RenderPrototypeComponent<TMemberHandle>,

179 TransformComponent<TMemberHandle, World>,

180 BoundsComponent<TMemberHandle, World>,

181 Active<TMemberHandle>

182 >().whereEnabled()) {

183

184 cullingContext.bounds = boundsWorld->value();

185 cullingContext.handle = memberEntity.handle();

186

187#if HELIOS_DEBUG

188 available++;

189#endif

190 if (smc->targetHandle() == sceneHandle && cullingStrategy_.shouldRender(cullingContext)) {

191#if HELIOS_DEBUG

192 used++;

193#endif

194 std::ignore = visibilityRegistry_.addVisibleMember(viewportEntity.handle(), memberEntity.handle());

195 cmdBuffer.template add<RenderSceneMemberCommand<TMemberHandle>>(

196 SceneMemberRenderContext<TMemberHandle>{

197 memberEntity.handle(),

198 fbc->targetHandle(),

199 viewportEntity.handle(),

200 sceneHandle,

201 rpc->meshHandle(),

202 rpc->materialHandle(),

203 rpc->shaderHandle(),

204 transformWorld->value()

205 });

206

207

208 } else {

209 std::ignore = visibilityRegistry_.addCulledMember(viewportEntity.handle(), memberEntity.handle());

210 }

211 }

212

213#if HELIOS_DEBUG

214 logger_.debug("Available {0}, culled in {1}, used {2} scene members for viewport {3}.", available, available - used, used, viewportEntity.handle().entityId);

215#endif

216

217 }

218

219 }

220

221 };

222

223}

---

Generated via doxygen2docusaurus 2.0.0 by Doxygen 1.9.8.