-
Notifications
You must be signed in to change notification settings - Fork 1
Expand file tree
/
Copy pathScriptableRenderer.h
More file actions
148 lines (128 loc) · 4.91 KB
/
Copy pathScriptableRenderer.h
File metadata and controls
148 lines (128 loc) · 4.91 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
#pragma once
#include "Export.h"
#include "IRenderContext.h"
#include "RenderData.h"
#include "ScriptableRenderPass.h"
#include "IRenderThrMethod.h"
#include "IBuffer.h"
#include "Core/Util.h"
#include "Core/ISyncable.h"
#include <vector>
#include <type_traits>
#include <utility>
#include <future>
namespace sh::render
{
class CopyPass;
class ComputeShader;
template<>
struct IRenderThrMethod<class ScriptableRenderer>
{
static void Setup(ScriptableRenderer& renderer, const RenderData& data);
static void Execute(ScriptableRenderer& renderer, const RenderData& data);
static void ExecuteTransfer(ScriptableRenderer& renderer, uint32_t imgIdx);
static void EnqueRenderPass(ScriptableRenderer& renderer, ScriptableRenderPass& pass);
static void CallReadbacks(ScriptableRenderer& renderer);
static void ResetSubmittedCommands(ScriptableRenderer& renderer, IRenderContext& ctx);
static void ResetSwapChainStates(ScriptableRenderer& renderer);
static auto GetRenderCallCount(ScriptableRenderer& renderer) -> uint32_t;
};
class ScriptableRenderer : public core::ISyncable
{
friend IRenderThrMethod<class ScriptableRenderer>;
public:
struct RecordedCommand
{
ScriptableRenderPass& pass;
CommandBuffer& cmd;
};
public:
SH_RENDER_API ScriptableRenderer(IRenderContext& ctx);
SH_RENDER_API virtual ~ScriptableRenderer();
SH_RENDER_API virtual void Init() {};
SH_RENDER_API auto AddRenderPass(const core::Name& passName, RenderQueue renderQueue) -> ScriptableRenderPass&;
SH_RENDER_API auto ReadRenderTextureAsync(RenderTexture& rt, int x, int y) -> std::future<std::unique_ptr<IBuffer>>;
SH_RENDER_API void Dispatch(const ComputeShader& computeShader, uint32_t x, uint32_t y, uint32_t z);
SH_RENDER_API auto HasPass(const core::Name& passName) const -> bool;
auto GetRecordedCommands() const -> const std::vector<RecordedCommand>& { return recordedCmds; }
template<typename T, typename = std::enable_if_t<std::is_base_of_v<ScriptableRenderPass, T>>, typename... Args>
auto AddRenderPass(Args&&... args) -> T&;
protected:
SH_RENDER_API void SyncDirty() override;
SH_RENDER_API void Sync() override;
SH_RENDER_API virtual void Setup(const RenderData& data);
SH_RENDER_API virtual void Execute(const RenderData& data);
SH_RENDER_API void ExecuteTransfer(uint32_t imgIdx);
SH_RENDER_API void CallReadbacks();
SH_RENDER_API void EnqueRenderPass(ScriptableRenderPass& pass);
SH_RENDER_API void ResetSubmittedCommands(IRenderContext& ctx);
SH_RENDER_API void ResetSwapChainStates();
SH_RENDER_API auto GetRenderCallCount() const -> uint32_t { return renderCallCount; }
private:
auto BuildBarrierInfo(ScriptableRenderPass& pass, uint32_t imgIdx) -> std::vector<BarrierInfo>;
protected:
IRenderContext& ctx;
std::vector<std::unique_ptr<ScriptableRenderPass>> allPasses;
private:
SH_RENDER_API static std::vector<ResourceUsage> swapChainStates;
std::vector<ScriptableRenderPass*> activePasses;
std::vector<RecordedCommand> recordedCmds;
std::unique_ptr<CopyPass> cpyPass;
struct SyncData
{
RenderTexture* src;
int x;
int y;
std::promise<std::unique_ptr<IBuffer>> promise;
};
std::vector<SyncData> syncDatas;
struct PendingReadback
{
std::unique_ptr<IBuffer> buffer;
std::promise<std::unique_ptr<IBuffer>> promise;
};
std::vector<PendingReadback> pendingReadbacks;
uint32_t renderCallCount = 0;
bool bSyncDirty = false;
};
template<typename T, typename, typename... Args>
inline auto ScriptableRenderer::AddRenderPass(Args&&... args) -> T&
{
std::unique_ptr<T> uniquePtr = std::make_unique<T>(std::forward<Args>(args)...);
T* ptr = uniquePtr.get();
allPasses.push_back(std::move(uniquePtr));
return *ptr;
}
inline void IRenderThrMethod<class ScriptableRenderer>::Setup(ScriptableRenderer& renderer, const RenderData& data)
{
renderer.Setup(data);
}
inline void IRenderThrMethod<class ScriptableRenderer>::Execute(ScriptableRenderer& renderer, const RenderData& data)
{
renderer.Execute(data);
}
inline void IRenderThrMethod<class ScriptableRenderer>::ExecuteTransfer(ScriptableRenderer& renderer, uint32_t imgIdx)
{
renderer.ExecuteTransfer(imgIdx);
}
inline void IRenderThrMethod<class ScriptableRenderer>::EnqueRenderPass(ScriptableRenderer& renderer, ScriptableRenderPass& pass)
{
renderer.EnqueRenderPass(pass);
}
inline void IRenderThrMethod<class ScriptableRenderer>::CallReadbacks(ScriptableRenderer& renderer)
{
renderer.CallReadbacks();
}
inline void IRenderThrMethod<class ScriptableRenderer>::ResetSubmittedCommands(ScriptableRenderer& renderer, IRenderContext& ctx)
{
renderer.ResetSubmittedCommands(ctx);
}
inline void IRenderThrMethod<class ScriptableRenderer>::ResetSwapChainStates(ScriptableRenderer& renderer)
{
renderer.ResetSwapChainStates();
}
inline auto IRenderThrMethod<class ScriptableRenderer>::GetRenderCallCount(ScriptableRenderer& renderer) -> uint32_t
{
return renderer.GetRenderCallCount();
}
}//namespace