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_MATERIAL_RENDER_SLOT_H
17 #define CORE__RENDER__NODE__RENDER_NODE_DEFAULT_MATERIAL_RENDER_SLOT_H
18 
19 #include <3d/render/intf_render_data_store_default_light.h>
20 #include <3d/render/intf_render_data_store_default_material.h>
21 #include <base/containers/string.h>
22 #include <base/containers/string_view.h>
23 #include <base/containers/unordered_map.h>
24 #include <base/containers/vector.h>
25 #include <base/math/vector.h>
26 #include <base/util/uid.h>
27 #include <core/namespace.h>
28 #include <render/datastore/render_data_store_render_pods.h>
29 #include <render/device/pipeline_state_desc.h>
30 #include <render/nodecontext/intf_pipeline_descriptor_set_binder.h>
31 #include <render/nodecontext/intf_render_node.h>
32 #include <render/render_data_structures.h>
33 #include <render/resource_handle.h>
34 
35 #include "render/render_node_scene_util.h"
36 
37 CORE3D_BEGIN_NAMESPACE()
38 class IRenderDataStoreDefaultCamera;
39 class IRenderDataStoreDefaultScene;
40 
41 class RenderNodeDefaultMaterialRenderSlot final : public RENDER_NS::IRenderNode {
42 public:
43     RenderNodeDefaultMaterialRenderSlot() = default;
44     ~RenderNodeDefaultMaterialRenderSlot() override = default;
45 
46     void InitNode(RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr) override;
47     void PreExecuteFrame() override;
48     void ExecuteFrame(RENDER_NS::IRenderCommandList& cmdList) override;
GetExecuteFlags()49     ExecuteFlags GetExecuteFlags() const override
50     {
51         // render pass always open
52         return 0U;
53     }
54 
55     struct MaterialHandleStruct {
56         RENDER_NS::BindableImage resources[RenderDataDefaultMaterial::MATERIAL_TEXTURE_COUNT];
57     };
58 
59     struct ShadowBuffers {
60         RENDER_NS::RenderHandle depthHandle;
61         RENDER_NS::RenderHandle vsmColorHandle;
62 
63         RENDER_NS::RenderHandle pcfSamplerHandle;
64         RENDER_NS::RenderHandle vsmSamplerHandle;
65     };
66 
67     struct BufferHandles {
68         RENDER_NS::RenderHandle mat;
69         RENDER_NS::RenderHandle matTransform;
70         RENDER_NS::RenderHandle matCustom;
71         RENDER_NS::RenderHandle mesh;
72         RENDER_NS::RenderHandle skinJoint;
73         RENDER_NS::RenderHandle environment;
74         RENDER_NS::RenderHandle fog;
75         RENDER_NS::RenderHandle generalData;
76         RENDER_NS::RenderHandle postProcess;
77 
78         RENDER_NS::RenderHandle camera;
79         RENDER_NS::RenderHandle light;
80         RENDER_NS::RenderHandle lightCluster;
81 
82         RENDER_NS::RenderHandle defaultBuffer;
83     };
84 
85     struct PerShaderData {
86         RENDER_NS::RenderHandle shaderHandle;
87         RENDER_NS::RenderHandle psoHandle;
88         RENDER_NS::RenderHandle graphicsStateHandle;
89         bool needsCustomSetBindings { false };
90     };
91     struct AllShaderData {
92         BASE_NS::vector<PerShaderData> perShaderData;
93         // shader hash, per shader data index
94         BASE_NS::unordered_map<uint64_t, uint32_t> shaderIdToData;
95 
96         bool slotHasShaders { false };
97         RENDER_NS::RenderHandle defaultShaderHandle;
98         RENDER_NS::RenderHandle defaultStateHandle;
99         RENDER_NS::RenderHandle defaultPlHandle;
100         RENDER_NS::RenderHandle defaultVidHandle;
101         RENDER_NS::PipelineLayout defaultPipelineLayout;
102         BASE_NS::vector<RENDER_NS::ShaderSpecialization::Constant> defaultSpecilizationConstants;
103     };
104 
105     // for plugin / factory interface
106     static constexpr BASE_NS::Uid UID { "80758e28-f064-45e6-878d-624652598405" };
107     static constexpr char const* const TYPE_NAME = "RenderNodeDefaultMaterialRenderSlot";
108     static constexpr IRenderNode::BackendFlags BACKEND_FLAGS = IRenderNode::BackendFlagBits::BACKEND_FLAG_BITS_DEFAULT;
109     static constexpr IRenderNode::ClassType CLASS_TYPE = IRenderNode::ClassType::CLASS_TYPE_NODE;
110     static IRenderNode* Create();
111     static void Destroy(IRenderNode* instance);
112 
113 private:
114     RENDER_NS::IRenderNodeContextManager* renderNodeContextMgr_ { nullptr };
115 
116     static constexpr uint64_t INVALID_CAM_ID { 0xFFFFFFFFffffffff };
117     struct JsonInputs {
118         RENDER_NS::RenderNodeGraphInputs::RenderDataStore renderDataStore;
119 
120         BASE_NS::string customCameraName;
121         uint64_t customCameraId { INVALID_CAM_ID };
122 
123         RENDER_NS::RenderSlotSortType sortType { RENDER_NS::RenderSlotSortType::NONE };
124         RENDER_NS::RenderSlotCullType cullType { RENDER_NS::RenderSlotCullType::NONE };
125 
126         RenderSceneFlags nodeFlags { 0u };
127         uint32_t renderSlotId { 0u };
128         uint32_t shaderRenderSlotId { 0u };
129         uint32_t stateRenderSlotId { 0u };
130         uint32_t shaderRenderSlotBaseId { 0u };
131         uint32_t shaderRenderSlotMultiviewId { 0u };
132         bool initialExplicitShader { false };
133         bool explicitShader { false };
134         RenderSubmeshFlags nodeSubmeshExtraFlags { 0 };
135         RenderMaterialFlags nodeMaterialDiscardFlags { 0 };
136 
137         RENDER_NS::RenderNodeGraphInputs::InputRenderPass renderPass;
138         bool hasChangeableRenderPassHandles { false };
139     };
140     JsonInputs jsonInputs_;
141     RENDER_NS::RenderNodeHandles::InputRenderPass inputRenderPass_;
142 
143     struct ShaderStateData {
144         RENDER_NS::RenderHandle shader;
145         RENDER_NS::RenderHandle gfxState;
146         uint64_t hash { 0 };
147     };
148     struct ObjectCounts {
149         uint32_t maxSlotMeshCount { 0u };
150         uint32_t maxSlotSubmeshCount { 0u };
151         uint32_t maxSlotSkinCount { 0u };
152         uint32_t maxSlotMaterialCount { 0u };
153     };
154     struct CurrentScene {
155         RenderCamera camera;
156         RENDER_NS::RenderHandle cameraEnvRadianceHandle;
157         RENDER_NS::ViewportDesc viewportDesc;
158         RENDER_NS::ScissorDesc scissorDesc;
159 
160         RENDER_NS::RenderHandle prePassColorTarget;
161 
162         bool hasShadow { false };
163         uint32_t cameraIdx { 0u };
164         IRenderDataStoreDefaultLight::ShadowTypes shadowTypes {};
165         IRenderDataStoreDefaultLight::LightingFlags lightingFlags { 0u };
166         RenderCamera::ShaderFlags cameraShaderFlags { 0u }; // evaluated based on camera and scene flags
167     };
168     struct SpecializationData {
169         static constexpr uint32_t MAX_FLAG_COUNT { 16u };
170         uint32_t flags[MAX_FLAG_COUNT];
171 
172         uint32_t maxSpecializationCount { 0u };
173     };
174     struct PsoAndInfo {
175         RENDER_NS::RenderHandle pso;
176         bool set3 { false };
177     };
178 
179     void ParseRenderNodeInputs();
180     void RenderSubmeshes(RENDER_NS::IRenderCommandList& cmdList,
181         const IRenderDataStoreDefaultMaterial& dataStoreMaterial, const IRenderDataStoreDefaultCamera& dataStoreCamera);
182     void UpdateSet01(RENDER_NS::IRenderCommandList& cmdList);
183     void UpdateAndBindSet2(
184         RENDER_NS::IRenderCommandList& cmdList, const MaterialHandleStruct& materialHandles, const uint32_t objIdx);
185     bool UpdateAndBindSet3(RENDER_NS::IRenderCommandList& cmdList,
186         const RenderDataDefaultMaterial::CustomResourceData& customResourceData);
187     void CreateDefaultShaderData();
188     // unique scene name as input
189     void GetSceneUniformBuffers(const BASE_NS::string_view us);
190     PsoAndInfo CreateNewPso(const ShaderStateData& ssd,
191         const RenderDataDefaultMaterial::SubmeshMaterialFlags& submeshMaterialFlags,
192         const RenderSubmeshFlags submeshFlags, const IRenderDataStoreDefaultLight::LightingFlags lightingFlags,
193         const RenderCamera::ShaderFlags cameraShaderFlags);
194     void ProcessSlotSubmeshes(
195         const IRenderDataStoreDefaultCamera& dataStoreCamera, const IRenderDataStoreDefaultMaterial& dataStoreMaterial);
196     void UpdateCurrentScene(const IRenderDataStoreDefaultScene& dataStoreScene,
197         const IRenderDataStoreDefaultCamera& dataStoreCamera, const IRenderDataStoreDefaultLight& dataStoreLight);
198     void ProcessBuffersAndDescriptors(const ObjectCounts& objectCounts);
199     void ResetAndUpdateDescriptorSets();
200 
201     void UpdatePostProcessConfiguration();
202     PsoAndInfo GetSubmeshPso(const ShaderStateData& ssd,
203         const RenderDataDefaultMaterial::SubmeshMaterialFlags& submeshMaterialFlags,
204         const RenderSubmeshFlags submeshFlags, const IRenderDataStoreDefaultLight::LightingFlags lightingFlags,
205         const RenderCamera::ShaderFlags cameraShaderFlags);
206     RENDER_NS::ShaderSpecializationConstantDataView GetShaderSpecializationView(
207         const RENDER_NS::GraphicsState& gfxState,
208         const RenderDataDefaultMaterial::SubmeshMaterialFlags& submeshMaterialFlags,
209         const RenderSubmeshFlags submeshFlags, const IRenderDataStoreDefaultLight::LightingFlags lightingFlags,
210         const RenderCamera::ShaderFlags cameraShaderFlags);
211     BASE_NS::array_view<const RENDER_NS::DynamicStateEnum> GetDynamicStates() const;
212     void EvaluateFogBits();
213     void ResetRenderSlotData(const uint32_t shaderRenderSlotId, const bool multiView);
214 
215     MaterialHandleStruct defaultMaterialStruct_;
216 
217     CurrentScene currentScene_;
218     SceneRenderDataStores stores_;
219 
220     ObjectCounts objectCounts_;
221 
222     SceneBufferHandles sceneBuffers_;
223     SceneCameraBufferHandles cameraBuffers_;
224     ShadowBuffers shadowBuffers_;
225 
226     struct DefaultSamplers {
227         RENDER_NS::RenderHandle cubemapHandle;
228 
229         RENDER_NS::RenderHandle linearHandle;
230         RENDER_NS::RenderHandle nearestHandle;
231         RENDER_NS::RenderHandle linearMipHandle;
232     };
233     DefaultSamplers defaultSamplers_;
234 
235     RENDER_NS::RenderHandle defaultColorPrePassHandle_;
236 
237     struct AllDescriptorSets {
238         static constexpr uint32_t SINGLE_SET_COUNT { 2u };
239         RENDER_NS::IDescriptorSetBinder::Ptr set01[SINGLE_SET_COUNT];
240         BASE_NS::vector<RENDER_NS::IDescriptorSetBinder::Ptr> sets2;
241     };
242     AllDescriptorSets allDescriptorSets_;
243     AllShaderData allShaderData_;
244     SpecializationData specializationData_;
245 
246     RENDER_NS::RenderPass renderPass_;
247     // the base default render node graph from RNG setup
248     RENDER_NS::RenderPass rngRenderPass_;
249     bool fsrEnabled_ { false };
250 
251     RENDER_NS::RenderPostProcessConfiguration currentRenderPPConfiguration_;
252     BASE_NS::vector<SlotSubmeshIndex> sortedSlotSubmeshes_;
253 };
254 CORE3D_END_NAMESPACE()
255 
256 #endif // CORE__RENDER__NODE__RENDER_NODE_DEFAULT_MATERIAL_RENDER_SLOT_H
257