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_SHADOW_RENDER_SLOT_H
17 #define CORE__RENDER__NODE__RENDER_NODE_DEFAULT_SHADOW_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 <3d/render/render_data_defines_3d.h>
22 #include <base/containers/unordered_map.h>
23 #include <base/containers/vector.h>
24 #include <base/util/formats.h>
25 #include <base/util/uid.h>
26 #include <core/namespace.h>
27 #include <render/device/pipeline_state_desc.h>
28 #include <render/nodecontext/intf_pipeline_descriptor_set_binder.h>
29 #include <render/nodecontext/intf_render_node.h>
30 #include <render/render_data_structures.h>
31 #include <render/resource_handle.h>
32 
33 #include "render/render_node_scene_util.h"
34 
35 CORE3D_BEGIN_NAMESPACE()
36 class IRenderDataStoreDefaultCamera;
37 class IRenderDataStoreDefaultScene;
38 
39 class RenderNodeDefaultShadowRenderSlot final : public RENDER_NS::IRenderNode {
40 public:
41     RenderNodeDefaultShadowRenderSlot() = default;
42     ~RenderNodeDefaultShadowRenderSlot() override = default;
43 
44     void InitNode(RENDER_NS::IRenderNodeContextManager& renderNodeContextMgr) override;
45     void PreExecuteFrame() override;
46     void ExecuteFrame(RENDER_NS::IRenderCommandList& cmdList) override;
47     ExecuteFlags GetExecuteFlags() const override;
48 
49     struct ShadowBuffers {
50         BASE_NS::string depthName;
51         BASE_NS::string vsmColorName;
52 
53         RENDER_NS::RenderHandleReference depthHandle;
54         RENDER_NS::RenderHandleReference vsmColorHandle;
55 
56         BASE_NS::Format depthFormat { BASE_NS::Format::BASE_FORMAT_D16_UNORM };
57         BASE_NS::Format colorFormat { BASE_NS::Format::BASE_FORMAT_R16G16_UNORM };
58 
59         // full size of atlas
60         uint32_t width { 2u };
61         uint32_t height { 2u };
62 
63         IRenderDataStoreDefaultLight::ShadowTypes shadowTypes {};
64     };
65 
66     struct ShaderStateData {
67         RENDER_NS::RenderHandle shader;
68         RENDER_NS::RenderHandle gfxState;
69         uint64_t hash { 0 };
70         RENDER_NS::RenderHandle defaultShader;
71         RENDER_NS::RenderHandle defaultShaderState;
72     };
73     struct ShadowTypeShaders {
74         RENDER_NS::RenderHandle basic;
75         RENDER_NS::RenderHandle basicState;
76     };
77 
78     // for plugin / factory interface
79     static constexpr BASE_NS::Uid UID { "ce5b861e-09a0-4dfa-84f1-c1a9986f1fdf" };
80     static constexpr char const* const TYPE_NAME = "RenderNodeDefaultShadowRenderSlot";
81     static constexpr IRenderNode::BackendFlags BACKEND_FLAGS = IRenderNode::BackendFlagBits::BACKEND_FLAG_BITS_DEFAULT;
82     static constexpr IRenderNode::ClassType CLASS_TYPE = IRenderNode::ClassType::CLASS_TYPE_NODE;
83     static IRenderNode* Create();
84     static void Destroy(IRenderNode* instance);
85 
86 private:
87     RENDER_NS::IRenderNodeContextManager* renderNodeContextMgr_ { nullptr };
88 
89     struct ObjectCounts {
90         uint32_t maxSlotMeshCount { 0u };
91         uint32_t maxSlotSubmeshCount { 0u };
92         uint32_t maxSlotSkinCount { 0u };
93         uint32_t maxSlotMaterialCount { 0u };
94     };
95     struct UboHandles {
96         RENDER_NS::RenderHandleReference generalData;
97 
98         RENDER_NS::RenderHandle mesh;
99         RENDER_NS::RenderHandle skinJoint;
100         RENDER_NS::RenderHandle camera;
101     };
102 
103     void ParseRenderNodeInputs();
104     void RenderSubmeshes(RENDER_NS::IRenderCommandList& cmdList,
105         const IRenderDataStoreDefaultMaterial& dataStoreMaterial,
106         const IRenderDataStoreDefaultLight::ShadowType shadowType, const RenderCamera& camera, const RenderLight& light,
107         const uint32_t shadowPassIdx);
108     void UpdateSet01(RENDER_NS::IRenderCommandList& cmdList, const uint32_t shadowPassIdx);
109 
110     void UpdateGeneralDataUniformBuffers(const IRenderDataStoreDefaultLight& dataStoreLight);
111     void CreateDefaultShaderData();
112     RENDER_NS::RenderHandle CreateNewPso(const ShaderStateData& ssd,
113         const RENDER_NS::ShaderSpecializationConstantDataView& specialization, const RenderSubmeshFlags submeshFlags);
114     RENDER_NS::RenderPass CreateRenderPass(const ShadowBuffers& buffers);
115     void ProcessSlotSubmeshes(const IRenderDataStoreDefaultCamera& dataStoreCamera,
116         const IRenderDataStoreDefaultMaterial& dataStoreMaterial, const uint32_t shadowCameraIdx);
117     void ProcessBuffersAndDescriptors(const ObjectCounts& objectCounts);
118     void UpdateCurrentScene(
119         const IRenderDataStoreDefaultScene& dataStoreScene, const IRenderDataStoreDefaultLight& dataStoreLight);
120 
121     RENDER_NS::RenderHandle GetSubmeshPso(const ShaderStateData& ssd,
122         const RenderDataDefaultMaterial::SubmeshMaterialFlags& submeshMaterialFlags,
123         const RenderSubmeshFlags submeshFlags);
124 
125     struct JsonInputs {
126         RENDER_NS::RenderSlotSortType sortType { RENDER_NS::RenderSlotSortType::NONE };
127         RENDER_NS::RenderSlotCullType cullType { RENDER_NS::RenderSlotCullType::NONE };
128 
129         uint32_t nodeFlags { 0u };
130         uint32_t renderSlotId { 0u };
131         uint32_t renderSlotVsmId { 0u };
132     };
133     JsonInputs jsonInputs_;
134 
135     struct CurrentScene {
136         BASE_NS::Math::UVec2 res { 0u, 0u };
137         RENDER_NS::ViewportDesc viewportDesc;
138         RENDER_NS::ScissorDesc scissorDesc;
139         BASE_NS::Math::Vec4 sceneTimingData { 0.0f, 0.0f, 0.0f, 0.0f };
140 
141         uint32_t renderSlotId { ~0u };
142     };
143     CurrentScene currentScene_;
144 
145     SceneRenderDataStores stores_;
146     ShadowBuffers shadowBuffers_;
147     ObjectCounts objectCounts_;
148 
149     struct AllDescriptorSets {
150         RENDER_NS::IDescriptorSetBinder::Ptr set0[DefaultMaterialLightingConstants::MAX_SHADOW_COUNT];
151         RENDER_NS::IDescriptorSetBinder::Ptr set1[DefaultMaterialLightingConstants::MAX_SHADOW_COUNT];
152     };
153     AllDescriptorSets allDescriptorSets_;
154 
155     ShadowTypeShaders pcfShaders_;
156     ShadowTypeShaders vsmShaders_;
157 
158     struct PerShaderData {
159         RENDER_NS::RenderHandle shaderHandle;
160         RENDER_NS::RenderHandle psoHandle;
161         RENDER_NS::RenderHandle stateHandle;
162     };
163     struct AllShaderData {
164         BASE_NS::vector<PerShaderData> perShaderData;
165         // shader hash, per shader data index
166         BASE_NS::unordered_map<uint64_t, uint32_t> shaderIdToData;
167 
168         bool slotHasShaders { false };
169         RENDER_NS::RenderHandle defaultPlHandle;
170         RENDER_NS::RenderHandle defaultVidHandle;
171         RENDER_NS::PipelineLayout defaultPipelineLayout;
172         BASE_NS::vector<RENDER_NS::ShaderSpecialization::Constant> defaultSpecilizationConstants;
173     };
174     AllShaderData allShaderData_;
175 
176     UboHandles uboHandles_;
177 
178     RENDER_NS::RenderPass renderPass_;
179     BASE_NS::vector<SlotSubmeshIndex> sortedSlotSubmeshes_;
180 
181     bool validShadowNode_ { true };
182     uint32_t shadowCount_ { 0U };
183 };
184 CORE3D_END_NAMESPACE()
185 
186 #endif // CORE__RENDER__NODE__RENDER_NODE_DEFAULT_SHADOW_RENDER_SLOT_H
187