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 ()__anon34655b370110::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 ()__anon34655b370110::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 |= ((static_cast<uint64_t>(submeshMatData.renderSortHash) & sRenderMask) << sRenderShift);
294             } else {
295                 sortKey = (sortKey << sDepthShift) |
296                     (static_cast<uint64_t>(slotSubmeshMatData[idx].renderSortHash) & sRenderMask);
297             }
298             refSubmeshIndices.push_back(SlotSubmeshIndex { static_cast<uint32_t>(submeshIndex),
299                 submeshMatData.combinedRenderSortLayer, sortKey, submeshMatData.renderSortHash,
300                 submeshMatData.shader.GetHandle(), submeshMatData.gfxState.GetHandle() });
301         }
302     }
303 
304     // front-to-back and by-material render layer sort is 0 -> 63
305     // back-to-front render layer sort is 63 -> 0
306     if (renderSlotInfo.sortType == RenderSlotSortType::FRONT_TO_BACK ||
307         renderSlotInfo.sortType == RenderSlotSortType::BY_MATERIAL) {
308         std::sort(refSubmeshIndices.begin(), refSubmeshIndices.end(), Less<SlotSubmeshIndex>());
309     } else if (renderSlotInfo.sortType == RenderSlotSortType::BACK_TO_FRONT) {
310         std::sort(refSubmeshIndices.begin(), refSubmeshIndices.end(), Greater<SlotSubmeshIndex>());
311     }
312 }
313 
GetSceneBufferHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName)314 SceneBufferHandles RenderNodeSceneUtil::GetSceneBufferHandles(
315     RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName)
316 {
317     SceneBufferHandles buffers;
318     const auto& gpuMgr = renderNodeContextMgr.GetGpuResourceManager();
319     buffers.camera = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialCameraConstants::CAMERA_DATA_BUFFER_NAME);
320     buffers.material = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MATERIAL_DATA_BUFFER_NAME);
321     buffers.materialTransform =
322         gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MATERIAL_TRANSFORM_DATA_BUFFER_NAME);
323     buffers.materialCustom =
324         gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MATERIAL_USER_DATA_BUFFER_NAME);
325     buffers.mesh = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::MESH_DATA_BUFFER_NAME);
326     buffers.skinJoint = gpuMgr.GetBufferHandle(sceneName + DefaultMaterialMaterialConstants::SKIN_DATA_BUFFER_NAME);
327 
328     const RenderHandle defaultBuffer = gpuMgr.GetBufferHandle("CORE_DEFAULT_GPU_BUFFER");
329     auto checkValidity = [](const RenderHandle defaultBuffer, bool& valid, RenderHandle& buffer) {
330         if (!RenderHandleUtil::IsValid(buffer)) {
331             valid = false;
332             buffer = defaultBuffer;
333         }
334     };
335     bool valid = true;
336     checkValidity(defaultBuffer, valid, buffers.camera);
337     checkValidity(defaultBuffer, valid, buffers.material);
338     checkValidity(defaultBuffer, valid, buffers.materialTransform);
339     checkValidity(defaultBuffer, valid, buffers.materialCustom);
340     checkValidity(defaultBuffer, valid, buffers.mesh);
341     checkValidity(defaultBuffer, valid, buffers.skinJoint);
342     if (!valid) {
343         CORE_LOG_E(
344             "RN: %s, invalid configuration, not all scene buffers not found.", renderNodeContextMgr.GetName().data());
345     }
346     return buffers;
347 }
348 
GetSceneCameraBufferHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName,const BASE_NS::string_view cameraName)349 SceneCameraBufferHandles RenderNodeSceneUtil::GetSceneCameraBufferHandles(
350     RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName,
351     const BASE_NS::string_view cameraName)
352 {
353     SceneCameraBufferHandles buffers;
354     const auto& gpuMgr = renderNodeContextMgr.GetGpuResourceManager();
355     buffers.generalData = gpuMgr.GetBufferHandle(
356         sceneName + DefaultMaterialCameraConstants::CAMERA_GENERAL_BUFFER_PREFIX_NAME + cameraName);
357     buffers.environment = gpuMgr.GetBufferHandle(
358         sceneName + DefaultMaterialCameraConstants::CAMERA_ENVIRONMENT_BUFFER_PREFIX_NAME + cameraName);
359     buffers.fog =
360         gpuMgr.GetBufferHandle(sceneName + DefaultMaterialCameraConstants::CAMERA_FOG_BUFFER_PREFIX_NAME + cameraName);
361     buffers.postProcess = gpuMgr.GetBufferHandle(
362         sceneName + DefaultMaterialCameraConstants::CAMERA_POST_PROCESS_BUFFER_PREFIX_NAME + cameraName);
363 
364     buffers.light = gpuMgr.GetBufferHandle(
365         sceneName + DefaultMaterialCameraConstants::CAMERA_LIGHT_BUFFER_PREFIX_NAME + cameraName);
366     buffers.lightCluster = gpuMgr.GetBufferHandle(
367         sceneName + DefaultMaterialCameraConstants::CAMERA_LIGHT_CLUSTER_BUFFER_PREFIX_NAME + cameraName);
368 
369     const RenderHandle defaultBuffer = gpuMgr.GetBufferHandle("CORE_DEFAULT_GPU_BUFFER");
370     auto checkValidity = [](const RenderHandle defaultBuffer, bool& valid, RenderHandle& buffer) {
371         if (!RenderHandleUtil::IsValid(buffer)) {
372             valid = false;
373             buffer = defaultBuffer;
374         }
375     };
376     bool valid = true;
377     checkValidity(defaultBuffer, valid, buffers.generalData);
378     checkValidity(defaultBuffer, valid, buffers.environment);
379     checkValidity(defaultBuffer, valid, buffers.fog);
380     checkValidity(defaultBuffer, valid, buffers.postProcess);
381     checkValidity(defaultBuffer, valid, buffers.light);
382     checkValidity(defaultBuffer, valid, buffers.lightCluster);
383     if (!valid) {
384         CORE_LOG_E(
385             "RN: %s, invalid configuration, not all camera buffers found.", renderNodeContextMgr.GetName().data());
386     }
387     return buffers;
388 }
389 
GetSceneCameraImageHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName,const BASE_NS::string_view cameraName,const RenderCamera & camera)390 SceneCameraImageHandles RenderNodeSceneUtil::GetSceneCameraImageHandles(
391     RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName,
392     const BASE_NS::string_view cameraName, const RenderCamera& camera)
393 {
394     SceneCameraImageHandles handles;
395     const auto& gpuMgr = renderNodeContextMgr.GetGpuResourceManager();
396     if (camera.flags & RenderCamera::CameraFlagBits::CAMERA_FLAG_DYNAMIC_CUBEMAP_BIT) {
397         handles.radianceCubemap = gpuMgr.GetImageHandle(
398             sceneName + DefaultMaterialCameraConstants::CAMERA_COLOR_PREFIX_NAME + "RADIANCE_CUBEMAP_" + cameraName);
399     }
400     if (!RenderHandleUtil::IsValid(handles.radianceCubemap)) {
401         handles.radianceCubemap = camera.environment.radianceCubemap.GetHandle();
402     }
403     if (!RenderHandleUtil::IsValid(handles.radianceCubemap)) {
404         handles.radianceCubemap =
405             gpuMgr.GetImageHandle(DefaultMaterialGpuResourceConstants::CORE_DEFAULT_RADIANCE_CUBEMAP);
406     }
407     return handles;
408 }
409 
GetSceneRenderDataStores(const IRenderNodeContextManager & renderNodeContextMgr,const string_view sceneDataStoreName)410 SceneRenderDataStores RenderNodeSceneUtilImpl::GetSceneRenderDataStores(
411     const IRenderNodeContextManager& renderNodeContextMgr, const string_view sceneDataStoreName)
412 {
413     return RenderNodeSceneUtil::GetSceneRenderDataStores(renderNodeContextMgr, sceneDataStoreName);
414 }
415 
CreateViewportFromCamera(const RenderCamera & camera)416 ViewportDesc RenderNodeSceneUtilImpl::CreateViewportFromCamera(const RenderCamera& camera)
417 {
418     return RenderNodeSceneUtil::CreateViewportFromCamera(camera);
419 }
420 
CreateScissorFromCamera(const RenderCamera & camera)421 ScissorDesc RenderNodeSceneUtilImpl::CreateScissorFromCamera(const RenderCamera& camera)
422 {
423     return RenderNodeSceneUtil::CreateScissorFromCamera(camera);
424 }
425 
UpdateRenderPassFromCamera(const RenderCamera & camera,RenderPass & renderPass)426 void RenderNodeSceneUtilImpl::UpdateRenderPassFromCamera(const RenderCamera& camera, RenderPass& renderPass)
427 {
428     return RenderNodeSceneUtil::UpdateRenderPassFromCamera(camera, renderPass);
429 }
430 
UpdateRenderPassFromCustomCamera(const RenderCamera & camera,const bool isNamedCamera,RenderPass & renderPass)431 void RenderNodeSceneUtilImpl::UpdateRenderPassFromCustomCamera(
432     const RenderCamera& camera, const bool isNamedCamera, RenderPass& renderPass)
433 {
434     return RenderNodeSceneUtil::UpdateRenderPassFromCustomCamera(camera, isNamedCamera, renderPass);
435 }
436 
GetRenderSlotSubmeshes(const IRenderDataStoreDefaultCamera & dataStoreCamera,const IRenderDataStoreDefaultMaterial & dataStoreMaterial,const uint32_t cameraId,const IRenderNodeSceneUtil::RenderSlotInfo & renderSlotInfo,vector<SlotSubmeshIndex> & refSubmeshIndices)437 void RenderNodeSceneUtilImpl::GetRenderSlotSubmeshes(const IRenderDataStoreDefaultCamera& dataStoreCamera,
438     const IRenderDataStoreDefaultMaterial& dataStoreMaterial, const uint32_t cameraId,
439     const IRenderNodeSceneUtil::RenderSlotInfo& renderSlotInfo, vector<SlotSubmeshIndex>& refSubmeshIndices)
440 {
441     return RenderNodeSceneUtil::GetRenderSlotSubmeshes(
442         dataStoreCamera, dataStoreMaterial, cameraId, renderSlotInfo, refSubmeshIndices);
443 }
444 
GetSceneBufferHandles(IRenderNodeContextManager & renderNodeContextMgr,const string_view sceneName)445 SceneBufferHandles RenderNodeSceneUtilImpl::GetSceneBufferHandles(
446     IRenderNodeContextManager& renderNodeContextMgr, const string_view sceneName)
447 {
448     return RenderNodeSceneUtil::GetSceneBufferHandles(renderNodeContextMgr, sceneName);
449 }
450 
GetSceneCameraBufferHandles(IRenderNodeContextManager & renderNodeContextMgr,const string_view sceneName,const string_view cameraName)451 SceneCameraBufferHandles RenderNodeSceneUtilImpl::GetSceneCameraBufferHandles(
452     IRenderNodeContextManager& renderNodeContextMgr, const string_view sceneName, const string_view cameraName)
453 {
454     return RenderNodeSceneUtil::GetSceneCameraBufferHandles(renderNodeContextMgr, sceneName, cameraName);
455 }
456 
GetSceneCameraImageHandles(RENDER_NS::IRenderNodeContextManager & renderNodeContextMgr,const BASE_NS::string_view sceneName,const BASE_NS::string_view cameraName,const RenderCamera & camera)457 SceneCameraImageHandles RenderNodeSceneUtilImpl::GetSceneCameraImageHandles(
458     RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr, const BASE_NS::string_view sceneName,
459     const BASE_NS::string_view cameraName, const RenderCamera& camera)
460 {
461     return RenderNodeSceneUtil::GetSceneCameraImageHandles(renderNodeContextMgr, sceneName, cameraName, camera);
462 }
463 
GetInterface(const Uid & uid) const464 const IInterface* RenderNodeSceneUtilImpl::GetInterface(const Uid& uid) const
465 {
466     if ((uid == IRenderNodeSceneUtil::UID) || (uid == IInterface::UID)) {
467         return this;
468     }
469     return nullptr;
470 }
471 
GetInterface(const Uid & uid)472 IInterface* RenderNodeSceneUtilImpl::GetInterface(const Uid& uid)
473 {
474     if ((uid == IRenderNodeSceneUtil::UID) || (uid == IInterface::UID)) {
475         return this;
476     }
477     return nullptr;
478 }
479 
Ref()480 void RenderNodeSceneUtilImpl::Ref() {}
481 
Unref()482 void RenderNodeSceneUtilImpl::Unref() {}
483 CORE3D_END_NAMESPACE()
484