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_RENDERER_H 17 #define RENDER_RENDERER_H 18 19 #include <mutex> 20 21 #include <base/containers/unique_ptr.h> 22 #include <base/containers/vector.h> 23 #include <core/threading/intf_thread_pool.h> 24 #include <render/intf_renderer.h> 25 #include <render/namespace.h> 26 #include <render/render_data_structures.h> 27 #include <render/resource_handle.h> 28 #include <render/util/intf_render_util.h> 29 30 #include "render_backend.h" 31 32 RENDER_BEGIN_NAMESPACE() 33 class Device; 34 class GpuResourceManager; 35 class IRenderContext; 36 class IRenderDataStoreDefaultStaging; 37 class ShaderManager; 38 class RenderFrameSync; 39 class RenderGraph; 40 class RenderNodeGraphManager; 41 class RenderDataStoreManager; 42 class RenderUtil; 43 class RenderNodeGraphGlobalShareDataManager; 44 struct RenderNodeGraphNodeStore; 45 46 /** 47 Renderer. 48 Implementation of default renderer. 49 Renderer renderers a render node graph with input data. 50 */ 51 class Renderer final : public IRenderer { 52 public: 53 explicit Renderer(IRenderContext& context); 54 ~Renderer() override; 55 56 uint64_t RenderFrame(BASE_NS::array_view<const RenderHandleReference> renderNodeGraphs) override; 57 uint64_t RenderDeferred(BASE_NS::array_view<const RenderHandleReference> renderNodeGraphs) override; 58 uint64_t RenderDeferredFrame() override; 59 60 uint64_t RenderFrameBackend(const RenderFrameBackendInfo& info) override; 61 uint64_t RenderFramePresent(const RenderFramePresentInfo& info) override; 62 63 RenderStatus GetFrameStatus() const override; 64 65 private: 66 void InitNodeGraphs(BASE_NS::array_view<const RenderHandle> renderNodeGraphs); 67 68 // same render node graphs needs to be removed before calling this 69 void RenderFrameImpl(BASE_NS::array_view<const RenderHandle> renderNodeGraphs); 70 void RenderFrameBackendImpl(); 71 void RenderFramePresentImpl(); 72 73 void ExecuteRenderNodes(BASE_NS::array_view<RenderNodeGraphNodeStore*> renderNodeGraphNodeStores); 74 75 void FillRngInputs( 76 BASE_NS::array_view<const RenderHandle> renderNodeGraphInputList, BASE_NS::vector<RenderHandle>& rngInputs); 77 void RemapBackBufferHandle(const IRenderDataStoreManager& renderData); 78 79 void ProcessTimeStampEnd(); 80 void Tick(); 81 82 CORE_NS::IThreadPool::Ptr threadPool_; 83 84 IRenderContext& renderContext_; 85 Device& device_; 86 GpuResourceManager& gpuResourceMgr_; 87 ShaderManager& shaderMgr_; 88 RenderNodeGraphManager& renderNodeGraphMgr_; 89 RenderDataStoreManager& renderDataStoreMgr_; 90 RenderUtil& renderUtil_; 91 92 BASE_NS::unique_ptr<RenderGraph> renderGraph_; 93 BASE_NS::unique_ptr<RenderBackend> renderBackend_; 94 BASE_NS::unique_ptr<RenderFrameSync> renderFrameSync_; 95 CORE_NS::IParallelTaskQueue::Ptr parallelQueue_; 96 CORE_NS::ISequentialTaskQueue::Ptr sequentialQueue_; 97 RenderingConfiguration renderConfig_; 98 BASE_NS::unique_ptr<RenderNodeGraphGlobalShareDataManager> rngGlobalShareDataMgr_; 99 100 RenderHandleReference defaultStagingRng_; 101 RenderHandleReference defaultEndFrameStagingRng_; 102 // deferred creation (only if using NodeGraphBackBufferConfiguration BackBufferType::GPU_IMAGE_BUFFER_COPY) 103 // NOTE: should be deprecated 104 RenderHandleReference defaultBackBufferGpuBufferRng_; 105 106 // mutex for calling RenderFrame() 107 mutable std::mutex renderMutex_; 108 109 // mutex for deferred render node graph list 110 mutable std::mutex deferredMutex_; 111 BASE_NS::vector<RenderHandleReference> deferredRenderNodeGraphs_; 112 113 RenderTimings::Times frameTimes_; 114 uint64_t firstTime_ { ~0u }; 115 uint64_t previousFrameTime_ { ~0u }; 116 uint64_t deltaTime_ { 1 }; 117 118 IRenderDataStoreDefaultStaging* dsStaging_ { nullptr }; 119 120 struct RenderFrameTimeData { 121 uint64_t frameIndex { 0 }; 122 123 // filled before backend run 124 // cleared after present run 125 RenderBackendBackBufferConfiguration config; 126 BASE_NS::vector<RenderHandle> rngInputs; 127 BASE_NS::vector<RenderNodeGraphNodeStore*> rngNodeStores; 128 129 // evaluated in RenderFrameBackendImpl 130 // used in RenderFramePresentImpl 131 bool hasBackendWork { false }; 132 }; 133 RenderFrameTimeData renderFrameTimeData_; 134 135 struct SeparatedRenderingData { 136 bool separateBackend { false }; 137 bool separatePresent { false }; 138 139 // this needs to be locked by RenderFrame (front-end) and RenderFrameBackend (back-end) 140 std::mutex frontMtx; 141 // this needs to be locked by RenderFrameBackend (back-end) and RenderFramePresent (presentation) 142 std::mutex backMtx; 143 }; 144 SeparatedRenderingData separatedRendering_; 145 146 RenderStatus renderStatus_; 147 // could be called in parallel 148 uint64_t renderStatusDeferred_ { 0 }; 149 150 bool forceSequentialQueue_ { false }; 151 }; 152 RENDER_END_NAMESPACE() 153 154 #endif // RENDER_RENDERER_H 155