RenderedRawRasterPipelineNode.hpp

#pragma once
#include <atomic>
 
#include <Gfx/Graph/ISFNode.hpp>
#include <Gfx/Graph/IndirectCountClamp.hpp>
#include <Gfx/Graph/IsfBindingsBuilder.hpp>
#include <Gfx/Graph/NodeRenderer.hpp>
#include <Gfx/Graph/RenderedISFUtils.hpp>
#include <Gfx/Graph/VertexFallbackPlan.hpp>
 
#include <ossia/detail/small_flat_map.hpp>
 
#include <span>
 
namespace score::gfx
{
SCORE_PLUGIN_GFX_TEST_EXPORT std::atomic<uint64_t>& iterationAttachmentAllocations() noexcept;
 
// Used for the simple case of a single, non-persistent pass (the most common case)
 
struct SCORE_PLUGIN_GFX_TEST_EXPORT RenderedRawRasterPipelineNode : score::gfx::NodeRenderer
{
  explicit RenderedRawRasterPipelineNode(const ISFNode& node) noexcept;
 
  virtual ~RenderedRawRasterPipelineNode();
 
  void updateInputTexture(const Port& input, QRhiTexture* tex, QRhiTexture* depthTex = nullptr) override;
  void updateInputSamplerFilter(const Port& input, const RenderTargetSpecs& spec) override;
  QRhiTexture* textureForOutput(const Port& output) override;
 
  void init(RenderList& renderer, QRhiResourceUpdateBatch& res) override;
  void update(RenderList& renderer, QRhiResourceUpdateBatch& res, Edge* edge) override;
  bool updateMaterials(RenderList& renderer, QRhiResourceUpdateBatch& res, Edge* edge);
  void release(RenderList& r) override;
 
  void initState(RenderList& renderer, QRhiResourceUpdateBatch& res) override;
  void releaseState(RenderList& renderer) override;
  void addOutputPass(RenderList& renderer, Edge& edge, QRhiResourceUpdateBatch& res) override;
  void removeOutputPass(RenderList& renderer, Edge& edge) override;
  bool hasOutputPassForEdge(Edge& edge) const override;
  void addInputEdge(RenderList& renderer, Edge& edge, QRhiResourceUpdateBatch& res) override;
  void removeInputEdge(RenderList& renderer, Edge& edge) override;
 
  void runInitialPasses(
      RenderList&, QRhiCommandBuffer& commands, QRhiResourceUpdateBatch*& res,
      Edge& edge) override;
 
  void runRenderPass(RenderList&, QRhiCommandBuffer& commands, Edge& edge) override;
 
  QRhiGraphicsPipeline::CompareOp depthCompare() const noexcept override;
  bool followsRenderSize() const noexcept override;
 
  void process(int32_t port, const ossia::transform3d& v) override;
 
private:
  // Resolves every image-style INPUT against the incoming geometry's
  // auxiliary_textures list and overrides the initial texture pointer in
  // m_inputSamplers for matches. Also builds m_auxTextureBindings so
  // update() can cheaply re-run the lookup when the geometry changes.
  // Must be called AFTER initInputSamplers.
  void bindAuxTexturesInit(RenderList& renderer);
 
  // Per-frame update hook: walks m_auxTextureBindings, re-resolves each
  // binding's texture pointer from the current geometry's aux textures,
  // and returns true if at least one sampler's texture pointer changed
  // (caller will flag mustRecreatePasses).
  bool rebindAuxTextures(RenderList& renderer);
 
  // What the input port behind m_inputSamplers[sampler_idx] provides without
  // any geometry override: its upstream or render-target texture, else the
  // port's empty placeholder.
  QRhiTexture* portTexture(RenderList& renderer, int sampler_idx) const;
 
  void initPass(
      const TextureRenderTarget& rt, RenderList& renderer,
      QRhiResourceUpdateBatch& res, Edge& edge);
  void initMRTPass(RenderList& renderer, QRhiResourceUpdateBatch& res);
  void initMRTBlitPasses(RenderList& renderer, QRhiResourceUpdateBatch& res);
  void initMRTBlitPass(RenderList& renderer, QRhiResourceUpdateBatch& res, Edge& edge);
 
