DebugScene.h

Go to the documentation of this file.

#pragma once
 
#include "Scene.h"
#include "Mesh.h"
#include "RenderContext.h"
#include "math_types.h"
 
#include <entt/entity/registry.hpp>
#include <entt/signal/sigh.hpp>
 
namespace candlewick {
 
enum class DebugPipelines {
  TRIANGLE_FILL,
  TRIANGLE_LINE,
};
 
class DebugScene;
 
enum class DebugMeshType {
  TRIAD,
  GRID,
  ARROW,
};

struct IDebugSubSystem {
  virtual void update() = 0;
  virtual ~IDebugSubSystem() = default;
 
protected:
  DebugScene &m_scene;
  explicit IDebugSubSystem(DebugScene &scene) : m_scene(scene) {}
};

struct DebugMeshComponent;

class DebugScene {
  entt::registry &m_registry;
  const RenderContext &m_renderer;
  SDL_GPUGraphicsPipeline *m_trianglePipeline{nullptr};
  SDL_GPUGraphicsPipeline *m_linePipeline{nullptr};
  std::vector<std::unique_ptr<IDebugSubSystem>> m_subsystems;
  std::unordered_map<DebugMeshType, Mesh> m_sharedMeshes;
  inline static const std::array<Float4, 3> m_triadColors = {
      Float4{1., 0., 0., 1.},
      Float4{0., 1., 0., 1.},
      Float4{0., 0., 1., 1.},
  };
 
  void initializeSharedMeshes();
 
  void setupPipelines(const MeshLayout &layout);
 
public:
  enum : Uint32 { TRANSFORM_SLOT = 0 };
  enum : Uint32 { COLOR_SLOT = 0 };
  using enum DebugMeshType;
 
  const Mesh &getMesh(DebugMeshType type) const {
    return m_sharedMeshes.at(type);
  }
 
  DebugScene(entt::registry &registry, const RenderContext &renderer);
  DebugScene(const DebugScene &) = delete;
  DebugScene &operator=(const DebugScene &) = delete;
  DebugScene(DebugScene &&other);
  DebugScene &operator=(DebugScene &&) = delete;
 
  const Device &device() const noexcept { return m_renderer.device; }
  entt::registry &registry() { return m_registry; }
  const entt::registry &registry() const { return m_registry; }

  template <std::derived_from<IDebugSubSystem> System, typename... Args>
  System &addSystem(Args &&...args) {
    auto sys = std::make_unique<System>(*this, std::forward<Args>(args)...);
    auto &p = m_subsystems.emplace_back(std::move(sys));
    return static_cast<System &>(*p);
  }

  std::tuple<entt::entity, DebugMeshComponent &>
  addTriad(const Float3 &scale = Float3::Ones());

  std::tuple<entt::entity, DebugMeshComponent &>
  addLineGrid(const Float4 &color = Float4::Ones());

  entt::entity addArrow(const Float4 &color = 0xf351ff_rgbaf);
 
  void update() {
    for (auto &system : m_subsystems) {
      system->update();
    }
  }
 
  void render(CommandBuffer &cmdBuf, const Camera &camera) const;
 
  void release();
 
  ~DebugScene() { release(); }
};
static_assert(Scene<DebugScene>);
 
struct DebugMeshComponent {
  DebugPipelines pipeline_type;
  DebugMeshType meshType;
  std::vector<Float4> colors;
  bool enable = true;
  Float3 scale = Float3::Ones();
};
 
} // namespace candlewick