• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #ifndef RENDER_CONTEXT_H
17 #define RENDER_CONTEXT_H
18 
19 #include <cstdint>
20 
21 #include <base/containers/string.h>
22 #include <base/containers/unique_ptr.h>
23 #include <base/containers/unordered_map.h>
24 #include <core/ecs/intf_component_manager.h>
25 #include <core/namespace.h>
26 #include <core/plugin/intf_plugin.h>
27 #include <render/implementation_uids.h>
28 #include <render/intf_render_context.h>
29 #include <render/namespace.h>
30 #include <render/resource_handle.h>
31 
32 #include "loader/render_data_configuration_loader.h"
33 #include "nodecontext/render_node_copy_util.h"
34 #include "nodecontext/render_node_post_process_util.h"
35 #include "postprocesses/render_post_process_bloom.h"
36 #include "postprocesses/render_post_process_bloom_node.h"
37 #include "postprocesses/render_post_process_blur.h"
38 #include "postprocesses/render_post_process_blur_node.h"
39 #include "postprocesses/render_post_process_combined.h"
40 #include "postprocesses/render_post_process_combined_node.h"
41 #include "postprocesses/render_post_process_dof.h"
42 #include "postprocesses/render_post_process_dof_node.h"
43 #include "postprocesses/render_post_process_flare.h"
44 #include "postprocesses/render_post_process_flare_node.h"
45 #include "postprocesses/render_post_process_fxaa.h"
46 #include "postprocesses/render_post_process_fxaa_node.h"
47 #include "postprocesses/render_post_process_motion_blur.h"
48 #include "postprocesses/render_post_process_motion_blur_node.h"
49 #include "postprocesses/render_post_process_taa.h"
50 #include "postprocesses/render_post_process_taa_node.h"
51 #include "postprocesses/render_post_process_upscale.h"
52 #include "postprocesses/render_post_process_upscale_node.h"
53 
54 CORE_BEGIN_NAMESPACE()
55 class IEngine;
56 class IFileManager;
57 CORE_END_NAMESPACE()
58 
59 RENDER_BEGIN_NAMESPACE()
60 class Device;
61 class Renderer;
62 class RenderDataStoreManager;
63 class RenderNodeManager;
64 class RenderNodeGraphManager;
65 class RenderNodeGraphLoader;
66 class RenderUtil;
67 
68 class IDevice;
69 class IRenderer;
70 class IRenderDataStore;
71 class IRenderDataStoreManager;
72 class IRenderNodeGraphManager;
73 class IRenderUtil;
74 
75 struct RenderPluginState;
76 struct IRenderPlugin;
77 
78 class RenderContext final : public IRenderContext,
79                             public CORE_NS::IClassRegister,
80                             CORE_NS::IPluginRegister::ITypeInfoListener {
81 public:
82     RenderContext(RenderPluginState& pluginState, CORE_NS::IEngine& engine);
83     ~RenderContext() override;
84 
85     /** Init, create device for render use.
86      *  @param createInfo Device creation info.
87      */
88     RenderResultCode Init(const RenderCreateInfo& createInfo) override;
89 
90     /** Get active device. */
91     IDevice& GetDevice() const override;
92     /** Get rendererer */
93     IRenderer& GetRenderer() const override;
94     /** Get render node graph manager */
95     IRenderNodeGraphManager& GetRenderNodeGraphManager() const override;
96     /** Get render data store manager */
97     IRenderDataStoreManager& GetRenderDataStoreManager() const override;
98 
99     /** Some methods and callbacks might try to use the members before full initialization */
100     bool ValidMembers() const;
101 
102     /** Get render utilities */
103     IRenderUtil& GetRenderUtil() const override;
104 
105     CORE_NS::IEngine& GetEngine() const override;
106 
107     BASE_NS::string_view GetVersion() override;
108 
109     void WritePipelineCache() const override;
110 
111     RenderCreateInfo GetCreateInfo() const override;
112 
113     // IInterface
114     const IInterface* GetInterface(const BASE_NS::Uid& uid) const override;
115     IInterface* GetInterface(const BASE_NS::Uid& uid) override;
116     void Ref() override;
117     void Unref() override;
118 
119     // IClassFactory
120     IInterface::Ptr CreateInstance(const BASE_NS::Uid& uid) override;
121 
122     // IClassRegister
123     void RegisterInterfaceType(const CORE_NS::InterfaceTypeInfo& interfaceInfo) override;
124     void UnregisterInterfaceType(const CORE_NS::InterfaceTypeInfo& interfaceInfo) override;
125     BASE_NS::array_view<const CORE_NS::InterfaceTypeInfo* const> GetInterfaceMetadata() const override;
126     const CORE_NS::InterfaceTypeInfo& GetInterfaceMetadata(const BASE_NS::Uid& uid) const override;
127     IInterface* GetInstance(const BASE_NS::Uid& uid) const override;
128 
129 private:
130     // IPluginRegister::ITypeInfoListener
131     void OnTypeInfoEvent(EventType type, BASE_NS::array_view<const CORE_NS::ITypeInfo* const> typeInfos) override;
132 
133     void RegisterDefaultPaths();
134     BASE_NS::unique_ptr<Device> CreateDevice(const RenderCreateInfo& createInfo);
135     void WritePipelineCacheInternal(bool activate) const;
136 
137     RenderPluginState& pluginState_;
138     CORE_NS::IEngine& engine_;
139     CORE_NS::IFileManager* fileManager_ { nullptr };
140     BASE_NS::unique_ptr<Device> device_;
141     BASE_NS::unique_ptr<RenderDataStoreManager> renderDataStoreMgr_;
142     BASE_NS::unique_ptr<RenderNodeGraphManager> renderNodeGraphMgr_;
143     BASE_NS::unique_ptr<Renderer> renderer_;
144     BASE_NS::unique_ptr<RenderUtil> renderUtil_;
145     RenderDataConfigurationLoaderImpl renderDataConfigurationLoader_;
146 
147     using InterfacePtr = CORE_NS::IInterface*;
148     CORE_NS::InterfaceTypeInfo interfaceInfos_[21U] {
149         CORE_NS::InterfaceTypeInfo {
150             this,
151             UID_RENDER_DATA_CONFIGURATION_LOADER,
152             CORE_NS::GetName<IRenderDataConfigurationLoader>().data(),
153             {}, // nullptr for CreateInstance
154             [](CORE_NS::IClassRegister& registry, CORE_NS::PluginToken token) -> InterfacePtr {
155                 if (token) {
156                     return &(static_cast<RenderContext*>(token)->renderDataConfigurationLoader_);
157                 }
158                 return nullptr;
159             },
160         },
161         CORE_NS::InterfaceTypeInfo {
162             this, UID_RENDER_NODE_POST_PROCESS_UTIL, CORE_NS::GetName<IRenderNodePostProcessUtil>().data(),
163             [](CORE_NS::IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr {
164                 if (token) {
165                     return new RenderNodePostProcessUtilImpl();
166                 }
167                 return nullptr;
168             },
169             nullptr, // nullptr for GetInstance
170         },
171         CORE_NS::InterfaceTypeInfo {
172             nullptr,
173             RenderPostProcessFlare::UID,
174             "",
175             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessFlare(); },
176             nullptr,
177         },
178         CORE_NS::InterfaceTypeInfo {
179             nullptr,
180             RenderPostProcessFlareNode::UID,
181             "",
182             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessFlareNode(); },
183             nullptr,
184         },
185         CORE_NS::InterfaceTypeInfo {
186             nullptr,
187             RenderPostProcessUpscale::UID,
188             "",
189             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessUpscale(); },
190             nullptr,
191         },
192         CORE_NS::InterfaceTypeInfo {
193             nullptr,
194             RenderPostProcessUpscaleNode::UID,
195             "",
196             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr {
197                 return new RenderPostProcessUpscaleNode();
198             },
199             nullptr,
200         },
201         CORE_NS::InterfaceTypeInfo {
202             this, UID_RENDER_NODE_COPY_UTIL, CORE_NS::GetName<IRenderNodeCopyUtil>().data(),
203             [](CORE_NS::IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr {
204                 if (token) {
205                     return new RenderNodeCopyUtil();
206                 }
207                 return nullptr;
208             },
209             nullptr, // nullptr for GetInstance
210         },
211         CORE_NS::InterfaceTypeInfo {
212             nullptr,
213             RenderPostProcessBlur::UID,
214             "",
215             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessBlur(); },
216             nullptr,
217         },
218         CORE_NS::InterfaceTypeInfo {
219             nullptr,
220             RenderPostProcessBlurNode::UID,
221             "",
222             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessBlurNode(); },
223             nullptr,
224         },
225         CORE_NS::InterfaceTypeInfo {
226             nullptr,
227             RenderPostProcessBloom::UID,
228             "",
229             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessBloom(); },
230             nullptr,
231         },
232         CORE_NS::InterfaceTypeInfo {
233             nullptr,
234             RenderPostProcessBloomNode::UID,
235             "",
236             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessBloomNode(); },
237             nullptr,
238         },
239         CORE_NS::InterfaceTypeInfo {
240             nullptr,
241             RenderPostProcessTaa::UID,
242             "",
243             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessTaa(); },
244             nullptr,
245         },
246         CORE_NS::InterfaceTypeInfo {
247             nullptr,
248             RenderPostProcessTaaNode::UID,
249             "",
250             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessTaaNode(); },
251             nullptr,
252         },
253         CORE_NS::InterfaceTypeInfo {
254             nullptr,
255             RenderPostProcessFxaa::UID,
256             "",
257             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessFxaa(); },
258             nullptr,
259         },
260         CORE_NS::InterfaceTypeInfo {
261             nullptr,
262             RenderPostProcessFxaaNode::UID,
263             "",
264             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessFxaaNode(); },
265             nullptr,
266         },
267         CORE_NS::InterfaceTypeInfo {
268             nullptr,
269             RenderPostProcessDof::UID,
270             "",
271             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessDof(); },
272             nullptr,
273         },
274         CORE_NS::InterfaceTypeInfo {
275             nullptr,
276             RenderPostProcessDofNode::UID,
277             "",
278             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessDofNode(); },
279             nullptr,
280         },
281         CORE_NS::InterfaceTypeInfo {
282             nullptr,
283             RenderPostProcessMotionBlur::UID,
284             "",
285             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr {
286                 return new RenderPostProcessMotionBlur();
287             },
288             nullptr,
289         },
290         CORE_NS::InterfaceTypeInfo {
291             nullptr,
292             RenderPostProcessMotionBlurNode::UID,
293             "",
294             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr {
295                 return new RenderPostProcessMotionBlurNode();
296             },
297             nullptr,
298         },
299         CORE_NS::InterfaceTypeInfo {
300             nullptr,
301             RenderPostProcessCombined::UID,
302             "",
303             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr { return new RenderPostProcessCombined(); },
304             nullptr,
305         },
306         CORE_NS::InterfaceTypeInfo {
307             nullptr,
308             RenderPostProcessCombinedNode::UID,
309             "",
310             [](IClassFactory&, CORE_NS::PluginToken token) -> InterfacePtr {
311                 return new RenderPostProcessCombinedNode();
312             },
313             nullptr,
314         }
315     };
316 
317     uint32_t refCount_ { 0 };
318     BASE_NS::vector<BASE_NS::refcnt_ptr<IRenderDataStore>> defaultRenderDataStores_;
319     BASE_NS::vector<BASE_NS::pair<CORE_NS::PluginToken, const IRenderPlugin*>> plugins_;
320     BASE_NS::vector<const CORE_NS::InterfaceTypeInfo*> interfaceTypeInfos_;
321 
322     BASE_NS::vector<RenderHandleReference> defaultGpuResources_;
323 
324     RenderCreateInfo createInfo_ {};
325 };
326 
327 struct RenderPluginState {
328     CORE_NS::IEngine& engine_;
329     IRenderContext::Ptr context_;
330     CORE_NS::InterfaceTypeInfo interfaceInfo_ {
331         this,
332         UID_RENDER_CONTEXT,
333         CORE_NS::GetName<IRenderContext>().data(),
334         [](CORE_NS::IClassFactory& factory, CORE_NS::PluginToken token) -> CORE_NS::IInterface* {
335             if (token) {
336                 auto state = static_cast<RenderPluginState*>(token);
337                 return static_cast<RenderPluginState*>(token)->CreateInstance(state->engine_);
338             }
339             return nullptr;
340         },
341         [](CORE_NS::IClassRegister& registry, CORE_NS::PluginToken token) -> CORE_NS::IInterface* {
342             if (token) {
343                 return static_cast<RenderPluginState*>(token)->GetInstance();
344             }
345             return nullptr;
346         },
347     };
348 
349     IRenderContext* CreateInstance(CORE_NS::IEngine& engine);
350     IRenderContext* GetInstance() const;
351     void Destroy();
352 };
353 RENDER_END_NAMESPACE()
354 
355 #endif // RENDER_CONTEXT_H
356