Instancer.hpp

#pragma once
#include "TransformHelper.hpp"
 
#include <Threedim/TinyObj.hpp>
#include <halp/buffer.hpp>
#include <halp/controls.hpp>
#include <halp/geometry.hpp>
#include <halp/meta.hpp>
 
#include <ossia/dataflow/geometry_port.hpp>
 
#include <Gfx/Graph/GpuResourceRegistry.hpp>
 
#include <cstdint>
#include <memory>
 
class QMatrix4x4;
class QRhi;
class QRhiBuffer;
class QRhiCommandBuffer;
class QRhiComputePipeline;
class QRhiResourceUpdateBatch;
class QRhiShaderResourceBindings;
 
namespace score::gfx
{
class RenderList;
struct Edge;
}
 
namespace Threedim
{
 
// GPU-instancing authoring node. Takes a scene containing a mesh and a GPU buffer
// of per-instance transforms, plus optional colors and custom data, and emits a
// scene_spec wrapping an instance_component that ScenePreprocessor forwards
// downstream as the standard instance_transforms / instance_colors /
// instance_custom auxiliary buffers.
//
// Consumer shaders read the per-instance attributes through the VERTEX_INPUTS
// location 3..5 convention already in GeometryToBufferStrategies.hpp:
//   3 = translation / rotation / transform_matrix, 4 = color0, 5 = scale/custom.
//
// Transform formats, packed floats per instance:
//   mat4        16 floats, column-major
//   trs         10 floats: 3 translation + 4 quaternion + 3 scale
//   translation 3 floats, rotation and scale identity
class Instancer
{
public:
  halp_meta(name, "Instancer")
  halp_meta(category, "Visuals/3D/Scene")
  halp_meta(c_name, "instancer")
  halp_meta(description, "Create GPU instances of a scene mesh using per-instance transforms, colors and custom data.")
  halp_meta(authors, "ossia team")
  halp_meta(
      manual_url,
      "https://ossia.io/score-docs/processes/instancer.html")
  halp_meta(uuid, "5e8a2c7f-9b4d-4e3a-a1c6-2d7f0b3e8c4a")
 
  enum TransformFormat
  {
    Mat4,
    TRS,
    Translation
  };
 
  enum InstanceTransformMode
  {
    FullMatrix,
    TranslationOnly
  };
 
  struct ins
  {
    struct
    {
      halp_meta(name, "Scene In");
      ossia::scene_spec scene;
      uint8_t dirty{0};
    } scene_in;
 
    halp::gpu_buffer_input<"Transforms"> transforms;
    halp::gpu_buffer_input<"Colors"> colors;
    halp::gpu_buffer_input<"Custom"> custom;
 
    // Optional point-cloud geometry input. When wired, its semantic attributes
    // override the raw buffer inputs above: translation / position and
    // transform_matrix feed the Transforms buffer in Translation and Mat4 mode,
    // color0 feeds the Colors buffer. The `count` inlet is then overridden by the
    // geometry's vertex_count, so shaderlib presets can feed Instancer directly
    // without a glue repack.
    struct
    {
      halp_meta(name, "Points");
      halp::dynamic_gpu_geometry mesh;
      float transform[16]{};
      bool dirty_mesh = false;
      bool dirty_transform = false;
    } points;
 
    // Port-driven rebuild: scalar controls trigger Instancer::rebuild().
    // Upstream scene_in / buffer handles are detected in operator()()
    // because they can change without a port-update event.
    struct : halp::combobox_t<"Format", TransformFormat>
    {
      struct range
      {
        std::string_view values[3]{"mat4", "trs", "translation"};
        int init{0};
      };
      void update(Instancer& n) { n.rebuild(); }
    } format;
 
    struct : halp::spinbox_i32<"Count", halp::irange{1, 1000000, 1}>
    { void update(Instancer& n) { n.rebuild(); } } count;
 
    // Optional TRS applied to the prototype before instancing — lets
    // the node place the instanced cloud without a separate
    // Transform3D upstream.
    struct : PositionControl
    { void update(Instancer& n) { n.rebuild(); } } position;
    struct : RotationControl
    { void update(Instancer& n) { n.rebuild(); } } rotation;
    struct : ScaleControl
    { void update(Instancer& n) { n.rebuild(); } } scale;
 
