voxel_piece.hpp

Go to the documentation of this file.

 
#pragma once
#include "voxel.hpp"
 
#include <array>
#include <cstdint>
#include <future>
#include <memory>
#include <toast/assets/types.hpp>
#include <toast/voxel/voxel_edit.hpp>
#include <vector>
 
namespace assets {
class VoxelModel;
}
 
namespace toast {

enum class PieceKind : uint8_t {
  fill,     
  carve,    
  paint,    
};

class [[ToastNode, Hidden, Interface, Icon("Shape"), Color("Magenta")]] TOAST_API VoxelPiece : public Voxel {
public:
  // Drawing

  [[nodiscard, Reflect]]
  auto getSize() -> glm::vec3;

  [[nodiscard, Reflect]]
  auto getVoxel(glm::vec3 pos) -> int;
 
  [[Reflect]]
  void setVoxel(glm::vec3 pos, int id);
 
  [[Reflect]]
  void removeVoxel(glm::vec3 pos);
 
  [[Reflect]]
  void fillBox(glm::vec3 min, glm::vec3 max, int id, voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0);

  [[Reflect]]
  void fillRoundBox(
      glm::vec3 min, glm::vec3 max, float radius, int id, voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0
  );
 
  [[Reflect]]
  void fillSphere(glm::vec3 center, float radius, int id, voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0);

  [[Reflect]]
  void fillEllipsoid(glm::vec3 min, glm::vec3 max, int id, voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0);
 
  [[Reflect]]
  void fillCylinder(
      glm::vec3 a, glm::vec3 b, float radius, int id, voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0
  );
 
  [[Reflect]]
  void fillCapsule(
      glm::vec3 a, glm::vec3 b, float radius, int id, voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0
  );
 
  [[Reflect]]
  void carveBox(glm::vec3 min, glm::vec3 max);
 
  [[Reflect]]
  void carveSphere(glm::vec3 center, float radius);
 
  [[Reflect]]
  void paintBox(glm::vec3 min, glm::vec3 max, int id);

  [[Reflect]]
  void stamp(
      const assets::Handle<assets::VoxelModel>& asset, glm::vec3 pos, glm::quat rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f),
      voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0
  );

  [[Reflect]]
  void tile(
      const assets::Handle<assets::VoxelModel>& asset, int fit = 0, glm::vec3 anchor = glm::vec3(0.0f),
      glm::vec3 offset = glm::vec3(0.0f), glm::vec3 mirror = glm::vec3(0.0f), voxel::WriteMode mode = voxel::WriteMode::replace,
      int match_id = 0
  );
 
  // Piece

  [[Reflect]]
  void redraw();

  [[nodiscard, Reflect]]
  auto getShapeScript() const -> const assets::Handle<assets::Script>&;

  [[Reflect]]
  void setShapeScript(assets::Handle<assets::Script> script);

  [[nodiscard, Reflect]]
  auto getClipPlanes() const -> std::vector<glm::vec4>;
 
  [[Reflect]]
  void setClipPlanes(std::vector<glm::vec4> planes);

  [[Reflect]]
  void addClipPlane(glm::vec4 plane);
 
  [[Reflect]]
  void clearClipPlanes();

  [[nodiscard, Reflect]]
  auto getShapeBounds() -> std::vector<glm::vec3>;

  [[nodiscard, Reflect]]
  auto getShape() -> Box<Node>;

  [[nodiscard, Reflect]]
  auto isMisaligned() const noexcept -> bool {
    return m_misaligned;
  }
 
  signals::Signal<> drawn;    
 
                              // Backend
 
  [[nodiscard]]
  virtual auto kind() const noexcept -> PieceKind {
    return PieceKind::fill;
  }
 
  [[nodiscard]]
  virtual auto writeMode() const noexcept -> voxel::WriteMode {
    return voxel::WriteMode::replace;
  }
 
  [[nodiscard]]
  virtual auto matchId() const noexcept -> uint8_t {
    return 0;
  }

  [[nodiscard]]
  virtual auto sourcePaletteUid() const -> uint64_t {
    return 0;
  }
 
  struct Grid {
    std::shared_ptr<const Grid> base;
    std::unique_ptr<voxel::Volume> volume;
    std::array<uint32_t, voxel::k_palette_size> histogram {};
  };
 
  using GridRef = std::shared_ptr<const Grid>;

  [[nodiscard]]
  auto grid() -> const voxel::Volume*;

  [[nodiscard]]
  auto gridRef() -> GridRef;
 
  // Drawing on other threads
  // for the editor ONLY (dario im looking at you)

  void requestGrid();

  auto collectGrid() -> bool;

  [[nodiscard]]
  auto readyGrid() -> GridRef;

  [[nodiscard]]
  auto gridBuilding() const noexcept -> bool {
    return m_job.valid();
  }

  [[nodiscard]]
  auto gridStale() const noexcept -> bool {
    return m_grid_dirty || m_job.valid();
  }

  void waitForGrid();

  [[nodiscard]]
  auto inputRevision() const noexcept -> uint32_t {
    return m_input_revision;
  }

  [[nodiscard]]
  auto buildCount() const noexcept -> uint32_t {
    return m_build_count;
  }
 
  [[nodiscard]]
  auto clipPlanes() const noexcept -> const std::vector<glm::vec4>& {
    return m_clip_planes;
  }

  [[nodiscard]]
  auto nominalSize() -> glm::ivec3 {
    return pieceSize();
  }

  [[nodiscard]]
  virtual auto resizable() const noexcept -> bool {
    return false;
  }

  void releaseGrid();

  void setMisaligned(bool misaligned);
 
protected:
  [[nodiscard]]
  virtual auto pieceSize() -> glm::ivec3;

  [[nodiscard]]
  virtual auto prepareGrid() -> std::unique_ptr<voxel::Volume> = 0;

  virtual void finishGrid(voxel::Volume& /*grid*/) { }

  void markGridDirty() noexcept;

  void markLandingDirty() noexcept { ++m_input_revision; }
 
  void onReflectedFieldChanged(std::string_view field_name) override;
  void onScriptsReloading() override;
  void onScriptsReloaded() override;
  void onScriptVarChanged(std::string_view path) override;
  void updateInspectorMessages() override;
 
  template<typename Kernel>
  void draw(std::string_view operation, Kernel&& kernel);

  [[nodiscard]]
  auto drawing() const noexcept -> voxel::Volume*;
 
  void init();
  void destroy();

  [[Reflect, Name("Script")]]
  assets::Handle<assets::Script> m_shape_script;

  [[Reflect, Name("Clip Planes"), Group("Clip")]]
  std::vector<glm::vec4> m_clip_planes;
 
private:
  [[nodiscard]]
  auto drawGrid() -> GridRef;

  void landGrid(GridRef fresh);

  void applyClip();

  [[nodiscard]]
  auto latestGrid() -> const voxel::Volume*;
 
  GridRef m_drawn;
  GridRef m_grid;
  std::future<GridRef> m_job;
  bool m_grid_dirty = true;
  bool m_clip_dirty = true;
  bool m_misaligned = false;
  bool m_warned_outside_edit = false;
  uint32_t m_input_revision = 1;
  uint32_t m_build_count = 0;
};
 
}