  // EXECUTION_MODEL=MANUAL: evaluate the COUNT expression against the
  // live input state (first input image's $WIDTH / $HEIGHT / $DEPTH /
  // $LAYERS, scalar input values as $<inputName>). Pure-integer literal
  // fast path; otherwise delegate to ossia::math_expression with '$' →
  // 'var_' rewrite — same convention as CSF STRIDE / image-size
  // expressions. Returns >= 1; unparseable expressions degrade to 1.
  int resolveManualInvocationCount() const;
  bool outputSizeReadsBufferSizes() const noexcept;
  QSize declaredOutputSize() const;
  QSize m_declaredOutputSize;
 
  // True when the shader renders procedurally: no VERTEX_INPUTS, driven by
  // gl_VertexIndex, with PIPELINE_STATE.VERTEX_COUNT set. m_mesh stays null and
  // the draw skips vertex-buffer bindings, which relaxes the "no mesh, bail out"
  // guards for fullscreen passes, VSA-style draws and IBL precompute shaders.
  bool isProceduralDraw() const noexcept;
 
  // PIPELINE_STATE.VERTEX_COUNT / INSTANCE_COUNT, literal or evaluated this
  // frame through resolveIntExpression; nullopt when undeclared.
  std::optional<uint32_t> declaredVertexCount() const;
  std::optional<uint32_t> declaredInstanceCount() const;
 
  // Evaluate an integer-valued expression against the same variable
  // surface as resolveManualInvocationCount ($WIDTH_<inp> / $HEIGHT /
  // scalar inputs). Used for OUTPUTS.WIDTH / HEIGHT.
  // Returns `fallback` when the expression is empty, >=1 otherwise.
  int resolveIntExpression(const std::string& expr, int fallback) const;
 
  template <typename F>
  void refreshStorageBuffers(F&& refresh);
  void bindGeometryBuffersToAllSrbs(
      RenderList& renderer, QRhiResourceUpdateBatch& res);
 
  // Issue the draw for the currently bound pipeline and SRB. When the input
  // geometry carries several sub-meshes with per-mesh aux buffers, this iterates
  // them and re-points the SRB bindings before each draw; single-sub-mesh and MDI
  // geometries delegate to the mesh's own draw(). The SRB is left on the last
  // sub-mesh's bindings, and the next runRenderPass rebinds from scratch.
  //
  // `pipeline` and `viewport` are the bound ones: when the ScenePreprocessor
  // marks alpha-blended draws and `pipeline` blends and writes depth, those
  // draws go last through blendPassPipeline(pipeline), which leaves the
  // command buffer on that pipeline.
  void drawWithPerMeshAuxRebind(
      QRhiGraphicsPipeline& pipeline, const QRhiViewport& viewport,
      QRhiShaderResourceBindings& srb, QRhiCommandBuffer& cb,
      const FallbackBindingPlan& plan = {});
 
  // `pipeline` without depth write, for the alpha-blended draws; created on
  // first use, null when `pipeline` does not both blend and write depth.
  QRhiGraphicsPipeline* blendPassPipeline(QRhiGraphicsPipeline& pipeline);
  void releaseBlendPassPipeline(QRhiGraphicsPipeline* pipeline);
  ossia::small_flat_map<QRhiGraphicsPipeline*, QRhiGraphicsPipeline*, 2>
      m_blendPassPipelines;
  // The pipelines' QRhi: QRhiResource::rhi() is Qt 6.6+.
  QRhi* m_blendPassRhi{};
 
  std::vector<Sampler> allSamplers() const noexcept;
 
  ossia::small_vector<std::pair<Edge*, Pass>, 2> m_passes;
 
  ISFNode& n;
 
  std::vector<Sampler> m_inputSamplers;
  std::vector<int> m_storageImageSamplers;
  std::vector<Sampler> m_audioSamplers;
  ossia::small_flat_map<Edge*, QRhiSampler*, 4> m_blitSamplersByEdge;
 
  int64_t meshChangedIndex{-1};
  const Mesh* m_mesh{};
  const Mesh* currentMesh() const noexcept override { return m_mesh; }
  MeshBuffers m_meshbufs;
 
  // Quad mesh used for MRT blit passes (separate from the geometry mesh)
  const Mesh* m_blitMesh{};
  MeshBuffers m_blitMeshbufs;
 
  QRhiBuffer* m_materialUBO{};
  int m_materialSize{};
 
  QRhiBuffer* m_modelUBO{};
 
