TextureLoader.hpp

#pragma once
#include <score_plugin_gfx_export.h>
 
#include <QImage>
#include <QString>
 
#include <cstdint>
#include <optional>
#include <unordered_map>
 
class QRhi;
class QRhiTexture;
class QRhiResourceUpdateBatch;
class QByteArray;
 
namespace score::gfx
{
 
// =============================================================================
// CPU-side decode result.
//
// The default implementation produces RGBA8888 data via QImageReader. The
// `srgb` flag is metadata only — it does NOT alter the pixel bytes, it just
// records whether the caller intends those bytes to be interpreted as sRGB
// when the texture is sampled (set the QRhiTexture format to RGBA8 vs sRGB8A8
// at upload time accordingly).
//
// Future swap-in candidates: OIIO (HDR/EXR), KTX2 (transcoded BCn), AVIF.
// =============================================================================
struct DecodedImage
{
  QImage image;        // QImage::Format_RGBA8888 (no premul)
  QString debug_name;  // For QRhiTexture::setName()
};
 
// =============================================================================
// Decode helpers — synchronous, called on the render thread.
//
// Both variants decode directly with QImage; cross-output dedup is handled at
// the TextureCache (per-renderer GPU side) and AssetTable (content-hash
// keyed) layers. We don't share a CPU-side cache here — reusing
// Gfx::ImageCache leaks every decoded path for the program lifetime.
// =============================================================================
 
SCORE_PLUGIN_GFX_EXPORT
std::optional<DecodedImage> decodeImageFromPath(const QString& path);
 
SCORE_PLUGIN_GFX_EXPORT
std::optional<DecodedImage> decodeImageFromMemory(
    const QByteArray& bytes, const QString& mime_hint);
 
// Colour-bleed a straight-alpha RGBA8888 image whose alpha is coverage (a
// cutout or blended base colour): the RGB under every alpha-0 texel is
// replaced by the colour of the covered texels around it, alpha untouched.
// Filtering and mip generation average RGB and alpha independently, so the
// arbitrary (often black) RGB authored under alpha 0 would otherwise bleed
// into the surviving edge as a dark or off-colour fringe. Direct neighbours
// of covered texels take their alpha-weighted mean; the rest are filled
// pull-push from alpha-weighted 2x2 block averages, which is what a box mip
// chain averages them into. Linear in the texel count. Returns false, leaving
// the image as it is, when it has no alpha-0 texel or no covered one.
SCORE_PLUGIN_GFX_EXPORT
bool bleedTransparentColor(QImage& image);
 
// =============================================================================
// GPU upload — pure RHI, no I/O. Allocates a freshly-sized QRhiTexture
// (RGBA8 or sRGB8_ALPHA8 depending on `srgb`), records the upload into
// `batch`. Caller owns the returned pointer (delete via deleteLater()).
//
// Returns nullptr on QRhi allocation failure.
// =============================================================================
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture* uploadImageToTexture(
    QRhi& rhi, QRhiResourceUpdateBatch& batch, const QImage& img, bool srgb,
    const QString& debug_name = {});
 
// =============================================================================
// One-shot decode + upload helpers. Convenience for callers that don't need
// to reuse the decoded CPU bytes.
// =============================================================================
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture* loadAndUploadTexture(
    QRhi& rhi, QRhiResourceUpdateBatch& batch, const QString& path, bool srgb);
 
SCORE_PLUGIN_GFX_EXPORT
QRhiTexture* loadAndUploadTexture(
    QRhi& rhi, QRhiResourceUpdateBatch& batch, const QByteArray& bytes,
    const QString& mime_hint, bool srgb);
 
// =============================================================================
// Per-renderer GPU texture cache.
//
// QRhiTexture* is bound to one QRhi instance, so this cache MUST live on the
// render-side node (e.g. ScenePreprocessorNode), not as a global singleton. Owns
// the textures it returns; clear() (also runs in the dtor) schedules each via
// deleteLater().
//
// Keys: a file path OR a stable content hash (for embedded glTF/FBX blobs).
// Two entries with the same origin but different sRGB flags coexist.
// =============================================================================
class SCORE_PLUGIN_GFX_EXPORT TextureCache
{
public:
  TextureCache() = default;
  ~TextureCache();
 
  TextureCache(const TextureCache&) = delete;
  TextureCache& operator=(const TextureCache&) = delete;
  TextureCache(TextureCache&&) noexcept = default;
  TextureCache& operator=(TextureCache&&) noexcept = default;
 
  // First call decodes + uploads via `batch`; later calls hit the cache.
  // Returns nullptr if the file can't be decoded.
  QRhiTexture* acquireFromPath(
      QRhi& rhi, QRhiResourceUpdateBatch& batch, const QString& path, bool srgb);
 
  // Same, for embedded blobs. `content_hash` is supplied by the caller — its
  // identity (not its value) is what guards re-upload.
  QRhiTexture* acquireFromMemory(
      QRhi& rhi, QRhiResourceUpdateBatch& batch, const QByteArray& bytes,
      const QString& mime_hint, uint64_t content_hash, bool srgb);
 
  // Schedule deleteLater() on every owned texture and drop the map.
  void clear();
 
  std::size_t size() const noexcept { return m_textures.size(); }
 
private:
  struct Key
  {
    QString origin;  // file path, or "blob:<hash-hex>" for memory blobs
    bool srgb{};
    bool operator==(const Key&) const noexcept = default;
  };
  struct KeyHash
  {
    std::size_t operator()(const Key& k) const noexcept;
  };
 
  std::unordered_map<Key, QRhiTexture*, KeyHash> m_textures;
};
 
}  // namespace score::gfx