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