  struct AuxiliarySSBO
  {
    QRhiBuffer* buffer{};
    QRhiBuffer* prev_buffer{}; 
    int64_t size{};
    int64_t offset{};
    QString refused;
    bool owned{true}; // false when adopted from upstream geometry / upstream port
    bool is_uniform{false}; // true for uniform_input, false for storage_input
    bool persistent{false}; 
    std::string name;
    std::string access;
    // SRB binding slot assigned at pipeline build time. Needed so the per-
    // sub-mesh draw loop can patch `per_draws` (and any other per-mesh aux)
    // to point at mesh[i]'s buffer before drawing sub-mesh i. -1 when the
    // aux was filtered out of the SRB (e.g. visibility==none).
    int binding{-1};
    // For persistent aux only: binding slot of the <name>_prev (read-only)
    // half of the ping-pong pair. prev_binding + 1 == binding.
    int prev_binding{-1};
    int64_t declared_size{};
    int64_t min_size{};
  };
  std::vector<AuxiliarySSBO> m_auxiliarySSBOs;
  static void createAuxPlaceholder(
      QRhi& rhi, QRhiResourceUpdateBatch& res, AuxiliarySSBO& aux, QSize renderSize);
 
  // The `camera` block's buffer while a Camera is wired to the node's camera
  // input (ISFNode::cameraInput): packed from that scene's cameras and bound in
  // place of the `camera` auxiliary, whatever the geometry carries.
  QRhiBuffer* m_cameraInletBuffer{};
  int64_t m_cameraInletFrame{-1};
  bool m_cameraInletActive{false};
  void updateCameraInlet(RenderList& renderer, QRhiResourceUpdateBatch& res, QSize renderSize);
  void dropCameraInletGeometry();
 
  // Storage images and the rest of the INPUTS storage trio -- storage_input for
  // SSBOs, csf_image_input for image2D/3D, uniform_input for UBOs -- declared in
  // the top-level INPUTS array. Wired through the shared IsfBindingsBuilder
  // helpers so the SRB binding type matches isf_emit_graphics_storage's GLSL.
  // m_auxiliarySSBOs carries only the AUXILIARY-block entries; the dual
  // population is deliberate while the AUXILIARY path still has its own dispatch.
  GraphicsStorageResources m_storage;
  int m_firstStorageBinding{-1};
  int m_firstSamplerBinding{3};
  int m_firstAuxImageBinding{3};
 
  // Texture auxes carried on the input geometry (see
  // ossia::geometry::auxiliary_textures). Each entry records a sampler
  // slot in m_inputSamplers that auto-resolves its texture pointer from
  // the incoming geometry's aux-texture list by name at init() time and
  // again every time the geometry changes. Eliminates the need for a
  // dedicated texture cable (base_color_array / skybox / ...).
  struct AuxTextureBinding
  {
    int sampler_idx{-1}; // index into m_inputSamplers
    std::string name;    // INPUT name, matched against auxiliary_texture::name
    // The geometry texture last written into the slot, null when the slot is
    // the port's own.
    QRhiTexture* applied{};
    // Named like one of the Scene Preprocessor's deprecated per-channel
    // texture aliases (P32), and said so once.
    bool aliasWarned{};
  };
  std::vector<AuxTextureBinding> m_auxTextureBindings;
 
  // Non-owning per-port sampler overrides published by the upstream geometry's
  // auxiliary_texture::sampler_handle, parallel to m_inputSamplers. Kept separate
  // because m_inputSamplers entries are owned and released with
  // `delete sampler.sampler`, which would double-free a registry-owned sampler.
  std::vector<QRhiSampler*> m_inputSamplerOverrides;
 
