1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "render_node_scene_util.h"
17
18 #include <algorithm>
19
20 #include <3d/render/intf_render_data_store_default_camera.h>
21 #include <3d/render/intf_render_data_store_default_material.h>
22 #include <3d/render/intf_render_data_store_default_scene.h>
23 #include <3d/render/render_data_defines_3d.h>
24 #include <base/containers/vector.h>
25 #include <base/math/matrix_util.h>
26 #include <core/implementation_uids.h>
27 #include <core/log.h>
28 #include <core/namespace.h>
29 #include <core/plugin/intf_plugin_register.h>
30 #include <core/util/intf_frustum_util.h>
31 #include <render/datastore/intf_render_data_store_manager.h>
32 #include <render/device/intf_gpu_resource_manager.h>
33 #include <render/device/pipeline_state_desc.h>
34 #include <render/nodecontext/intf_render_node.h>
35 #include <render/nodecontext/intf_render_node_context_manager.h>
36 #include <render/nodecontext/intf_render_node_util.h>
37
38 #include "render/datastore/render_data_store_default_material.h"
39
40 CORE3D_BEGIN_NAMESPACE()
41 using namespace BASE_NS;
42 using namespace CORE_NS;
43 using namespace RENDER_NS;
44
45 namespace {
operator <(const SlotSubmeshIndex & lhs,const SlotSubmeshIndex & rhs)46 inline bool operator<(const SlotSubmeshIndex& lhs, const SlotSubmeshIndex& rhs)
47 {
48 if (lhs.sortLayerKey < rhs.sortLayerKey) {
49 return true;
50 } else if (lhs.sortLayerKey == rhs.sortLayerKey) {
51 return (lhs.sortKey < rhs.sortKey);
52 } else {
53 return false;
54 }
55 }
56
operator >(const SlotSubmeshIndex & lhs,const SlotSubmeshIndex & rhs)57 inline bool operator>(const SlotSubmeshIndex& lhs, const SlotSubmeshIndex& rhs)
58 {
59 if (lhs.sortLayerKey > rhs.sortLayerKey) {
60 return true;
61 } else if (lhs.sortLayerKey == rhs.sortLayerKey) {
62 return (lhs.sortKey > rhs.sortKey);
63 } else {
64 return false;
65 }
66 }
67
68 template<class T>
69 struct Less {
operator ()__anonea84aaff0111::Less70 constexpr bool operator()(const T& lhs, const T& rhs) const
71 {
72 return lhs < rhs;
73 }
74 };
75
76 template<class T>
77 struct Greater {
operator ()__anonea84aaff0111::Greater78 constexpr bool operator()(const T& lhs, const T& rhs) const
79 {
80 return lhs > rhs;
81 }
82 };
83
UpdateRenderArea(const Math::Vec4 & scissor,RenderPassDesc::RenderArea & renderArea)84 void UpdateRenderArea(const Math::Vec4& scissor, RenderPassDesc::RenderArea& renderArea)
85 {
86 // prevent larger than image render area
87 if (scissor.x >= 0.0f && scissor.y >= 0.0f && scissor.z <= 1.0f && scissor.w <= 1.0f) {
88 const float fWidth = static_cast<float>(renderArea.extentWidth);
89 const float fHeight = static_cast<float>(renderArea.extentHeight);
90
91 const float offsetX = (fWidth * scissor.x);
92 const float offsetY = (fHeight * scissor.y);
93 const float extentWidth = (fWidth * scissor.z);
94 const float extentHeight = (fHeight * scissor.w);
95
96 renderArea = {
97 static_cast<int32_t>(offsetX),
98 static_cast<int32_t>(offsetY),
99 static_cast<uint32_t>(extentWidth),
100 static_cast<uint32_t>(extentHeight),
101 };
102 }
103 }
104
UpdateCustomCameraTargets(const RenderCamera & camera,RenderPass & renderPass)105 void UpdateCustomCameraTargets(const RenderCamera& camera, RenderPass& renderPass)
106 {
107 auto& subpassDesc = renderPass.subpassDesc;
108 RenderPassDesc& renderPassDesc = renderPass.renderPassDesc;
109 if ((camera.flags & RenderCamera::CAMERA_FLAG_MSAA_BIT) == 0) {
110 if ((subpassDesc.depthAttachmentCount == 1) && camera.depthTarget) {
111 renderPassDesc.attachmentHandles[subpassDesc.depthAttachmentIndex] = camera.depthTarget.GetHandle();
112 }
113 if ((subpassDesc.colorAttachmentCount >= 1) && camera.colorTargets[0u]) {
114 renderPassDesc.attachmentHandles[subpassDesc.colorAttachmentIndices[0]] =
115 camera.colorTargets[0u].GetHandle();
116 }
117 }
118 }
119
UpdateCustomCameraLoadStore(const RenderCamera & camera,RenderPass & renderPass)120 void UpdateCustomCameraLoadStore(const RenderCamera& camera, RenderPass& renderPass)
121 {
122 // NOTE: if clear bits given the camera RNG loadOp is overrided with clear
123 // otherwise the loadOp is the one from RNG
124 auto& subpassDesc = renderPass.subpassDesc;
125 if ((subpassDesc.depthAttachmentCount == 1) &&
126 (subpassDesc.depthAttachmentIndex < PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT)) {
127 auto& attRef = renderPass.renderPassDesc.attachments[subpassDesc.depthAttachmentIndex];
128 if ((camera.flags & RenderCamera::CAMERA_FLAG_CLEAR_DEPTH_BIT)) {
129 attRef.loadOp = AttachmentLoadOp::CORE_ATTACHMENT_LOAD_OP_CLEAR;
130 attRef.clearValue.depthStencil = camera.clearDepthStencil;
131 }
132 if (((camera.flags & RenderCamera::CAMERA_FLAG_MSAA_BIT) == 0) &&
133 (camera.flags & RenderCamera::CAMERA_FLAG_OUTPUT_DEPTH_BIT)) {
134 attRef.storeOp = AttachmentStoreOp::CORE_ATTACHMENT_STORE_OP_STORE;
135 }
136 }
137 for (uint32_t idx = 0; idx < subpassDesc.colorAttachmentCount; ++idx) {
138 if (subpassDesc.colorAttachmentIndices[idx] < PipelineStateConstants::MAX_RENDER_PASS_ATTACHMENT_COUNT) {
139 auto& attRef = renderPass.renderPassDesc.attachments[subpassDesc.colorAttachmentIndices[idx]];
140 if (camera.flags & RenderCamera::CAMERA_FLAG_CLEAR_COLOR_BIT) {
141 attRef.loadOp = AttachmentLoadOp::CORE_ATTACHMENT_LOAD_OP_CLEAR;
142 attRef.clearValue.color = camera.clearColorValues;
143 }
144 }
145 }
146 }
147
UpdateCameraFlags(const RenderCamera & camera,RenderPass & renderPass)148 void UpdateCameraFlags(const RenderCamera& camera, RenderPass& renderPass)
149 {
150 if (camera.multiViewCameraCount > 0U) {
151 // NOTE: does not over write viewmask if it has some special values
152 if (renderPass.subpassDesc.viewMask <= 1U) {
153 const uint32_t layerCount = camera.multiViewCameraCount + 1U;
154 renderPass.subpassDesc.viewMask = (1U << layerCount) - 1U;
155 }
156 }
157 }
158 } // namespace
159
GetSceneRenderDataStores(const IRenderNodeContextManager & renderNodeContextMgr,const string_view sceneDataStoreName)160 SceneRenderDataStores RenderNodeSceneUtil::GetSceneRenderDataStores(
161 const IRenderNodeContextManager& renderNodeContextMgr, const string_view sceneDataStoreName)
162 {
163 SceneRenderDataStores stores;
164 stores.dataStoreNameScene = sceneDataStoreName.empty() ? "RenderDataStoreDefaultScene" : sceneDataStoreName;
165 const auto& renderDataStoreMgr = renderNodeContextMgr.GetRenderDataStoreManager();
166 const IRenderDataStoreDefaultScene* dsScene =
167 static_cast<IRenderDataStoreDefaultScene*>(renderDataStoreMgr.GetRenderDataStore(stores.dataStoreNameScene));
168 if (dsScene) {
169 const RenderScene& rs = dsScene->GetScene();
170 stores.dataStoreNameMaterial =
171 rs.dataStoreNameMaterial.empty() ? "RenderDataStoreDefaultMaterial" : rs.dataStoreNameMaterial;
172 stores.dataStoreNameCamera =
173 rs.dataStoreNameCamera.empty() ? "RenderDataStoreDefaultCamera" : rs.dataStoreNameCamera;
174 stores.dataStoreNameLight =
175 rs.dataStoreNameLight.empty() ? "RenderDataStoreDefaultLight" : rs.dataStoreNameLight;
176 stores.dataStoreNameMorph = rs.dataStoreNameMorph.empty() ? "RenderDataStoreMorph" : rs.dataStoreNameMorph;
177 stores.dataStoreNamePrefix = rs.dataStoreNamePrefix;
178 }
179 return stores;
180 }
181
CreateViewportFromCamera(const RenderCamera & camera)182 ViewportDesc RenderNodeSceneUtil::CreateViewportFromCamera(const RenderCamera& camera)
183 {
184 const float fRenderResX = static_cast<float>(camera.renderResolution.x);
185 const float fRenderResY = static_cast<float>(camera.renderResolution.y);
186
187 const float offsetX = (fRenderResX * camera.viewport.x);
188 const float offsetY = (fRenderResY * camera.viewport.y);
189 const float extentWidth = (fRenderResX * camera.viewport.z);
190 const float extentHeight = (fRenderResY * camera.viewport.w);
191
192 return ViewportDesc {
193 offsetX,
194 offsetY,
195 extentWidth,
196 extentHeight,
197 0.0f,
198 1.0f,
199 };
200 }
201
CreateScissorFromCamera(const RenderCamera & camera)202 ScissorDesc RenderNodeSceneUtil::CreateScissorFromCamera(const RenderCamera& camera)
203 {
204 const float fRenderResX = static_cast<float>(camera.renderResolution.x);
205 const float fRenderResY = static_cast<float>(camera.renderResolution.y);
206
207 const float offsetX = (fRenderResX * camera.scissor.x);
208 const float offsetY = (fRenderResY * camera.scissor.y);
209 const float extentWidth = (fRenderResX * camera.scissor.z);
210 const float extentHeight = (fRenderResY * camera.scissor.w);
211
212 return ScissorDesc {
213 static_cast<int32_t>(offsetX),
214 static_cast<int32_t>(offsetY),
215 static_cast<uint32_t>(extentWidth),
216 static_cast<uint32_t>(extentHeight),
217 };
218 }
219
UpdateRenderPassFromCamera(const RenderCamera & camera,RenderPass & renderPass)220 void RenderNodeSceneUtil::UpdateRenderPassFromCamera(const RenderCamera& camera, RenderPass& renderPass)
221 {
222 renderPass.renderPassDesc.renderArea = { 0, 0, camera.renderResolution.x, camera.renderResolution.y };
223 if (camera.flags & RenderCamera::CameraFlagBits::CAMERA_FLAG_CUSTOM_TARGETS_BIT) {
224 UpdateCustomCameraTargets(camera, renderPass);
225 }
226 // NOTE: UpdateCustomCameraClears(camera, renderPass) is not yet called
227 UpdateRenderArea(camera.scissor, renderPass.renderPassDesc.renderArea);
228 UpdateCameraFlags(camera, renderPass);
229 }
230
UpdateRenderPassFromCustomCamera(const RenderCamera & camera,const bool isNamedCamera,RenderPass & renderPass)231 void RenderNodeSceneUtil::UpdateRenderPassFromCustomCamera(
232 const RenderCamera& camera, const bool isNamedCamera, RenderPass& renderPass)
233 {
234 renderPass.renderPassDesc.renderArea = { 0, 0, camera.renderResolution.x, camera.renderResolution.y };
235 // NOTE: legacy support is only taken into account when isNamedCamera flag is true
236 if ((camera.flags & RenderCamera::CameraFlagBits::CAMERA_FLAG_CUSTOM_TARGETS_BIT) && isNamedCamera) {
237 UpdateCustomCameraTargets(camera, renderPass);
238 }
239 UpdateCustomCameraLoadStore(camera, renderPass);
240 UpdateRenderArea(camera.scissor, renderPass.renderPassDesc.renderArea);
241 UpdateCameraFlags(camera, renderPass);
242 }
243
GetRenderSlotSubmeshes(const IRenderDataStoreDefaultCamera & dataStoreCamera,const IRenderDataStoreDefaultMaterial & dataStoreMaterial,const uint32_t cameraId,const IRenderNodeSceneUtil::RenderSlotInfo & renderSlotInfo,vector<SlotSubmeshIndex> & refSubmeshIndices)244 void RenderNodeSceneUtil::GetRenderSlotSubmeshes(const IRenderDataStoreDefaultCamera& dataStoreCamera,
245 const IRenderDataStoreDefaultMaterial& dataStoreMaterial, const uint32_t cameraId,
246 const IRenderNodeSceneUtil::RenderSlotInfo& renderSlotInfo, vector<SlotSubmeshIndex>& refSubmeshIndices)
247 {
248 // Get IFrustumUtil from global plugin registry.
249 auto frustumUtil = GetInstance<IFrustumUtil>(UID_FRUSTUM_UTIL);
250
251 // 64 bit sorting key should have
252 // material hash with:
253 // shader, materialIndex, meshId, and depth
254
255 Math::Vec3 camWorldPos { 0.0f, 0.0f, 0.0f };
256 uint64_t camLayerMask { RenderSceneDataConstants::INVALID_ID };
257 Frustum camFrustum;
258 if (const auto& cameras = dataStoreCamera.GetCameras(); cameraId < static_cast<uint32_t>(cameras.size())) {
259 const Math::Mat4X4 viewInv = Math::Inverse(cameras[cameraId].matrices.view);
260 camWorldPos = Math::Vec3(viewInv[3u]); // take world position from matrix
261 camLayerMask = cameras[cameraId].layerMask;
262 if (renderSlotInfo.cullType == RenderSlotCullType::VIEW_FRUSTUM_CULL) {
263 camFrustum = frustumUtil->CreateFrustum(cameras[cameraId].matrices.proj * cameras[cameraId].matrices.view);
264 }
265 }
266
267 constexpr uint64_t maxUDepth = RenderDataStoreDefaultMaterial::SLOT_SORT_MAX_DEPTH;
268 constexpr uint64_t sDepthShift = RenderDataStoreDefaultMaterial::SLOT_SORT_DEPTH_SHIFT;
269 constexpr uint64_t sRenderMask = RenderDataStoreDefaultMaterial::SLOT_SORT_HASH_MASK;
270 constexpr uint64_t sRenderShift = RenderDataStoreDefaultMaterial::SLOT_SORT_HASH_SHIFT;
271 // NOTE: might need to change to log value or similar
272 constexpr float depthUintCoeff { 1000.0f }; // one centimeter is one uint step
273
274 // NOTE: material sort should be based on PSO not shader handle
275 const auto& slotSubmeshIndices = dataStoreMaterial.GetSlotSubmeshIndices(renderSlotInfo.id);
276 const auto& slotSubmeshMatData = dataStoreMaterial.GetSlotSubmeshMaterialData(renderSlotInfo.id);
277 const auto& submeshes = dataStoreMaterial.GetSubmeshes();
278
279 refSubmeshIndices.clear();
280 refSubmeshIndices.reserve(slotSubmeshIndices.size());
281 for (size_t idx = 0; idx < slotSubmeshIndices.size(); ++idx) {
282 const uint32_t submeshIndex = slotSubmeshIndices[idx];
283 const auto& submesh = submeshes[submeshIndex];
284 const bool notCulled =
285 ((renderSlotInfo.cullType != RenderSlotCullType::VIEW_FRUSTUM_CULL) ||
286 frustumUtil->SphereFrustumCollision(camFrustum, submesh.worldCenter, submesh.worldRadius));
287 const auto& submeshMatData = slotSubmeshMatData[idx];
288 const bool discardedMat = (submeshMatData.renderMaterialFlags & renderSlotInfo.materialDiscardFlags);
289 if ((camLayerMask & submesh.layerMask) && notCulled && (!discardedMat)) {
290 const float distSq = Math::Distance2(submesh.worldCenter, camWorldPos);
291 uint64_t sortKey = Math::min(maxUDepth, static_cast<uint64_t>(distSq * depthUintCoeff));
292 if (renderSlotInfo.sortType == RenderSlotSortType::BY_MATERIAL) {
293 sortKey |= (((uint64_t)submeshMatData.renderSortHash & sRenderMask) << sRenderShift);
294 } else {
295 sortKey = (sortKey << sDepthShift) | ((uint64_t)slotSubmeshMatData[idx].renderSortHash & sRenderMask);
296 }
297 refSubmeshIndices.push_back(SlotSubmeshIndex { (uint32_t)submeshIndex,
298 submeshMatData.combinedRenderSortLayer, sortKey, submeshMatData.renderSortHash,
299 submeshMatData.shader.GetHandle(), submeshMatData.gfxState.GetHandle() });
300 }
301 }
302
303 // front-to-back and by-material render layer sort is 0 -> 63
304 // back-to-front render layer sort is 63 -> 0
305 if (renderSlotInfo.sortType == RenderSlotSortType::FRONT_TO_BACK ||
306 renderSlotInfo.sortType == RenderSlotSortType::BY_MATERIAL) {
307 std::sort(refSubmeshIndices.begin(), refSubmeshIndices.end(), Less<SlotSubmeshIndex>());
308 } else if (renderSlotInfo.sortType == RenderSlotSortType::BACK_TO_FRONT) {
309 std::sort(refSubmeshIndices.begin(), refSubmeshIndices.end(), Greater<SlotSubmeshIndex>());
310 }
311 }
312
GetSceneBufferHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName)313 SceneBufferHandles RenderNodeSceneUtil::GetSceneBufferHandles(
314 RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName)
315 {
316 SceneBufferHandles buffers;
317 const auto& gpuMgr = renderNodeContextMgr.GetGpuResourceManager();
318 buffers.camera = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialCameraConstants::CAMERA_DATA_BUFFER_NAME);
319 buffers.material = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MATERIAL_DATA_BUFFER_NAME);
320 buffers.materialTransform =
321 gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MATERIAL_TRANSFORM_DATA_BUFFER_NAME);
322 buffers.materialCustom =
323 gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MATERIAL_USER_DATA_BUFFER_NAME);
324 buffers.mesh = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MESH_DATA_BUFFER_NAME);
325 buffers.skinJoint = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::SKIN_DATA_BUFFER_NAME);
326
327 const RenderHandle defaultBuffer = gpuMgr.GetBufferHandle("CORE_DEFAULT_GPU_BUFFER");
328 auto checkValidity = [](const RenderHandle defaultBuffer, bool& valid, RenderHandle& buffer) {
329 if (!RenderHandleUtil::IsValid(buffer)) {
330 valid = false;
331 buffer = defaultBuffer;
332 }
333 };
334 bool valid = true;
335 checkValidity(defaultBuffer, valid, buffers.camera);
336 checkValidity(defaultBuffer, valid, buffers.material);
337 checkValidity(defaultBuffer, valid, buffers.materialTransform);
338 checkValidity(defaultBuffer, valid, buffers.materialCustom);
339 checkValidity(defaultBuffer, valid, buffers.mesh);
340 checkValidity(defaultBuffer, valid, buffers.skinJoint);
341 if (!valid) {
342 CORE_LOG_E(
343 "RN: %s, invalid configuration, not all scene buffers not found.", renderNodeContextMgr.GetName().data());
344 }
345 return buffers;
346 }
347
GetSceneCameraBufferHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName,const BASE_NS::string_view cameraName)348 SceneCameraBufferHandles RenderNodeSceneUtil::GetSceneCameraBufferHandles(
349 RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName,
350 const BASE_NS::string_view cameraName)
351 {
352 SceneCameraBufferHandles buffers;
353 const auto& gpuMgr = renderNodeContextMgr.GetGpuResourceManager();
354 buffers.generalData = gpuMgr.GetBufferHandle(
355 sceneName + DefaultMaterialCameraConstants::CAMERA_GENERAL_BUFFER_PREFIX_NAME + cameraName);
356 buffers.environment = gpuMgr.GetBufferHandle(
357 sceneName + DefaultMaterialCameraConstants::CAMERA_ENVIRONMENT_BUFFER_PREFIX_NAME + cameraName);
358 buffers.fog =
359 gpuMgr.GetBufferHandle(sceneName + DefaultMaterialCameraConstants::CAMERA_FOG_BUFFER_PREFIX_NAME + cameraName);
360 buffers.postProcess = gpuMgr.GetBufferHandle(
361 sceneName + DefaultMaterialCameraConstants::CAMERA_POST_PROCESS_BUFFER_PREFIX_NAME + cameraName);
362
363 buffers.light = gpuMgr.GetBufferHandle(
364 sceneName + DefaultMaterialCameraConstants::CAMERA_LIGHT_BUFFER_PREFIX_NAME + cameraName);
365 buffers.lightCluster = gpuMgr.GetBufferHandle(
366 sceneName + DefaultMaterialCameraConstants::CAMERA_LIGHT_CLUSTER_BUFFER_PREFIX_NAME + cameraName);
367
368 const RenderHandle defaultBuffer = gpuMgr.GetBufferHandle("CORE_DEFAULT_GPU_BUFFER");
369 auto checkValidity = [](const RenderHandle defaultBuffer, bool& valid, RenderHandle& buffer) {
370 if (!RenderHandleUtil::IsValid(buffer)) {
371 valid = false;
372 buffer = defaultBuffer;
373 }
374 };
375 bool valid = true;
376 checkValidity(defaultBuffer, valid, buffers.generalData);
377 checkValidity(defaultBuffer, valid, buffers.environment);
378 checkValidity(defaultBuffer, valid, buffers.fog);
379 checkValidity(defaultBuffer, valid, buffers.postProcess);
380 checkValidity(defaultBuffer, valid, buffers.light);
381 checkValidity(defaultBuffer, valid, buffers.lightCluster);
382 if (!valid) {
383 CORE_LOG_E(
384 "RN: %s, invalid configuration, not all camera buffers found.", renderNodeContextMgr.GetName().data());
385 }
386 return buffers;
387 }
388
GetSceneCameraImageHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName,const BASE_NS::string_view cameraName,const RenderCamera & camera)389 SceneCameraImageHandles RenderNodeSceneUtil::GetSceneCameraImageHandles(
390 RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName,
391 const BASE_NS::string_view cameraName, const RenderCamera& camera)
392 {
393 SceneCameraImageHandles handles;
394 const auto& gpuMgr = renderNodeContextMgr.GetGpuResourceManager();
395 if (camera.flags & RenderCamera::CameraFlagBits::CAMERA_FLAG_DYNAMIC_CUBEMAP_BIT) {
396 handles.radianceCubemap = gpuMgr.GetImageHandle(
397 sceneName + DefaultMaterialCameraConstants::CAMERA_COLOR_PREFIX_NAME + "RADIANCE_CUBEMAP_" + cameraName);
398 }
399 if (!RenderHandleUtil::IsValid(handles.radianceCubemap)) {
400 handles.radianceCubemap = camera.environment.radianceCubemap.GetHandle();
401 }
402 if (!RenderHandleUtil::IsValid(handles.radianceCubemap)) {
403 handles.radianceCubemap =
404 gpuMgr.GetImageHandle(DefaultMaterialGpuResourceConstants::CORE_DEFAULT_RADIANCE_CUBEMAP);
405 }
406 return handles;
407 }
408
GetSceneRenderDataStores(const IRenderNodeContextManager & renderNodeContextMgr,const string_view sceneDataStoreName)409 SceneRenderDataStores RenderNodeSceneUtilImpl::GetSceneRenderDataStores(
410 const IRenderNodeContextManager& renderNodeContextMgr, const string_view sceneDataStoreName)
411 {
412 return RenderNodeSceneUtil::GetSceneRenderDataStores(renderNodeContextMgr, sceneDataStoreName);
413 }
414
CreateViewportFromCamera(const RenderCamera & camera)415 ViewportDesc RenderNodeSceneUtilImpl::CreateViewportFromCamera(const RenderCamera& camera)
416 {
417 return RenderNodeSceneUtil::CreateViewportFromCamera(camera);
418 }
419
CreateScissorFromCamera(const RenderCamera & camera)420 ScissorDesc RenderNodeSceneUtilImpl::CreateScissorFromCamera(const RenderCamera& camera)
421 {
422 return RenderNodeSceneUtil::CreateScissorFromCamera(camera);
423 }
424
UpdateRenderPassFromCamera(const RenderCamera & camera,RenderPass & renderPass)425 void RenderNodeSceneUtilImpl::UpdateRenderPassFromCamera(const RenderCamera& camera, RenderPass& renderPass)
426 {
427 return RenderNodeSceneUtil::UpdateRenderPassFromCamera(camera, renderPass);
428 }
429
UpdateRenderPassFromCustomCamera(const RenderCamera & camera,const bool isNamedCamera,RenderPass & renderPass)430 void RenderNodeSceneUtilImpl::UpdateRenderPassFromCustomCamera(
431 const RenderCamera& camera, const bool isNamedCamera, RenderPass& renderPass)
432 {
433 return RenderNodeSceneUtil::UpdateRenderPassFromCustomCamera(camera, isNamedCamera, renderPass);
434 }
435
GetRenderSlotSubmeshes(const IRenderDataStoreDefaultCamera & dataStoreCamera,const IRenderDataStoreDefaultMaterial & dataStoreMaterial,const uint32_t cameraId,const IRenderNodeSceneUtil::RenderSlotInfo & renderSlotInfo,vector<SlotSubmeshIndex> & refSubmeshIndices)436 void RenderNodeSceneUtilImpl::GetRenderSlotSubmeshes(const IRenderDataStoreDefaultCamera& dataStoreCamera,
437 const IRenderDataStoreDefaultMaterial& dataStoreMaterial, const uint32_t cameraId,
438 const IRenderNodeSceneUtil::RenderSlotInfo& renderSlotInfo, vector<SlotSubmeshIndex>& refSubmeshIndices)
439 {
440 return RenderNodeSceneUtil::GetRenderSlotSubmeshes(
441 dataStoreCamera, dataStoreMaterial, cameraId, renderSlotInfo, refSubmeshIndices);
442 }
443
GetSceneBufferHandles(IRenderNodeContextManager & renderNodeContextMgr,const string_view sceneName)444 SceneBufferHandles RenderNodeSceneUtilImpl::GetSceneBufferHandles(
445 IRenderNodeContextManager& renderNodeContextMgr, const string_view sceneName)
446 {
447 return RenderNodeSceneUtil::GetSceneBufferHandles(renderNodeContextMgr, sceneName);
448 }
449
GetSceneCameraBufferHandles(IRenderNodeContextManager & renderNodeContextMgr,const string_view sceneName,const string_view cameraName)450 SceneCameraBufferHandles RenderNodeSceneUtilImpl::GetSceneCameraBufferHandles(
451 IRenderNodeContextManager& renderNodeContextMgr, const string_view sceneName, const string_view cameraName)
452 {
453 return RenderNodeSceneUtil::GetSceneCameraBufferHandles(renderNodeContextMgr, sceneName, cameraName);
454 }
455
GetSceneCameraImageHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName,const BASE_NS::string_view cameraName,const RenderCamera & camera)456 SceneCameraImageHandles RenderNodeSceneUtilImpl::GetSceneCameraImageHandles(
457 RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName,
458 const BASE_NS::string_view cameraName, const RenderCamera& camera)
459 {
460 return RenderNodeSceneUtil::GetSceneCameraImageHandles(renderNodeContextMgr, sceneName, cameraName, camera);
461 }
462
GetInterface(const Uid & uid) const463 const IInterface* RenderNodeSceneUtilImpl::GetInterface(const Uid& uid) const
464 {
465 if ((uid == IRenderNodeSceneUtil::UID) || (uid == IInterface::UID)) {
466 return this;
467 }
468 return nullptr;
469 }
470
GetInterface(const Uid & uid)471 IInterface* RenderNodeSceneUtilImpl::GetInterface(const Uid& uid)
472 {
473 if ((uid == IRenderNodeSceneUtil::UID) || (uid == IInterface::UID)) {
474 return this;
475 }
476 return nullptr;
477 }
478
Ref()479 void RenderNodeSceneUtilImpl::Ref() {}
480
Unref()481 void RenderNodeSceneUtilImpl::Unref() {}
482 CORE3D_END_NAMESPACE()
483