4#include <Crousti/GfxNode.hpp>
9template <
typename Node_T>
11 avnd::texture_input_introspection<Node_T>::size > 0
12 && avnd::texture_output_introspection<Node_T>::size == 0)
13struct GfxRenderer<Node_T>
final :
score::gfx::OutputNodeRenderer
15 using texture_inputs = avnd::texture_input_introspection<Node_T>;
16 std::shared_ptr<Node_T> state;
18 ossia::small_flat_map<const score::gfx::Port*, score::gfx::TextureRenderTarget, 2>
21 std::vector<QRhiReadbackResult> m_readbacks;
22 ossia::time_value m_last_time{-1};
24 const GfxNode<Node_T>& node() const noexcept
26 return static_cast<const GfxNode<Node_T>&
>(score::gfx::NodeRenderer::node);
28 GfxRenderer(
const GfxNode<Node_T>& p)
29 :
score::gfx::OutputNodeRenderer{p}
30 , state{
std::make_shared<Node_T>()}
31 , m_readbacks(texture_inputs::size)
33 prepareNewState<Node_T>(state, p);
39 auto it = m_rts.find(&p);
40 SCORE_ASSERT(it != m_rts.end());
44 template <
typename Tex>
49 auto port = this->node().input[k];
50 static constexpr auto flags
51 = QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource;
52 auto texture = renderer.
state.rhi->newTexture(
53 gpp::qrhi::textureFormat<Tex>(), spec.size, 1, flags);
54 SCORE_ASSERT(texture->create());
59 QRhiTexture* texture(
int k)
const noexcept
61 auto port = this->node().input[k];
62 auto it = m_rts.find(port);
63 SCORE_ASSERT(it != m_rts.end());
64 SCORE_ASSERT(it->second.texture);
65 return it->second.texture;
68 void loadInputTexture(QRhi& rhi, avnd::cpu_texture
auto& cpu_tex,
int k)
70 auto& buf = m_readbacks[k].data;
71 if(buf.size() != cpu_tex.bytesize())
73 cpu_tex.bytes =
nullptr;
77 cpu_tex.bytes =
reinterpret_cast<unsigned char*
>(buf.data());
80 if(cpu_tex.width * cpu_tex.height > 0)
82 cpu_tex.bytes, cpu_tex.width, cpu_tex.height, cpu_tex.bytes_per_pixel);
84 cpu_tex.changed =
true;
90 if constexpr(
requires { state->prepare(); })
92 this->node().processControlIn(
93 *
this, *state, m_last_message, this->node().last_message, this->node().m_ctx);
99 avnd::cpu_texture_input_introspection<Node_T>::for_all(
100 avnd::get_inputs<Node_T>(*state),
101 [&]<
typename F>(F& t) {
103 auto spec = this->node().resolveRenderTargetSpecs(k, renderer);
104 if constexpr(
requires {
109 spec.size.rwidth() = t.request_width;
110 spec.size.rheight() = t.request_height;
112 createInput(renderer, k, t.texture, spec);
113 if constexpr(avnd::cpu_fixed_format_texture<
decltype(t.texture)>)
115 t.texture.width = spec.size.width();
116 t.texture.height = spec.size.height();
126 bool updated =
false;
166 for(
auto [port, rt] : m_rts)
171 void inputAboutToFinish(
173 QRhiResourceUpdateBatch*& res)
override
175 auto& parent = this->node();
176 res = renderer.
state.rhi->nextResourceUpdateBatch();
177 const auto& inputs = parent.input;
178 auto index_of_port = ossia::find(inputs, &p) - inputs.begin();
179 SCORE_ASSERT(index_of_port == 0);
181 auto tex = m_rts[&p].texture;
182 auto& readback = m_readbacks[index_of_port];
184 res->readBackTexture(QRhiReadbackDescription{tex}, &readback);
188 void runInitialPasses(
192 auto& parent = this->node();
193 auto& rhi = *renderer.
state.rhi;
199 if(parent.last_message.token.date == m_last_time)
203 m_last_time = parent.last_message.token.date;
211 avnd::cpu_texture_input_introspection<Node_T>::for_all(
212 avnd::get_inputs<Node_T>(*state), [&](
auto& t) {
213 loadInputTexture(rhi, t.texture, k);
218 parent.processControlIn(
219 *
this, *state, m_last_message, parent.last_message, parent.m_ctx);
225 parent.processControlOut(*this->state);
229 avnd::geometry_output_introspection<Node_T>::for_all_n2(
230 state->outputs, [&]<std::size_t F, std::size_t P>(
231 auto& t, avnd::predicate_index<P>, avnd::field_index<F>) {
232 postprocess_geometry(t);
235 template <avnd::geometry_port Field>
236 void postprocess_geometry(Field& ctrl)
238 using namespace avnd;
245 auto meshes = std::make_shared<ossia::mesh_list>();
246 auto& ossia_meshes = *meshes;
247 if constexpr(static_geometry_type<Field> || dynamic_geometry_type<Field>)
249 ossia_meshes.meshes.resize(1);
250 oscr::load_geometry(ctrl, ossia_meshes.meshes[0]);
253 static_geometry_type<
decltype(Field::mesh)>
254 || dynamic_geometry_type<
decltype(Field::mesh)>)
256 ossia_meshes.meshes.resize(1);
257 oscr::load_geometry(ctrl.mesh, ossia_meshes.meshes[0]);
261 oscr::load_geometry(ctrl, ossia_meshes);
264 ctrl.dirty_mesh =
false;
285template <
typename Node_T>
286 requires(avnd::texture_input_introspection<Node_T>::size > 0
287 && avnd::texture_output_introspection<Node_T>::size == 0)
288struct GfxNode<Node_T>
final
289 : CustomGpuOutputNodeBase
290 , GpuNodeElements<Node_T>
295 std::weak_ptr<Execution::ExecutionCommandQueue> q, Gfx::exec_controls ctls,
297 : CustomGpuOutputNodeBase{
std::move(q),
std::move(ctls), ctx}
298 , processModel{element}
302 initGfxPorts<Node_T>(
this, this->input, this->output);
308 return new GfxRenderer<Node_T>{*
this};
Definition score-plugin-avnd/Crousti/ProcessModel.hpp:79
Definition OutputNode.hpp:11
List of nodes to be rendered to an output.
Definition RenderList.hpp:19
bool requiresDepth() const noexcept
Whether this list of rendering actions requires depth testing at all.
Definition RenderList.hpp:137
RenderState & state
RenderState corresponding to this RenderList.
Definition RenderList.hpp:89
Definition Factories.hpp:19
TextureRenderTarget createRenderTarget(const RenderState &state, QRhiTexture *tex, int samples, bool depth)
Create a render target from a texture.
Definition score-plugin-gfx/Gfx/Graph/Utils.cpp:10
Base toolkit upon which the software is built.
Definition Application.cpp:97
Definition DocumentContext.hpp:18
Connection between two score::gfx::Port.
Definition score-plugin-gfx/Gfx/Graph/Utils.hpp:66
Definition score-plugin-gfx/Gfx/Graph/Node.hpp:50
Port of a score::gfx::Node.
Definition score-plugin-gfx/Gfx/Graph/Utils.hpp:48
Definition score-plugin-gfx/Gfx/Graph/Node.hpp:57
Useful abstraction for storing all the data related to a render target.
Definition score-plugin-gfx/Gfx/Graph/Utils.hpp:111