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 #ifndef CORE__RENDER__NODE__RENDER_NODE_DEFAULT_DEPTH_RENDER_SLOT_H
17 #define CORE__RENDER__NODE__RENDER_NODE_DEFAULT_DEPTH_RENDER_SLOT_H
18 
19 #include <3d/render/intf_render_data_store_default_material.h>
20 #include <base/containers/string.h>
21 #include <base/containers/string_view.h>
22 #include <base/containers/unordered_map.h>
23 #include <base/containers/vector.h>
24 #include <base/math/vector.h>
25 #include <base/util/uid.h>
26 #include <render/device/pipeline_state_desc.h>
27 #include <render/nodecontext/intf_pipeline_descriptor_set_binder.h>
28 #include <render/nodecontext/intf_render_node.h>
29 #include <render/render_data_structures.h>
30 #include <render/resource_handle.h>
31 
32 #include "render/render_node_scene_util.h"
33 
34 CORE3D_BEGIN_NAMESPACE()
35 class IRenderDataStoreDefaultCamera;
36 class IRenderDataStoreDefaultScene;
37 
38 class RenderNodeDefaultDepthRenderSlot final : public RENDER_NS::IRenderNode {
39 public:
40     RenderNodeDefaultDepthRenderSlot() = default;
41     ~RenderNodeDefaultDepthRenderSlot() override = default;
42 
43     void InitNode(RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr) override;
44     void PreExecuteFrame() override;
45     void ExecuteFrame(RENDER_NS::IRenderCommandList& cmdList) override;
GetExecuteFlags()46     ExecuteFlags GetExecuteFlags() const override
47     {
48         return 0U;
49     }
50 
51     struct BufferHandles {
52         RENDER_NS::RenderHandle generalData;
53 
54         RENDER_NS::RenderHandle mesh;
55         RENDER_NS::RenderHandle skinJoint;
56         RENDER_NS::RenderHandle camera;
57 
58         RENDER_NS::RenderHandle defaultBuffer;
59     };
60 
61     struct PerShaderData {
62         RENDER_NS::RenderHandle shaderHandle;
63         RENDER_NS::RenderHandle psoHandle;
64         RENDER_NS::RenderHandle graphicsStateHandle;
65     };
66     struct AllShaderData {
67         BASE_NS::vector<PerShaderData> perShaderData;
68         // shader hash, per shader data index
69         BASE_NS::unordered_map<uint64_t, uint32_t> shaderIdToData;
70 
71         bool slotHasShaders { false };
72         RENDER_NS::RenderHandle defaultShaderHandle;
73         RENDER_NS::RenderHandle defaultStateHandle;
74         RENDER_NS::RenderHandle defaultPlHandle;
75         RENDER_NS::RenderHandle defaultVidHandle;
76         RENDER_NS::PipelineLayout defaultPipelineLayout;
77         BASE_NS::vector<RENDER_NS::ShaderSpecialization::Constant> defaultSpecilizationConstants;
78     };
79 
80     // for plugin / factory interface
81     static constexpr BASE_NS::Uid UID { "fd9f70bc-e13c-4a02-a6b9-c45eed50d8f9" };
82     static constexpr char const* const TYPE_NAME = "RenderNodeDefaultDepthRenderSlot";
83     static constexpr IRenderNode::BackendFlags BACKEND_FLAGS = IRenderNode::BackendFlagBits::BACKEND_FLAG_BITS_DEFAULT;
84     static constexpr IRenderNode::ClassType CLASS_TYPE = IRenderNode::ClassType::CLASS_TYPE_NODE;
85     static IRenderNode* Create();
86     static void Destroy(IRenderNode* instance);
87 
88 private:
89     RENDER_NS::IRenderNodeContextManager* renderNodeContextMgr_ { nullptr };
90 
91     static constexpr uint64_t INVALID_CAM_ID { 0xFFFFFFFFffffffff };
92     struct JsonInputs {
93         RENDER_NS::RenderNodeGraphInputs::RenderDataStore renderDataStore;
94 
95         BASE_NS::string customCameraName;
96         uint64_t customCameraId { INVALID_CAM_ID };
97 
98         RENDER_NS::RenderSlotSortType sortType { RENDER_NS::RenderSlotSortType::NONE };
99         RENDER_NS::RenderSlotCullType cullType { RENDER_NS::RenderSlotCullType::NONE };
100 
101         uint32_t nodeFlags { 0u };
102         uint32_t renderSlotId { 0u };
103         uint32_t shaderRenderSlotId { 0u };
104         uint32_t stateRenderSlotId { 0u };
105         bool explicitShader { false };
106         RenderSubmeshFlags nodeSubmeshExtraFlags { 0 };
107         RenderMaterialFlags nodeMaterialDiscardFlags { 0 };
108 
109         RENDER_NS::RenderNodeGraphInputs::InputRenderPass renderPass;
110         bool hasChangeableRenderPassHandles { false };
111     };
112     JsonInputs jsonInputs_;
113     RENDER_NS::RenderNodeHandles::InputRenderPass inputRenderPass_;
114 
115     struct ShaderStateData {
116         RENDER_NS::RenderHandle shader;
117         RENDER_NS::RenderHandle gfxState;
118         uint64_t hash { 0 };
119     };
120     struct ObjectCounts {
121         uint32_t maxSlotMeshCount { 0u };
122         uint32_t maxSlotSubmeshCount { 0u };
123         uint32_t maxSlotSkinCount { 0u };
124     };
125     struct CurrentScene {
126         RenderCamera camera;
127         RENDER_NS::ViewportDesc viewportDesc;
128         RENDER_NS::ScissorDesc scissorDesc;
129         uint32_t cameraIdx { 0u };
130     };
131     struct SpecializationData {
132         static constexpr uint32_t MAX_FLAG_COUNT { 16u };
133         uint32_t flags[MAX_FLAG_COUNT];
134 
135         uint32_t maxSpecializationCount { 0u };
136     };
137 
138     void ParseRenderNodeInputs();
139     void RenderSubmeshes(RENDER_NS::IRenderCommandList& cmdList,
140         const IRenderDataStoreDefaultMaterial& dataStoreMaterial, const IRenderDataStoreDefaultCamera& dataStoreCamera);
141     void UpdateSet01(RENDER_NS::IRenderCommandList& cmdList);
142     void CreateDefaultShaderData();
143     // unique scene name as input
144     void GetSceneUniformBuffers(const BASE_NS::string_view us);
145     void GetCameraUniformBuffers(const BASE_NS::string_view us);
146     RENDER_NS::RenderHandle CreateNewPso(const ShaderStateData& ssd,
147         const RenderDataDefaultMaterial::SubmeshMaterialFlags& submeshMaterialFlags,
148         const RenderSubmeshFlags submeshFlags);
149     void ProcessSlotSubmeshes(
150         const IRenderDataStoreDefaultCamera& dataStoreCamera, const IRenderDataStoreDefaultMaterial& dataStoreMaterial);
151     void UpdateCurrentScene(
152         const IRenderDataStoreDefaultScene& dataStoreScene, const IRenderDataStoreDefaultCamera& dataStoreCamera);
153     void ProcessBuffersAndDescriptors(const ObjectCounts& objectCounts);
154     void ResetAndUpdateDescriptorSets();
155 
156     RENDER_NS::RenderHandle GetSubmeshPso(const ShaderStateData& ssd,
157         const RenderDataDefaultMaterial::SubmeshMaterialFlags& submeshMaterialFlags,
158         const RenderSubmeshFlags submeshFlags);
159     RENDER_NS::ShaderSpecializationConstantDataView GetShaderSpecializationView(
160         const RENDER_NS::GraphicsState& gfxState,
161         const RenderDataDefaultMaterial::SubmeshMaterialFlags& submeshMaterialFlags,
162         const RenderSubmeshFlags submeshFlags);
163 
164     CurrentScene currentScene_;
165     SceneRenderDataStores stores_;
166 
167     ObjectCounts objectCounts_;
168     BufferHandles buffers_;
169 
170     struct AllDescriptorSets {
171         static constexpr uint32_t SINGLE_SET_COUNT { 2u };
172         RENDER_NS::IDescriptorSetBinder::Ptr set01[SINGLE_SET_COUNT];
173     };
174     AllDescriptorSets allDescriptorSets_;
175     AllShaderData allShaderData_;
176     SpecializationData specializationData_;
177 
178     RENDER_NS::RenderPass renderPass_;
179     // the base default render node graph from RNG setup
180     RENDER_NS::RenderPass rngRenderPass_;
181 
182     RENDER_NS::RenderPostProcessConfiguration currentRenderPPConfiguration_;
183     BASE_NS::vector<SlotSubmeshIndex> sortedSlotSubmeshes_;
184 };
185 CORE3D_END_NAMESPACE()
186 
187 #endif // CORE__RENDER__NODE__RENDER_NODE_DEFAULT_DEPTH_RENDER_SLOT_H
188