  // Textures declared in the top-level AUXILIARY array (TYPE: image /
  // texture / cubemap / image_cube). Do NOT create a score input port —
  // resolved only from ossia::geometry::auxiliary_textures by name, with
  // a placeholder bound until the first matching handle arrives.
  struct AuxTextureAuxSampler
  {
    QRhiSampler* sampler{};  // Null for storage-image entries.
    QRhiTexture* texture{};
    // Shape-matched empty fallback. Set at init from is_cubemap / dimensions /
    // is_array and never changes. When rebindAuxTextures stops finding a
    // matching aux_texture upstream (producer stopped publishing the name, got
    // disconnected, etc.) `texture` reverts to this placeholder rather
    // than keeping the previous, possibly-freed, upstream handle.
    // One of the RenderList-owned empty textures for a sampled entry; owned
    // here, in the declared FORMAT, for a storage image.
    QRhiTexture* placeholder{};
    bool owns_placeholder{false};
    std::string name;
    int binding{-1};
    // Storage-image variant: bound with imageLoad / imageStore /
    // imageLoadStore instead of sampledTexture. `access` distinguishes
    // which of the three — "read_only" / "write_only" / "read_write".
    bool is_storage{false};
    std::string access;
    // Ladder rung, mirroring isf::…::auxiliary_texture_request. The rung with
    // ladder_index == 0 owns two SRB slots -- a `textures()` array at
    // `binding` and a `sampler()` at `binding + 1` -- and the other rungs are
    // elements of that array, so they take no slot of their own and keep
    // binding == -1. `sampler` is only allocated on the owner.
    int ladder_index{-1};
    int ladder_size{0};
    bool in_ladder() const noexcept { return ladder_size > 0; }
    bool owns_ladder() const noexcept { return ladder_index == 0 && ladder_size > 0; }
    // The publisher's sampler for this texture (auxiliary_texture::
    // sampler_handle), bound in place of `sampler` when set. Non-owning: the
    // publisher owns it. Never taken for a declaration that asks for COMPARE,
    // which is the shader's own intent rather than the texture's.
    QRhiSampler* sampler_override{};
    bool declares_compare{false};
    // MIPMAP_MODE left out of the declaration: `sampler` follows the bound
    // texture's mips (followTextureMips).
    bool mips_follow_texture{false};
    QRhiSampler* boundSampler() const noexcept
    {
      return sampler_override ? sampler_override : sampler;
    }
  };
  std::vector<AuxTextureAuxSampler> m_auxTextureSamplers;
  // Set by rebindAuxTextures when an AUXILIARY texture's bound sampler
  // changed; the passes are rebuilt, since a hot texture swap keeps the
  // sampler.
  bool m_auxSamplerChanged{false};
 
  const ossia::geometry_spec& drawGeometry();
  ossia::geometry_spec m_primitiveGeometry;
  ossia::geometry_spec m_primitiveSource;
  int64_t m_primitiveSourceIndex{};
  uint64_t m_primitiveSourceHash{};
  std::vector<std::pair<const void*, int64_t>> m_primitiveSourceBuffers;
  bool m_warnedPrimitiveData{false};
 
  void applyModeTopology(
      QRhiGraphicsPipeline& ps, int mode,
      std::optional<QRhiGraphicsPipeline::Topology> geometry);
  void warnModeOverridesGeometry(
      std::optional<QRhiGraphicsPipeline::Topology> geometry,
      QRhiGraphicsPipeline::Topology drawn);
  int m_warnedModeTopology{-1};
 
  // isf::raw_raster_point_quads on D3D11 / D3D12: rebuild the pipeline's
  // vertex input to one instance per point and its topology to triangles,
  // and mark the plan so the draw issues 6 vertices per point.
  void applyPointQuads(
      const RenderList& renderer, QRhiGraphicsPipeline& ps, FallbackBindingPlan& plan);
  bool m_warnedPointQuads{false};
 
  // Emit the SRB bindings for m_auxTextureSamplers, advancing `binding`.
  // Shared by initPass and initMRTPass so the two can never disagree about
  // how many slots a ladder consumes.
  // Whether this shader cannot be built on the current backend at all; warns
  // once.
  bool refusesBackend(const RenderList& renderer);
  bool m_backendRefusalLogged{false};
 
  void requestIndirectCommandBuffers(
      QRhiGraphicsPipeline& ps, const QRhi& rhi, const QShader& vs,
      const QShader& fs);
 
  void appendAuxTextureBindings(
      ossia::small_vector<QRhiShaderResourceBinding, 4>& out, int& binding,
      int imageBinding);
 
  std::optional<AudioTextureUpload> m_audioTex;
 
  // MRT: internally-owned render target with multiple attachments
  TextureRenderTarget m_mrtRenderTarget;
  bool m_hasMRT{false};
  bool m_mrtRenderedThisFrame{false};
 
  // Without the draw-count rung: the commands with their dead slots zeroed,
  // drawn by the plain indirect rungs (MeshBuffers::clampedIndirectBuffer).
  IndirectCountClamp m_countClamp;
  bool m_countClampedThisFrame{false};
  // Whether the mesh pipelines' shaders bind a texture, which declines the
  // count rung on Metal (drawIndirectCountUsable). Until there is a pipeline,
  // assume they do.
  bool m_drawBindsTextures{true};
  int m_countPathLogged{0};
  const char* m_countClampLastRefusal{};
  int64_t m_frameIndexFrame{-1};
 
