GPUBufferScatter.hpp

#pragma once
#include <Gfx/Graph/RenderState.hpp>
 
#include <private/qrhi_p.h>
 
#include <score_plugin_gfx_export.h>
 
namespace score::gfx
{
 
class GPUBufferScatter
{
public:
  enum class SourceFormat : uint32_t
  {
    Float32 = 0,
    Unorm8 = 1, 
    Half = 2,
    Uint32 = 3,
    Sint32 = 4,
  };
  enum class DestinationKind : uint32_t
  {
    Float = 0,
    Uint = 1,
    Int = 2,
  };
 
  struct Params
  {
    QRhiBuffer* staging{};    // Source SSBO (raw CPU data, uploaded as-is)
    QRhiBuffer* output{};     // Destination SSBO (format-converted result)
    uint32_t element_count{};
    uint32_t src_components{}; // Components per source element (1-4)
    uint32_t dst_components{}; // Components per destination element (1-4)
    uint32_t src_stride_bytes{}; // Stride between source elements, in bytes
    uint32_t src_offset_bytes{}; // Offset of the first element in the source, in bytes
    uint32_t dst_stride_floats{}; // Stride between destination elements (in words, 0 = dst_components)
    SourceFormat src_format{SourceFormat::Float32};
    DestinationKind dst_kind{DestinationKind::Float};
  };
 
  SCORE_PLUGIN_GFX_TEST_EXPORT static void scatterOnCpu(
      const Params& p, const char* src, int64_t src_size, char* dst, int64_t dst_size);
 
  bool init(RenderState& state);
  void release();
 
  struct PreparedOp
  {
    QRhiShaderResourceBindings* srb{};
    QRhiBuffer* paramsUBO{};
  };
  PreparedOp prepare(QRhi& rhi, const Params& p);
 
  void updateParams(QRhiResourceUpdateBatch& res, const PreparedOp& op, const Params& p);
 
  void dispatch(QRhiCommandBuffer& cb, const PreparedOp& op, const Params& p);
 
  static constexpr int LocalSize = 256;
 
  struct DispatchDims
  {
    int x{};
    int y{};
    int z{};
  };
 
private:
  DispatchDims computeDispatchDims(uint32_t element_count) const;
 
  QRhiComputePipeline* m_pipeline{};
  QShader m_shader;
  int m_maxWorkgroupsPerDim{65535};
};
 
} // namespace score::gfx