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_create_default_camera_gpu_images.h"
17 
18 #include <3d/render/intf_render_data_store_default_camera.h>
19 #include <core/log.h>
20 #include <core/namespace.h>
21 #include <render/datastore/intf_render_data_store.h>
22 #include <render/datastore/intf_render_data_store_manager.h>
23 #include <render/device/intf_gpu_resource_manager.h>
24 #include <render/nodecontext/intf_node_context_pso_manager.h>
25 #include <render/nodecontext/intf_render_command_list.h>
26 #include <render/nodecontext/intf_render_node_context_manager.h>
27 #include <render/nodecontext/intf_render_node_graph_share_manager.h>
28 #include <render/nodecontext/intf_render_node_parser_util.h>
29 #include <render/render_data_structures.h>
30 
31 CORE3D_BEGIN_NAMESPACE()
32 using namespace BASE_NS;
33 using namespace RENDER_NS;
34 
InitNode(IRenderNodeContextManager & renderNodeContextMgr)35 void RenderNodeCreateDefaultCameraGpuImages::InitNode(IRenderNodeContextManager& renderNodeContextMgr)
36 {
37     renderNodeContextMgr_ = &renderNodeContextMgr;
38     ParseRenderNodeInputs();
39 
40     const auto& renderNodeGraphData = renderNodeContextMgr_->GetRenderNodeGraphData();
41     stores_ = RenderNodeSceneUtil::GetSceneRenderDataStores(
42         renderNodeContextMgr, renderNodeGraphData.renderNodeGraphDataStoreName);
43 
44     if (jsonInputs_.gpuImageDescs.empty()) {
45         CORE_LOG_W("RenderNodeCreateDefaultCameraGpuImages: No gpu image descs given to");
46     }
47 
48     descs_.reserve(jsonInputs_.gpuImageDescs.size());
49     resourceHandles_.reserve(jsonInputs_.gpuImageDescs.size());
50 
51     auto& gpuResourceMgr = renderNodeContextMgr.GetGpuResourceManager();
52     for (const auto& ref : jsonInputs_.gpuImageDescs) {
53         descs_.push_back(ref);
54 
55         GpuImageDesc desc = ref.desc;
56         desc.width = Math::max(1u, static_cast<uint32_t>(static_cast<float>(desc.width) * ref.dependencySizeScale));
57         desc.height = Math::max(1u, static_cast<uint32_t>(static_cast<float>(desc.height) * ref.dependencySizeScale));
58         resourceHandles_.push_back(gpuResourceMgr.Create(ref.name, desc));
59     }
60     // broadcast the resources
61     for (size_t idx = 0; idx < resourceHandles_.size(); ++idx) {
62         IRenderNodeGraphShareManager& rngShareMgr = renderNodeContextMgr_->GetRenderNodeGraphShareManager();
63         rngShareMgr.RegisterRenderNodeOutput(descs_[idx].shareName, resourceHandles_[idx].GetHandle());
64     }
65 }
66 
PreExecuteFrame()67 void RenderNodeCreateDefaultCameraGpuImages::PreExecuteFrame()
68 {
69     CORE_ASSERT(resourceHandles_.size() == descs_.size());
70     auto& gpuResourceMgr = renderNodeContextMgr_->GetGpuResourceManager();
71     const auto& renderDataStoreMgr = renderNodeContextMgr_->GetRenderDataStoreManager();
72     const auto* dataStoreCamera =
73         static_cast<IRenderDataStoreDefaultCamera*>(renderDataStoreMgr.GetRenderDataStore(stores_.dataStoreNameCamera));
74     if (dataStoreCamera) {
75         const auto& cameras = dataStoreCamera->GetCameras();
76         if (!cameras.empty() && !descs_.empty()) {
77             for (size_t idx = 0; idx < descs_.size(); ++idx) {
78                 // If no camera given, we default to zero camera (main camera)
79                 uint32_t cameraIndex = 0u;
80                 if (jsonInputs_.customCameraId != INVALID_CAM_ID) {
81                     cameraIndex = dataStoreCamera->GetCameraIndex(jsonInputs_.customCameraId);
82                 } else if (!(jsonInputs_.customCameraName.empty())) {
83                     cameraIndex = dataStoreCamera->GetCameraIndex(jsonInputs_.customCameraName);
84                 }
85                 if (cameraIndex < (uint32_t)cameras.size()) {
86                     const auto& currCamera = cameras[cameraIndex];
87                     auto& currDesc = descs_[idx];
88                     const bool xChanged = (currCamera.renderResolution.x != currDesc.desc.width) ? true : false;
89                     const bool yChanged = (currCamera.renderResolution.y != currDesc.desc.height) ? true : false;
90 
91                     if (xChanged || yChanged) {
92                         currDesc.desc.width = currCamera.renderResolution.x;
93                         currDesc.desc.height = currCamera.renderResolution.y;
94                         // additional copy
95                         GpuImageDesc desc = currDesc.desc;
96                         desc.width = Math::max(
97                             1u, static_cast<uint32_t>(static_cast<float>(desc.width) * currDesc.dependencySizeScale));
98                         desc.height = Math::max(
99                             1u, static_cast<uint32_t>(static_cast<float>(desc.height) * currDesc.dependencySizeScale));
100                         // replace the handle
101                         resourceHandles_[idx] = gpuResourceMgr.Create(resourceHandles_[idx], desc);
102                     }
103                 }
104             }
105         }
106     }
107     // broadcast the resources
108     for (size_t idx = 0; idx < resourceHandles_.size(); ++idx) {
109         IRenderNodeGraphShareManager& rngShareMgr = renderNodeContextMgr_->GetRenderNodeGraphShareManager();
110         rngShareMgr.RegisterRenderNodeOutput(descs_[idx].shareName, resourceHandles_[idx].GetHandle());
111     }
112 }
113 
ParseRenderNodeInputs()114 void RenderNodeCreateDefaultCameraGpuImages::ParseRenderNodeInputs()
115 {
116     const IRenderNodeParserUtil& parserUtil = renderNodeContextMgr_->GetRenderNodeParserUtil();
117     const auto jsonVal = renderNodeContextMgr_->GetNodeJson();
118     jsonInputs_.gpuImageDescs = parserUtil.GetGpuImageDescs(jsonVal, "gpuImageDescs");
119     jsonInputs_.customCameraName = parserUtil.GetStringValue(jsonVal, "customCameraName");
120     jsonInputs_.customCameraId = parserUtil.GetUintValue(jsonVal, "customCameraId");
121 }
122 
123 // for plugin / factory interface
Create()124 RENDER_NS::IRenderNode* RenderNodeCreateDefaultCameraGpuImages::Create()
125 {
126     return new RenderNodeCreateDefaultCameraGpuImages();
127 }
128 
Destroy(IRenderNode * instance)129 void RenderNodeCreateDefaultCameraGpuImages::Destroy(IRenderNode* instance)
130 {
131     delete static_cast<RenderNodeCreateDefaultCameraGpuImages*>(instance);
132 }
133 CORE3D_END_NAMESPACE()
134