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_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_flare.h" 36 #include "postprocesses/render_post_process_flare_node.h" 37 38 CORE_BEGIN_NAMESPACE() 39 class IEngine; 40 class IFileManager; 41 CORE_END_NAMESPACE() 42 43 RENDER_BEGIN_NAMESPACE() 44 class Device; 45 class Renderer; 46 class RenderDataStoreManager; 47 class RenderNodeManager; 48 class RenderNodeGraphManager; 49 class RenderNodeGraphLoader; 50 class RenderUtil; 51 52 class IDevice; 53 class IRenderer; 54 class IRenderDataStore; 55 class IRenderDataStoreManager; 56 class IRenderNodeGraphManager; 57 class IRenderUtil; 58 59 struct RenderPluginState; 60 struct IRenderPlugin; 61 62 class RenderContext final : public IRenderContext, 63 public CORE_NS::IClassRegister, 64 CORE_NS::IPluginRegister::ITypeInfoListener { 65 public: 66 RenderContext(RenderPluginState& pluginState, CORE_NS::IEngine& engine); 67 ~RenderContext() override; 68 69 /** Init, create device for render use. 70 * @param createInfo Device creation info. 71 */ 72 RenderResultCode Init(const RenderCreateInfo& createInfo) override; 73 74 /** Get active device. */ 75 IDevice& GetDevice() const override; 76 /** Get rendererer */ 77 IRenderer& GetRenderer() const override; 78 /** Get render node graph manager */ 79 IRenderNodeGraphManager& GetRenderNodeGraphManager() const override; 80 /** Get render data store manager */ 81 IRenderDataStoreManager& GetRenderDataStoreManager() const override; 82 83 /** Get render utilities */ 84 IRenderUtil& GetRenderUtil() const override; 85 86 CORE_NS::IEngine& GetEngine() const override; 87 88 BASE_NS::ColorSpaceFlags GetColorSpaceFlags() const override; 89 90 BASE_NS::string_view GetVersion() override; 91 92 void WritePipelineCache() const override; 93 94 RenderCreateInfo GetCreateInfo() const; 95 96 // IInterface 97 const IInterface* GetInterface(const BASE_NS::Uid& uid) const override; 98 IInterface* GetInterface(const BASE_NS::Uid& uid) override; 99 void Ref() override; 100 void Unref() override; 101 102 // IClassFactory 103 IInterface::Ptr CreateInstance(const BASE_NS::Uid& uid) override; 104 105 // IClassRegister 106 void RegisterInterfaceType(const CORE_NS::InterfaceTypeInfo& interfaceInfo) override; 107 void UnregisterInterfaceType(const CORE_NS::InterfaceTypeInfo& interfaceInfo) override; 108 BASE_NS::array_view<const CORE_NS::InterfaceTypeInfo* const> GetInterfaceMetadata() const override; 109 const CORE_NS::InterfaceTypeInfo& GetInterfaceMetadata(const BASE_NS::Uid& uid) const override; 110 IInterface* GetInstance(const BASE_NS::Uid& uid) const override; 111 112 private: 113 // IPluginRegister::ITypeInfoListener 114 void OnTypeInfoEvent(EventType type, BASE_NS::array_view<const CORE_NS::ITypeInfo* const> typeInfos) override; 115 116 void RegisterDefaultPaths(); 117 BASE_NS::unique_ptr<Device> CreateDevice(const DeviceCreateInfo& createInfo); 118 void WritePipelineCacheInternal(bool activate) const; 119 120 RenderPluginState& pluginState_; 121 CORE_NS::IEngine& engine_; 122 CORE_NS::IFileManager* fileManager_ { nullptr }; 123 BASE_NS::unique_ptr<Device> device_; 124 BASE_NS::unique_ptr<RenderDataStoreManager> renderDataStoreMgr_; 125 BASE_NS::unique_ptr<RenderNodeGraphManager> renderNodeGraphMgr_; 126 BASE_NS::unique_ptr<Renderer> renderer_; 127 BASE_NS::unique_ptr<RenderUtil> renderUtil_; 128 RenderDataConfigurationLoaderImpl renderDataConfigurationLoader_; 129 130 CORE_NS::InterfaceTypeInfo interfaceInfos_[5U] { 131 CORE_NS::InterfaceTypeInfo { 132 this, 133 UID_RENDER_DATA_CONFIGURATION_LOADER, 134 CORE_NS::GetName<IRenderDataConfigurationLoader>().data(), 135 {}, // nullptr for CreateInstance 136 [](CORE_NS::IClassRegister& registry, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 137 if (token) { 138 return &(static_cast<RenderContext*>(token)->renderDataConfigurationLoader_); 139 } 140 return nullptr; 141 }, 142 }, 143 CORE_NS::InterfaceTypeInfo { 144 this, UID_RENDER_NODE_POST_PROCESS_UTIL, CORE_NS::GetName<IRenderNodePostProcessUtil>().data(), 145 [](CORE_NS::IClassFactory&, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 146 if (token) { 147 return new RenderNodePostProcessUtilImpl(); 148 } 149 return nullptr; 150 }, 151 nullptr, // nullptr for GetInstance 152 }, 153 CORE_NS::InterfaceTypeInfo { 154 nullptr, 155 RenderPostProcessFlare::UID, 156 "", 157 [](IClassFactory&, CORE_NS::PluginToken token) -> IInterface* { return new RenderPostProcessFlare(); }, 158 nullptr, 159 }, 160 CORE_NS::InterfaceTypeInfo { 161 nullptr, 162 RenderPostProcessFlareNode::UID, 163 "", 164 [](IClassFactory&, CORE_NS::PluginToken token) -> IInterface* { return new RenderPostProcessFlareNode(); }, 165 nullptr, 166 }, 167 CORE_NS::InterfaceTypeInfo { 168 this, UID_RENDER_NODE_COPY_UTIL, CORE_NS::GetName<IRenderNodeCopyUtil>().data(), 169 [](CORE_NS::IClassFactory&, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 170 if (token) { 171 return new RenderNodeCopyUtil(); 172 } 173 return nullptr; 174 }, 175 nullptr, // nullptr for GetInstance 176 }, 177 }; 178 179 uint32_t refCount_ { 0 }; 180 BASE_NS::vector<BASE_NS::refcnt_ptr<IRenderDataStore>> defaultRenderDataStores_; 181 BASE_NS::vector<BASE_NS::pair<CORE_NS::PluginToken, const IRenderPlugin*>> plugins_; 182 BASE_NS::vector<const CORE_NS::InterfaceTypeInfo*> interfaceTypeInfos_; 183 184 BASE_NS::vector<RenderHandleReference> defaultGpuResources_; 185 186 RenderCreateInfo createInfo_ {}; 187 }; 188 189 struct RenderPluginState { 190 CORE_NS::IEngine& engine_; 191 IRenderContext::Ptr context_; 192 CORE_NS::InterfaceTypeInfo interfaceInfo_ { 193 this, 194 UID_RENDER_CONTEXT, 195 CORE_NS::GetName<IRenderContext>().data(), 196 [](CORE_NS::IClassFactory& factory, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 197 if (token) { 198 auto state = static_cast<RenderPluginState*>(token); 199 return static_cast<RenderPluginState*>(token)->CreateInstance(state->engine_); 200 } 201 return nullptr; 202 }, 203 [](CORE_NS::IClassRegister& registry, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 204 if (token) { 205 return static_cast<RenderPluginState*>(token)->GetInstance(); 206 } 207 return nullptr; 208 }, 209 }; 210 211 IRenderContext* CreateInstance(CORE_NS::IEngine& engine); 212 IRenderContext* GetInstance() const; 213 void Destroy(); 214 }; 215 RENDER_END_NAMESPACE() 216 217 #endif // RENDER_CONTEXT_H 218