1 /* 2 * Copyright (C) 2023 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 <core/ecs/intf_component_manager.h> 24 #include <core/namespace.h> 25 #include <render/implementation_uids.h> 26 #include <render/intf_render_context.h> 27 #include <render/namespace.h> 28 #include <render/resource_handle.h> 29 30 #include "datastore/render_data_store_manager.h" 31 #include "device/device.h" 32 #include "loader/render_data_configuration_loader.h" 33 #include "nodecontext/render_node_graph_manager.h" 34 #include "renderer.h" 35 36 CORE_BEGIN_NAMESPACE() 37 class IEngine; 38 class IFileManager; 39 CORE_END_NAMESPACE() 40 RENDER_BEGIN_NAMESPACE() 41 class Device; 42 class Renderer; 43 class RenderDataStoreManager; 44 class RenderNodeManager; 45 class RenderNodeGraphManager; 46 class RenderNodeGraphLoader; 47 class RenderUtil; 48 49 class IDevice; 50 class IRenderer; 51 class IRenderDataStoreManager; 52 class IRenderNodeGraphManager; 53 class IRenderUtil; 54 55 struct RenderPluginState; 56 57 class RenderContext final : public IRenderContext, 58 public virtual CORE_NS::IClassRegister, 59 CORE_NS::IPluginRegister::ITypeInfoListener { 60 public: 61 RenderContext(RenderPluginState& pluginState, CORE_NS::IEngine& engine); 62 ~RenderContext() override; 63 64 /** Init, create device for render use. 65 * @param createInfo Device creation info. 66 */ 67 RenderResultCode Init(const RenderCreateInfo& createInfo) override; 68 69 /** Get active device. */ 70 IDevice& GetDevice() const override; 71 /** Get rendererer */ 72 IRenderer& GetRenderer() const override; 73 /** Get render node graph manager */ 74 IRenderNodeGraphManager& GetRenderNodeGraphManager() const override; 75 /** Get render data store manager */ 76 IRenderDataStoreManager& GetRenderDataStoreManager() const override; 77 78 /** Get render utilities */ 79 IRenderUtil& GetRenderUtil() const override; 80 81 CORE_NS::IEngine& GetEngine() const override; 82 83 BASE_NS::string_view GetVersion() override; 84 85 // IInterface 86 const IInterface* GetInterface(const BASE_NS::Uid& uid) const override; 87 IInterface* GetInterface(const BASE_NS::Uid& uid) override; 88 void Ref() override; 89 void Unref() override; 90 91 // IClassFactory 92 IInterface::Ptr CreateInstance(const BASE_NS::Uid& uid) override; 93 94 // IClassRegister 95 void RegisterInterfaceType(const CORE_NS::InterfaceTypeInfo& interfaceInfo) override; 96 void UnregisterInterfaceType(const CORE_NS::InterfaceTypeInfo& interfaceInfo) override; 97 BASE_NS::array_view<const CORE_NS::InterfaceTypeInfo* const> GetInterfaceMetadata() const override; 98 const CORE_NS::InterfaceTypeInfo& GetInterfaceMetadata(const BASE_NS::Uid& uid) const override; 99 IInterface* GetInstance(const BASE_NS::Uid& uid) const override; 100 101 private: 102 // IPluginRegister::ITypeInfoListener 103 void OnTypeInfoEvent(EventType type, BASE_NS::array_view<const CORE_NS::ITypeInfo* const> typeInfos) override; 104 105 void RegisterDefaultPaths(); 106 BASE_NS::unique_ptr<Device> CreateDevice(const DeviceCreateInfo& createInfo); 107 108 RenderPluginState& pluginState_; 109 CORE_NS::IEngine& engine_; 110 CORE_NS::IFileManager* fileManager_ { nullptr }; 111 BASE_NS::unique_ptr<Device> device_; 112 BASE_NS::unique_ptr<RenderDataStoreManager> renderDataStoreMgr_; 113 BASE_NS::unique_ptr<RenderNodeGraphManager> renderNodeGraphMgr_; 114 BASE_NS::unique_ptr<Renderer> renderer_; 115 BASE_NS::unique_ptr<RenderUtil> renderUtil_; 116 RenderDataConfigurationLoaderImpl renderDataConfigurationLoader_; 117 118 CORE_NS::InterfaceTypeInfo interfaceInfo_ { 119 this, 120 UID_RENDER_DATA_CONFIGURATION_LOADER, 121 CORE_NS::GetName<IRenderDataConfigurationLoader>().data(), 122 {}, 123 [](CORE_NS::IClassRegister& registry, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 124 if (token) { 125 return &(static_cast<RenderContext*>(token)->renderDataConfigurationLoader_); 126 } 127 return nullptr; 128 }, 129 }; 130 uint32_t refCount_ { 0 }; 131 132 BASE_NS::vector<BASE_NS::pair<CORE_NS::PluginToken, const IRenderPlugin*>> plugins_; 133 BASE_NS::vector<const CORE_NS::InterfaceTypeInfo*> interfaceTypeInfos_; 134 135 BASE_NS::vector<RenderHandleReference> defaultGpuResources_; 136 }; 137 138 struct RenderPluginState { 139 CORE_NS::IEngine& engine_; 140 IRenderContext::Ptr context_; 141 CORE_NS::InterfaceTypeInfo interfaceInfo_ { 142 this, 143 UID_RENDER_CONTEXT, 144 CORE_NS::GetName<IRenderContext>().data(), 145 [](CORE_NS::IClassFactory& factory, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 146 if (token) { 147 auto state = static_cast<RenderPluginState*>(token); 148 return static_cast<RenderPluginState*>(token)->CreateInstance(state->engine_); 149 } 150 return nullptr; 151 }, 152 [](CORE_NS::IClassRegister& registry, CORE_NS::PluginToken token) -> CORE_NS::IInterface* { 153 if (token) { 154 return static_cast<RenderPluginState*>(token)->GetInstance(); 155 } 156 return nullptr; 157 }, 158 }; 159 160 IRenderContext* CreateInstance(CORE_NS::IEngine& engine); 161 IRenderContext* GetInstance(); 162 void Destroy(); 163 }; 164 RENDER_END_NAMESPACE() 165 166 #endif // RENDER_CONTEXT_H 167