  // EXECUTION_MODEL (top-level, RAW_RASTER only).
  //   Single   default, one invocation, no extra loop.
  //   PerMip   one invocation per mip level of the TARGET output, each binding a
  //            per-mip render target so the draw writes only that mip;
  //            ProcessUBO.passIndex carries the mip index. Drives the
  //            prefiltered-GGX roughness sweep.
  //   PerLayer one invocation per array layer. Colour targets bind setLayer(i);
  //            depth targets render to a shared scratch and copyTexture into
  //            layer i after the pass, since Qt RHI 6.11 has no per-layer depth
  //            attachment. Drives shadow_cascades.frag.
  //   Manual   count decided every frame by evaluating a COUNT expression through
  //            the math_expression parser, with the same variable surface as CSF
  //            STRIDE and image-size expressions. All invocations share the MRT
  //            render target and the shader branches on ProcessUBO.passIndex.
  enum class ExecutionMode : std::uint8_t
  {
    Single,
    PerMip,
    PerCubeFace,   // Iterate 6 cube faces; target = CubeMap + setLayer(i)
    PerLayer,      // Iterate N array layers; target = TextureArray + setLayer(i)
    Manual
  };
  ExecutionMode m_executionMode{ExecutionMode::Single};
 
  // PerCubeFace state. The target OUTPUT is allocated with
  // QRhiTexture::CubeMap (6 implicit layers) and six per-face render
  // targets are built at init; runInitialPasses iterates them in order,
  // stamping the face index into ProcessUBO.passIndex. Shares the
  // m_perMipOutputIndex resolution path (same "which colour output is
  // the target" question) and reuses the m_mipRTs vector for storage
  // — interpretation is mode-dependent (mip level vs face index).
  int m_perCubeFaceOutputIndex{-1};
 
  // PerMip state. When PerMip is active the MRT target texture is
  // allocated with QRhiTexture::MipMapped and m_mipCount / m_mipRTs
  // point at per-level render-pass views of it. m_perMipOutputIndex is
  // the index into m_mrtRenderTarget{.texture, .additionalColorTextures}
  // being iterated. -1 in other modes.
  int m_perMipOutputIndex{-1};
  int m_mipCount{0};
  // PER_MIP on a MULTIVIEW shader whose view index is lowered to a uniform
  // (viewIndexNeedsPassIndexFallback): no draw amplifies over the views, so
  // every mip level is rendered once per view, into that view's layer / face.
  // m_mipRTs then holds m_mipCount * m_perMipViews targets, mip-major.
  int m_perMipViews{1};
  int m_perLayerViews{0};
  struct MipRT
  {
    QRhiTextureRenderTarget* renderTarget{};
    QRhiRenderPassDescriptor* renderPass{};
    QRhiTexture* depth{}; // per-level depth — owned here.
    int colorCount{1};
    std::vector<QRhiTexture*> scratch;
    std::vector<QRhiRenderBuffer*> msaa;
    int samples{1};
  };
  std::vector<MipRT> m_mipRTs;
 
  // PerLayer state. m_perLayerOutputIndex is the raw index into
  // descriptor().outputs[], depth-inclusive, unlike the colour-only
  // m_perMipOutputIndex / m_perCubeFaceOutputIndex. m_perLayerIsDepth picks the
  // path:
  //
  //   colour: m_mipRTs holds one entry per layer with a setLayer(i) attachment,
  //   structurally PER_CUBE_FACE with a variable layer count.
  //
  //   depth: identical, using QRhiTextureRenderTargetDescription::setDepthLayer
  //   (Qt >= 6.12) so the pass writes straight into layer i of the OUTPUT
  //   depth array. Below 6.12 that API does not exist and the mode is REFUSED
  //   with a diagnostic rather than silently producing an empty array -- see
  //   initMRTPass. m_perLayerDummyColor is the placeholder colour attachment
  //   some backends (GLES) require, shared by every layer's RT and sized to
  //   the render extent, never 1x1.
  int  m_perLayerOutputIndex{-1};
  bool m_perLayerIsDepth{false};
  QRhiTexture*              m_perLayerDummyColor{nullptr};
 
