1 /*
2 * Copyright (c) 2022 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_bloom.h"
17
18 #include <base/math/vector.h>
19 #include <render/datastore/intf_render_data_store_manager.h>
20 #include <render/datastore/intf_render_data_store_pod.h>
21 #include <render/datastore/render_data_store_render_pods.h>
22 #include <render/device/intf_gpu_resource_manager.h>
23 #include <render/intf_render_context.h>
24 #include <render/namespace.h>
25 #include <render/nodecontext/intf_node_context_descriptor_set_manager.h>
26 #include <render/nodecontext/intf_pipeline_descriptor_set_binder.h>
27 #include <render/nodecontext/intf_render_command_list.h>
28 #include <render/nodecontext/intf_render_node_context_manager.h>
29 #include <render/nodecontext/intf_render_node_parser_util.h>
30 #include <render/nodecontext/intf_render_node_util.h>
31
32 #include "core/plugin/intf_class_factory.h"
33 #include "datastore/render_data_store_pod.h"
34 #include "postprocesses/render_post_process_bloom.h"
35 #include "util/log.h"
36
37 // shaders
38 #include <render/shaders/common/render_post_process_structs_common.h>
39
40 using namespace BASE_NS;
41 using namespace CORE_NS;
42
43 RENDER_BEGIN_NAMESPACE()
44 namespace {
GetBindableImage(const RenderNodeResource & res)45 inline BindableImage GetBindableImage(const RenderNodeResource& res)
46 {
47 return BindableImage { res.handle, res.mip, res.layer, ImageLayout::CORE_IMAGE_LAYOUT_UNDEFINED, res.secondHandle };
48 }
49 } // namespace
50
InitNode(IRenderNodeContextManager & renderNodeContextMgr)51 void RenderNodeBloom::InitNode(IRenderNodeContextManager& renderNodeContextMgr)
52 {
53 valid_ = true;
54
55 renderNodeContextMgr_ = &renderNodeContextMgr;
56 ParseRenderNodeInputs();
57 CreatePostProcessInterface();
58
59 if (jsonInputs_.renderDataStore.dataStoreName.empty()) {
60 PLUGIN_LOG_E("RenderNodeBloom: render data store configuration not set in render node graph");
61 }
62 if (jsonInputs_.renderDataStore.typeName != RenderDataStorePod::TYPE_NAME) {
63 PLUGIN_LOG_E("RenderNodeBloom: render data store type name not supported (%s != %s)",
64 jsonInputs_.renderDataStore.typeName.data(), RenderDataStorePod::TYPE_NAME);
65 valid_ = false;
66 }
67
68 if (ppRenderBloomInterface_.postProcessNode) {
69 ppRenderBloomInterface_.postProcessNode->Init(ppRenderBloomInterface_.postProcess, *renderNodeContextMgr_);
70 }
71
72 renderNodeContextMgr.GetDescriptorSetManager().ResetAndReserve(
73 ppRenderBloomInterface_.postProcessNode->GetRenderDescriptorCounts());
74 }
75
PreExecuteFrame()76 void RenderNodeBloom::PreExecuteFrame()
77 {
78 if (!valid_) {
79 return;
80 }
81
82 const auto& renderNodeUtil = renderNodeContextMgr_->GetRenderNodeUtil();
83 if (jsonInputs_.hasChangeableResourceHandles) {
84 inputResources_ = renderNodeUtil.CreateInputResources(jsonInputs_.resources);
85 }
86 ProcessPostProcessConfiguration(renderNodeContextMgr_->GetRenderDataStoreManager());
87
88 RenderPostProcessBloom& pp = static_cast<RenderPostProcessBloom&>(*ppRenderBloomInterface_.postProcess);
89 pp.propertiesData.bloomConfiguration = ppConfig_.bloomConfiguration;
90 pp.propertiesData.enabled = ((ppConfig_.enableFlags & PostProcessConfiguration::ENABLE_BLOOM_BIT) > 0);
91
92 RenderPostProcessBloomNode& ppNode =
93 static_cast<RenderPostProcessBloomNode&>(*ppRenderBloomInterface_.postProcessNode);
94 ppNode.nodeInputsData.input = GetBindableImage(inputResources_.customInputImages[0]);
95 ppNode.nodeOutputsData.output = GetBindableImage(inputResources_.customOutputImages[0]);
96
97 ppRenderBloomInterface_.postProcessNode->PreExecute();
98 }
99
ExecuteFrame(IRenderCommandList & cmdList)100 void RenderNodeBloom::ExecuteFrame(IRenderCommandList& cmdList)
101 {
102 if (!valid_) {
103 return;
104 }
105
106 ppRenderBloomInterface_.postProcessNode->Execute(cmdList);
107 }
108
CreatePostProcessInterface()109 void RenderNodeBloom::CreatePostProcessInterface()
110 {
111 auto* renderClassFactory = renderNodeContextMgr_->GetRenderContext().GetInterface<IClassFactory>();
112 if (renderClassFactory) {
113 auto CreatePostProcessInterface = [&](const auto uid, auto& pp, auto& ppNode) {
114 if (pp = CreateInstance<IRenderPostProcess>(*renderClassFactory, uid); pp) {
115 ppNode = CreateInstance<IRenderPostProcessNode>(*renderClassFactory, pp->GetRenderPostProcessNodeUid());
116 }
117 };
118
119 CreatePostProcessInterface(
120 RenderPostProcessBloom::UID, ppRenderBloomInterface_.postProcess, ppRenderBloomInterface_.postProcessNode);
121 }
122 if (!(ppRenderBloomInterface_.postProcess && ppRenderBloomInterface_.postProcess)) {
123 valid_ = false;
124 }
125 }
126
GetExecuteFlags() const127 IRenderNode::ExecuteFlags RenderNodeBloom::GetExecuteFlags() const
128 {
129 // At the moment bloom needs typically copy even though it would not be in use
130 return ExecuteFlagBits::EXECUTE_FLAG_BITS_DEFAULT;
131 }
132
ProcessPostProcessConfiguration(const IRenderNodeRenderDataStoreManager & dataStoreMgr)133 void RenderNodeBloom::ProcessPostProcessConfiguration(const IRenderNodeRenderDataStoreManager& dataStoreMgr)
134 {
135 if (!jsonInputs_.renderDataStore.dataStoreName.empty()) {
136 if (const IRenderDataStore* ds = dataStoreMgr.GetRenderDataStore(jsonInputs_.renderDataStore.dataStoreName);
137 ds) {
138 if (jsonInputs_.renderDataStore.typeName == RenderDataStorePod::TYPE_NAME) {
139 auto const dataStore = static_cast<const IRenderDataStorePod*>(ds);
140 auto const dataView = dataStore->Get(jsonInputs_.renderDataStore.configurationName);
141 if (dataView.data() && (dataView.size_bytes() == sizeof(PostProcessConfiguration))) {
142 ppConfig_ = *((const PostProcessConfiguration*)dataView.data());
143 }
144 }
145 }
146 }
147 }
148
ParseRenderNodeInputs()149 void RenderNodeBloom::ParseRenderNodeInputs()
150 {
151 const IRenderNodeParserUtil& parserUtil = renderNodeContextMgr_->GetRenderNodeParserUtil();
152 const auto jsonVal = renderNodeContextMgr_->GetNodeJson();
153 jsonInputs_.resources = parserUtil.GetInputResources(jsonVal, "resources");
154 jsonInputs_.renderDataStore = parserUtil.GetRenderDataStore(jsonVal, "renderDataStore");
155
156 const auto& renderNodeUtil = renderNodeContextMgr_->GetRenderNodeUtil();
157 inputResources_ = renderNodeUtil.CreateInputResources(jsonInputs_.resources);
158 }
159
160 // for plugin / factory interface
Create()161 IRenderNode* RenderNodeBloom::Create()
162 {
163 return new RenderNodeBloom();
164 }
165
Destroy(IRenderNode * instance)166 void RenderNodeBloom::Destroy(IRenderNode* instance)
167 {
168 delete static_cast<RenderNodeBloom*>(instance);
169 }
170 RENDER_END_NAMESPACE()
171