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 API_RENDER_IRENDERER_H
17 #define API_RENDER_IRENDERER_H
18 
19 #include <base/containers/array_view.h>
20 #include <render/namespace.h>
21 #include <render/resource_handle.h>
22 
23 RENDER_BEGIN_NAMESPACE()
24 class IRenderDataStoreManager;
25 /** \addtogroup group_render_irenderer
26  *  @{
27  */
28 /** Rendering interface.
29  *
30  * Engine creates a single renderer.
31  * 1. RenderFrame() should be called once per frame with a proper render node graphs.
32  * or
33  * 2 RenderDeferredFrame should be called once per frame.
34  *
35  * Render Node Graph:
36  * Render node graph contains a definition of the rendering pipeline (render nodes that contain render passes).
37  * A render node graph needs to be created before rendering can be done.
38  * Render node graph can be created (and should be) created with json.
39  * Json file is loaded with IRenderNodeGraphLoader and stored to RenderNodeGraphManager.
40  * Render Data Store:
41  * Render data store contains multiple managers that can store data that is accessable in render nodes.
42  *
43  * NOTE: render node graphs need to be unique per frame
44  * The same render node graph cannot be send to rendering multiple times in a frame
45  */
46 class IRenderer {
47 public:
48     IRenderer() = default;
49     virtual ~IRenderer() = default;
50 
51     IRenderer(const IRenderer&) = delete;
52     IRenderer& operator=(const IRenderer&) = delete;
53 
54     /** Render render node graphs. Should be called once a frame. Preferred method to call RenderFrame.
55      * Render node graphs are run in input order.
56      * @param renderNodeGraphs Multiple render node graph handles.
57      * @return Frame index of the currently rendered frame when the method returns.
58      */
59     virtual uint64_t RenderFrame(const BASE_NS::array_view<const RenderHandleReference> renderNodeGraphs) = 0;
60 
61     /** Render deferred can be called multiple times a frame.
62      * Creates a list of deferred render node graphs which will be rendered in order when calling
63      * Can be called from multiple threads.
64      * @param renderNodeGraphs Multiple render node graph handles.
65      * @return Frame index of next frame where these will be processed.
66      */
67     virtual uint64_t RenderDeferred(const BASE_NS::array_view<const RenderHandleReference> renderNodeGraphs) = 0;
68 
69     /** Render deferred render node graphs. Should be called once a frame.
70      * Renders deferred render node graphs in input order.
71      * @return Frame index of the currently rendered frame when the method returns.
72      */
73     virtual uint64_t RenderDeferredFrame() = 0;
74 
75     /** Render frame backend info.
76      */
77     struct RenderFrameBackendInfo {};
78     /** Execute current frame backend.
79      * Only valid if RenderContext created with SEPARATE_RENDER_FRAME_BACKEND.
80      * Needs to be called after RenderFrame or RenderDeferredFrame.
81      * @return Frame index of the currently rendered backend frame when the method returns.
82      */
83     virtual uint64_t RenderFrameBackend(const RenderFrameBackendInfo& info) = 0;
84 
85     /** Render frame presentation info.
86      */
87     struct RenderFramePresentInfo {};
88     /** Execute current frame presentation.
89      * Only valid if RenderContext created with SEPARATE_RENDER_FRAME_PRESENT.
90      * Needs to be called after RenderFrame or RenderDeferredFrame.
91      * Needs to be called after RenderFrameBackend if RenderContext created with SEPARATE_RENDER_FRAME_BACKEND.
92      * @return Frame index of the currently rendered present frame when the method returns.
93      */
94     virtual uint64_t RenderFramePresent(const RenderFramePresentInfo& info) = 0;
95 
96     /** Render frame status.
97      * Provides information of frame counts when different parts are processed.
98      * 1. If using: SEPARATE_RENDER_FRAME_PRESENT
99      * -> frontEndIndex and backEndIndex change before RenderFramePresent()
100      * 2. If using SEPARATE_RENDER_FRAME_BACKEND
101      * -> frontEndIndex changes before RenderFrameBackend()
102      * 3. Default
103      * -> all indices change when RenderFrame() is fully processed
104      * When the first frame is rendered the index is 1. (i.e. the actual number is count of rendered frames)
105      * The number starts from zero if no frames are rendered yet.
106      */
107     struct RenderStatus {
108         /** Processed front-end frame index (count of frames) */
109         uint64_t frontEndIndex { 0ULL };
110         /** Processed backend-end frame index (count of frames) */
111         uint64_t backEndIndex { 0ULL };
112         /** Processed present-end frame index (count of frames) */
113         uint64_t presentIndex { 0ULL };
114     };
115     /** Get status of rendering.
116      * @return RenderStatus
117      */
118     virtual RenderStatus GetFrameStatus() const = 0;
119 };
120 /** @} */
121 RENDER_END_NAMESPACE()
122 
123 #endif // API_RENDER_IRENDERER_H
124