  // Manual state. Re-evaluated every frame in runInitialPasses.
  int m_manualCount{1};
 
  // Per-invocation UBO + SRB pool for PER_MIP / PER_CUBE_FACE / MANUAL.
  //
  // A QRhi Dynamic UBO has a single slot per frame-in-flight: several
  // updateDynamicBuffer calls to one buffer within a frame overwrite each other,
  // so every draw that frame reads the last value and distinct PASSINDEX values
  // collapse to one.
  //
  // One UBO and one SRB per invocation, pre-built at init, lets the render loop
  // swap which SRB it binds. Index 0 is the main pass (pass.processUBO /
  // pass.p.srb); the vectors hold 1..N-1 and grow lazily, which MANUAL needs
  // since its count is per-frame dynamic.
  std::vector<QRhiBuffer*> m_perInvocationUBOs;
  std::vector<QRhiShaderResourceBindings*> m_perInvocationSRBs;
 
  // Transparent CUBEMAP + MULTIVIEW shim: QRhi forbids setMultiViewCount on a
  // cube texture, so a shader declaring both renders into a hidden 2D
  // TextureArray -- the only shape multiview accepts -- and each layer is blitted
  // onto the matching cube face at the end of runInitialPasses. Downstream sees a
  // real samplerCube through textureForOutput(); the shadow array never leaves
  // this class.
  //
  //   m_cubeCopyShadowArray  6-layer TextureArray, UsedAsTransferSource, the
  //                          multiview render target
  //   m_cubeCopyCube         the public CubeMap
  //   m_cubeCopyOutputIdx    colour-attachment index taking the array-then-copy
  //                          path, -1 otherwise; one output per shader
  QRhiTexture* m_cubeCopyShadowArray{};
  QRhiTexture* m_cubeCopyCube{};
  int m_cubeCopyOutputIdx{-1};
 
  // The part of the m_materialUBO for which changes
  // trigger a pipeline recreation (blend status etc.)
  static constexpr int size_of_pipeline_material = 32;
  alignas(4) char m_prevPipelineChangingMaterial[size_of_pipeline_material]{0};
  struct PipelineChangingMaterial
  {
    int32_t mode;         // tri, point, line
    int32_t enable_blend; // bool
    QRhiGraphicsPipeline::BlendFactor src_color;
    QRhiGraphicsPipeline::BlendFactor dst_color;
    QRhiGraphicsPipeline::BlendOp op_color;
    QRhiGraphicsPipeline::BlendFactor src_alpha;
    QRhiGraphicsPipeline::BlendFactor dst_alpha;
    QRhiGraphicsPipeline::BlendOp op_alpha;
  };
  static_assert(sizeof(PipelineChangingMaterial) == size_of_pipeline_material);
 
  ossia::transform3d m_modelTransform;
 
  // LAYER, per output edge: the draw goes into `targets` with the consumer's
  // depth attached read-only, then `resumeTarget` reopens the consumer's pass
  // for the resolve. `readDepthTarget` is the consumer's colour alone, for a
  // resolve sampling the consumer's depth.
  struct LayerTargets
  {
    std::vector<QRhiTexture*> targets;
    QRhiTextureRenderTarget* renderTarget{};
    QRhiRenderPassDescriptor* renderPass{};
    QRhiTextureRenderTarget* resumeTarget{};
    QRhiRenderPassDescriptor* resumePass{};
    QRhiTextureRenderTarget* readDepthTarget{};
    QRhiRenderPassDescriptor* readDepthPass{};
    QRhiTexture* depthInput{};
    QRhiTexture* depthPlaceholder{};
    QRhiSampler* sampler{};
    QColor clear;
    Pipeline clearTargets;
    Pipeline resolve;
    Pipeline resolveDepth;
    void release();
  };
  ossia::small_flat_map<Edge*, LayerTargets, 2> m_layers;
  bool m_warnedLayerFallback{false};
 
  TextureRenderTarget initLayerTargets(
      RenderList& renderer, const TextureRenderTarget& inlet, Edge& edge,
      QRhiResourceUpdateBatch& res);
  void initLayerResolve(RenderList& renderer, LayerTargets& t, QRhiBuffer* processUBO);
  void releaseLayerTargets(Edge* edge);
  void releaseLayerTargets();
  void applyLayerState(QRhiGraphicsPipeline& ps, bool depthAvailable, bool internal) const;
};
}