    struct : halp::combobox_t<"Per-instance transform", InstanceTransformMode>
    {
      struct range
      {
        std::string_view values[2]{"Full matrix", "Translation only"};
        int init{0};
      };
      void update(Instancer& n) { n.rebuild(); }
    } transform_mode;
  } inputs;
 
  struct outs
  {
    struct
    {
      halp_meta(name, "Scene Out");
      ossia::scene_spec scene;
      uint8_t dirty{0};
    } scene_out;
  } outputs;
 
  void rebuild();
  void operator()();
 
  void init(score::gfx::RenderList& r, QRhiResourceUpdateBatch& res);
  void update(
      score::gfx::RenderList& r, QRhiResourceUpdateBatch& res,
      score::gfx::Edge* e);
  void runInitialPasses(
      score::gfx::RenderList& r, QRhiCommandBuffer& cb,
      QRhiResourceUpdateBatch*& res, score::gfx::Edge& e);
  void release(score::gfx::RenderList& r);
 
  enum BakeSourceIndex
  {
    BakeTransforms,
    BakeRotations,
    BakeScales,
    BakeColors,
    BakeCustom,
    BakeSourceCount
  };
  struct BakeSource
  {
    QRhiBuffer* buffer{};
    uint32_t offset{};
    uint32_t stride{};
    uint32_t components{};
  };
  struct Bake
  {
    BakeSource sources[BakeSourceCount]{};
    uint32_t transform_kind{};
    uint32_t count{};
    bool full{};
    float proto[16]{};
    float proto_inverse_linear[16]{};
  };
 
  // Cache so we republish a stable shared_ptr when inputs haven't
  // changed — ScenePreprocessor's identity caches stay warm.
  std::shared_ptr<ossia::scene_state> m_wrapped_state;
  uint8_t m_pending_dirty{0xFF};
  CachedTRS m_cachedTRS{};
  // Track input identity to detect when a rebuild is needed without
  // relying on buffer-contents equality.
  const ossia::scene_state* m_cached_in_state{};
  // The VIEW, not just the handle. A producer that re-points a buffer at a
  // different offset, or shrinks it to a smaller window of the same
  // allocation, keeps the handle -- and the instance-count capacity clamp
  // below depends on the size. Comparing handles alone would let a shrink go
  // unnoticed and the cloud would draw past the end of its transforms.
  struct CachedView
  {
    void* handle{};
    int64_t byte_offset{};
    int64_t byte_size{};
    friend bool operator==(const CachedView&, const CachedView&) = default;
  };
  static CachedView viewOf(const halp::gpu_buffer& b) noexcept
  {
    return {b.handle, (int64_t)b.byte_offset, (int64_t)b.byte_size};
  }
  CachedView m_cached_transforms{};
  CachedView m_cached_colors{};
  CachedView m_cached_custom{};
  int32_t m_cached_count{-1};
  int m_cached_format{-1};
  // For the point-cloud input: cache the primary-buffer identity so we
  // detect upstream handle replacements without poking every buffer
  // every frame.
  void* m_cached_points_buf{};
  int64_t m_cached_points_vertices{-1};
  // Fingerprint of ALL Points buffer handles (not just buffers[0]), so a
  // reallocated secondary attribute buffer (transform_matrix / color0)
  // that leaves the primary buffer + vertex count untouched still forces a
  // rebuild instead of republishing a dangling handle.
  uintptr_t m_cached_points_fingerprint{};
  int64_t m_version_counter{0};
 
  score::gfx::GpuResourceRegistry::Slot raw_transform_slot;
  ossia::gpu_slot_ref m_xform_ref{};
 
  bool refresh();
  bool ensureBakeTarget(QRhiBuffer*& buf, quint32 bytes, const char* name);
  bool prepareBake(
      const BakeSource (&sources)[BakeSourceCount], uint32_t transform_kind,
      uint32_t& count, bool full, const QMatrix4x4& proto);
 
  QRhi* m_rhi{};
  Bake m_bake{};
  bool m_baking{};
  QRhiBuffer* m_bakedTransforms{};
  QRhiBuffer* m_bakedColors{};
  QRhiBuffer* m_bakedCustom{};
  QRhiBuffer* m_bakeParams{};
  QRhiBuffer* m_bakeDummy{};
  QRhiShaderResourceBindings* m_bakeSrb{};
  QRhiComputePipeline* m_bakePipeline{};
  bool m_bakeSrbDirty{true};
  bool m_warnedBakeFallback{};
};
 
}