SceneDrawer.hpp

#pragma once
#include <Gfx/Graph/NodeRenderer.hpp>
#include <Gfx/Graph/Utils.hpp>
 
#include <Threedim/ModelDisplay/ModelSceneDrawer.hpp>
 
#include <ossia/detail/hash_map.hpp>
 
#include <Threedim/GeometryViewer/SceneSummary.hpp>
 
#include <QMatrix4x4>
 
#include <array>
#include <memory>
#include <optional>
#include <vector>
 
namespace Gfx::GeometryViewer
{
struct GeometryViewerNode;
 
using SceneView = score::gfx::ModelSceneView;
 
class SceneDrawer final : public score::gfx::ModelSceneDrawer
{
public:
  explicit SceneDrawer(const GeometryViewerNode& node);
  ~SceneDrawer() override;
  SceneDrawer(const SceneDrawer&) = delete;
  SceneDrawer& operator=(const SceneDrawer&) = delete;
 
  bool setScene(const ossia::scene_spec& scene) override;
 
  bool active() const noexcept override { return m_active; }
 
  const ossia::aabb& bounds() const noexcept override { return m_desc.bounds; }
 
  void update(
      score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res,
      score::gfx::PassMap& passes, QRhiBuffer* processUBO, QRhiBuffer* cameraUBO,
      const SceneView& view) override;
 
  void draw(
      score::gfx::RenderList& renderer, QRhiCommandBuffer& cb,
      score::gfx::Edge& edge) override;
 
  bool hasLines() const noexcept override { return m_lineVertices > 0 || m_wantsLines; }
  void drawLines(
      score::gfx::RenderList& renderer, QRhiCommandBuffer& cb, score::gfx::Edge& edge,
      QRhiGraphicsPipeline* lines, QRhiShaderResourceBindings* srb) override;
 
  void release() override;
 
private:
  struct MeshEntry
  {
    ossia::geometry_spec spec;
    const score::gfx::Mesh* mesh{};
    score::gfx::MeshBuffers buffers;
    uint8_t attributes{};
    uint64_t layout{};
    bool live{};
    bool used{};
  };
 
  struct TextureEntry
  {
    std::shared_ptr<const ossia::texture_source> source;
    QRhiTexture* texture{};
    bool borrowed{};
    bool used{};
    bool failed{};
  };
 
  struct Draw
  {
    uint64_t mesh{};
    QMatrix4x4 world;
    ossia::material_component_ptr material;
    uint64_t texture{}, emissive{};
    uint64_t bindings{};
  };
 
  struct EdgePass
  {
    score::gfx::Edge* edge{};
    QRhiRenderPassDescriptor* renderPass{};
    score::gfx::TextureRenderTarget target;
    ossia::hash_map<uint64_t, score::gfx::Pipeline> pipelines;
    ossia::hash_map<uint64_t, QRhiShaderResourceBindings*> bindings;
  };
 
  void walk();
  void publish();
  uint64_t meshFor(const ossia::mesh_primitive& prim);
  uint64_t meshFor(const ossia::geometry_spec& spec, std::size_t index);
  uint64_t textureFor(const ossia::texture_ref& ref);
 
  bool ensureShaders(score::gfx::RenderList& renderer, int variant);
  uint64_t pipelineKey(const MeshEntry& m) const noexcept;
  score::gfx::Pipeline makePipeline(
      score::gfx::RenderList& renderer, const MeshEntry& m, const EdgePass& pass,
      QRhiShaderResourceBindings* srb);
  QRhiShaderResourceBindings* bindingsFor(
      score::gfx::RenderList& renderer, EdgePass& pass, const Draw& draw,
      QRhiBuffer* processUBO, QRhiBuffer* cameraUBO);
  QRhiTexture* textureOf(uint64_t key) const noexcept;
  void uploadTextures(score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res);
  void uploadDraws(score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res, const SceneView& view);
  void uploadLines(score::gfx::RenderList& renderer, QRhiResourceUpdateBatch& res, const SceneView& view);
  void releasePasses();
 
  const GeometryViewerNode& m_node;
 
  ossia::scene_spec m_scene;
  const ossia::scene_state* m_state{};
  int64_t m_version{-1}, m_dirty{-1};
  bool m_active{};
 
  SceneDescription m_desc;
  uint32_t m_serial{};
  bool m_summaryPending{};
  std::vector<Draw> m_draws;
  ossia::hash_map<uint64_t, MeshEntry> m_meshes;
  ossia::hash_map<uint64_t, TextureEntry> m_textures;
 
  std::array<std::optional<std::pair<QShader, QShader>>, 16> m_shaders;
  std::array<bool, 16> m_shaderFailed{};
 
  ossia::small_vector<EdgePass, 2> m_passes;
  QRhiBuffer* m_drawUBO{};
  QRhiBuffer* m_lightingUBO{};
  QRhiSampler* m_sampler{};
  int64_t m_drawStride{};
  int64_t m_drawCapacity{};
  bool m_drawsDirty{true};
  bool m_passesDirty{true};
  QMatrix4x4 m_drawsModel, m_linesModel;
  std::vector<char> m_drawData;
  int m_mode{-1};
 
  QRhiBuffer* m_lineBuffer{};
  int64_t m_lineCapacity{};
  int m_lineVertices{};
  bool m_wantsLines{};
  bool m_linesDirty{true};
  bool m_gizmos{};
  int64_t m_selected{-1};
  std::vector<float> m_lineData;
};
}