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 RENDER_NODECONTEXT_RENDER_NODE_POST_PROCESS_UTIL_H 17 #define RENDER_NODECONTEXT_RENDER_NODE_POST_PROCESS_UTIL_H 18 19 #include <cstdint> 20 21 #include <base/containers/array_view.h> 22 #include <render/datastore/render_data_store_render_pods.h> 23 #include <render/device/intf_shader_manager.h> 24 #include <render/device/pipeline_state_desc.h> 25 #include <render/namespace.h> 26 #include <render/nodecontext/intf_pipeline_descriptor_set_binder.h> 27 #include <render/nodecontext/intf_render_node_post_process_util.h> 28 #include <render/nodecontext/intf_render_post_process.h> 29 #include <render/nodecontext/intf_render_post_process_node.h> 30 #include <render/render_data_structures.h> 31 32 #include "node/render_bloom.h" 33 #include "node/render_blur.h" 34 #include "node/render_motion_blur.h" 35 #include "nodecontext/render_node_copy_util.h" 36 37 RENDER_BEGIN_NAMESPACE() 38 struct RenderableList; 39 struct PipelineLayout; 40 class IRenderNodeContextManager; 41 class IRenderNodeCommandList; 42 43 class RenderNodePostProcessUtil final { 44 public: 45 RenderNodePostProcessUtil() = default; 46 ~RenderNodePostProcessUtil() = default; 47 48 void Init(IRenderNodeContextManager& renderNodeContextMgr, 49 const IRenderNodePostProcessUtil::PostProcessInfo& postProcessInfo); 50 void PreExecute(const IRenderNodePostProcessUtil::PostProcessInfo& postProcessInfo); 51 void Execute(IRenderCommandList& cmdList); 52 53 private: 54 IRenderNodeContextManager* renderNodeContextMgr_; 55 56 void ParseRenderNodeInputs(); 57 void UpdateImageData(); 58 59 void UpdatePostProcessData(const PostProcessConfiguration& postProcessConfiguration); 60 void ProcessPostProcessConfiguration(); 61 void InitCreateShaderResources(); 62 void InitCreateBinders(); 63 void CreatePostProcessInterfaces(); 64 65 struct InputOutput { 66 BindableImage input; 67 BindableImage output; 68 }; 69 void ExecuteCombine(IRenderCommandList& cmdList, const InputOutput& inOut); 70 void ExecuteFXAA(IRenderCommandList& cmdList, const InputOutput& inOut); 71 void ExecuteBlit(IRenderCommandList& cmdList, const InputOutput& inOut); 72 void ExecuteTAA(IRenderCommandList& cmdList, const InputOutput& inOut); 73 void ExecuteDofBlur(IRenderCommandList& cmdList, const InputOutput& inOut); 74 void ExecuteDof(IRenderCommandList& cmdList, const InputOutput& inOut); 75 76 // Json resources which might need re-fetching 77 struct JsonInputs { 78 RenderNodeGraphInputs::InputResources resources; 79 RenderNodeGraphInputs::RenderDataStore renderDataStore; 80 bool hasChangeableResourceHandles { false }; 81 82 uint32_t colorIndex { ~0u }; 83 uint32_t depthIndex { ~0u }; 84 uint32_t velocityIndex { ~0u }; 85 uint32_t historyIndex { ~0u }; 86 uint32_t historyNextIndex { ~0u }; 87 }; 88 JsonInputs jsonInputs_; 89 RenderNodeHandles::InputResources inputResources_; 90 91 struct EffectData { 92 IShaderManager::ShaderData sd; 93 RenderHandle pso; 94 }; 95 EffectData fxaaData_; 96 EffectData taaData_; 97 EffectData dofBlurData_; 98 EffectData dofData_; 99 EffectData copyData_; 100 EffectData combineData_; 101 // additional optimized layer copy for GL(ES) 102 EffectData combineDataLayer_; 103 104 RenderBloom renderBloom_; 105 RenderBlur renderBlur_; 106 RenderMotionBlur renderMotionBlur_; 107 RenderNodeCopyUtil renderCopy_; 108 // additional layer copy 109 RenderNodeCopyUtil renderCopyLayer_; 110 111 RenderBlur renderNearBlur_; 112 RenderBlur renderFarBlur_; 113 114 struct PostProcessInterfaces { 115 IRenderPostProcess::Ptr postProcess; 116 IRenderPostProcessNode::Ptr postProcessNode; 117 }; 118 PostProcessInterfaces ppLensFlareInterface_; 119 120 struct AdditionalImageData { 121 RenderHandle black; 122 RenderHandle white; 123 }; 124 IRenderNodePostProcessUtil::ImageData images_; 125 AdditionalImageData aimg_; 126 127 IRenderNodePostProcessUtil::PostProcessInfo postProcessInfo_; 128 129 enum POST_PROCESS_UBO_INDICES { 130 PP_TAA_IDX = 0U, 131 PP_BLOOM_IDX, 132 PP_BLUR_IDX, 133 PP_FXAA_IDX, 134 PP_COMBINED_IDX, 135 PP_DOF_IDX, 136 PP_MB_IDX, 137 PP_COUNT_IDX, 138 }; 139 140 struct UboHandles { 141 // first 512 aligned is global post process 142 // after (256) we have effect local data 143 RenderHandleReference postProcess; 144 }; 145 UboHandles ubos_; 146 147 BASE_NS::Math::UVec2 outputSize_ { 0U, 0U }; 148 149 bool validInputs_ { true }; 150 bool validInputsForTaa_ { false }; 151 bool validInputsForDof_ { false }; 152 bool validInputsForMb_ { false }; 153 BASE_NS::vector<InputOutput> framePostProcessInOut_; 154 155 struct DefaultSamplers { 156 RenderHandle nearest; 157 RenderHandle linear; 158 RenderHandle mipLinear; 159 }; 160 DefaultSamplers samplers_; 161 PostProcessConfiguration ppConfig_; 162 163 struct TemporaryImages { 164 uint32_t idx = 0U; 165 uint32_t imageCount = 0U; 166 uint32_t mipIdx = 0U; 167 uint32_t mipImageCount = 0U; 168 RenderHandleReference images[2U]; 169 RenderHandleReference mipImages[2U]; 170 BASE_NS::Math::Vec4 targetSize { 0.0f, 0.0f, 0.0f, 0.0f }; 171 uint32_t mipCount[2U]; 172 173 RenderHandleReference layerCopyImage; 174 }; 175 TemporaryImages ti_; GetIntermediateImage(const RenderHandle & input)176 BindableImage GetIntermediateImage(const RenderHandle& input) 177 { 178 if (ti_.imageCount == 0U) { 179 return {}; 180 } 181 if (input == ti_.images[ti_.idx].GetHandle()) { 182 ti_.idx = (ti_.idx + 1) % static_cast<uint32_t>(ti_.imageCount); 183 } 184 return { ti_.images[ti_.idx].GetHandle() }; 185 } GetMipImage(const RenderHandle & input)186 BindableImage GetMipImage(const RenderHandle& input) 187 { 188 if (ti_.mipImageCount == 0U) { 189 return {}; 190 } 191 if (input == ti_.mipImages[ti_.mipIdx].GetHandle()) { 192 ti_.mipIdx = (ti_.mipIdx + 1) % static_cast<uint32_t>(ti_.mipImageCount); 193 } 194 return { ti_.mipImages[ti_.mipIdx].GetHandle() }; 195 } 196 197 struct AllBinders { 198 IDescriptorSetBinder::Ptr globalSet0[POST_PROCESS_UBO_INDICES::PP_COUNT_IDX]; 199 200 IDescriptorSetBinder::Ptr combineBinder; 201 IDescriptorSetBinder::Ptr combineLayerBinder; 202 IDescriptorSetBinder::Ptr taaBinder; 203 IDescriptorSetBinder::Ptr fxaaBinder; 204 IDescriptorSetBinder::Ptr dofBlurBinder; 205 IDescriptorSetBinder::Ptr dofBinder; 206 207 IDescriptorSetBinder::Ptr copyBinder; 208 }; 209 AllBinders binders_; 210 211 DeviceBackendType deviceBackendType_ { DeviceBackendType::VULKAN }; 212 213 bool glOptimizedLayerCopyEnabled_ { false }; 214 }; 215 216 class RenderNodePostProcessUtilImpl final : public IRenderNodePostProcessUtil { 217 public: 218 RenderNodePostProcessUtilImpl() = default; 219 ~RenderNodePostProcessUtilImpl() override = default; 220 221 void Init(IRenderNodeContextManager& renderNodeContextMgr, 222 const IRenderNodePostProcessUtil::PostProcessInfo& postProcessInfo) override; 223 void PreExecute(const IRenderNodePostProcessUtil::PostProcessInfo& postProcessInfo) override; 224 void Execute(IRenderCommandList& cmdList) override; 225 226 const CORE_NS::IInterface* GetInterface(const BASE_NS::Uid& uid) const override; 227 CORE_NS::IInterface* GetInterface(const BASE_NS::Uid& uid) override; 228 229 void Ref() override; 230 void Unref() override; 231 232 private: 233 RenderNodePostProcessUtil rn_; 234 235 uint32_t refCount_ { 0U }; 236 }; 237 RENDER_END_NAMESPACE() 238 239 #endif // RENDER__RENDER_NODE_POST_PROCESS_UTIL_H 240