procedural_voxel.hpp

Go to the documentation of this file.

 
#pragma once
#include "voxel_bucket.hpp"
#include "voxel_group.hpp"
#include "voxel_node.hpp"
#include "voxel_piece.hpp"
#include "voxel_volume.hpp"
 
#include <cstdint>
#include <future>
#include <memory>
#include <optional>
#include <span>
#include <toast/voxel/stamp.hpp>
#include <toast/voxel/voxel_edit.hpp>
#include <unordered_map>
#include <vector>
 
namespace event {
struct ProceduralVoxelLayout;
}
 
namespace toast {

class [[ToastNode, Color("Magenta")]] TOAST_API ProceduralVoxel : public VoxelNode {
public:
  struct PieceLayout {
    Box<Node> node;
    PieceKind kind = PieceKind::fill;
    voxel::LatticePlacement placement;
    voxel::EditBounds bounds;    
    glm::vec4 average_color {0.0f};
  };

  [[nodiscard]]
  auto layout() const noexcept -> const std::vector<PieceLayout>& {
    return m_layout;
  }

  [[Reflect, Button("Rebuild")]]
  void rebuild();

  [[Reflect, Button("Bake"), EditorAction("voxel_editor.bake")]]
  void bakeVoxel() { }

  void sendLayout();

  [[nodiscard, Reflect]]
  auto getPieceAt(glm::vec3 pos) -> Box<Node>;

  [[nodiscard, Reflect]]
  auto getPieceCount() const noexcept -> int {
    return static_cast<int>(m_layout.size());
  }

  [[nodiscard]]
  auto pickPiece(glm::vec3 origin, glm::vec3 direction) -> VoxelPiece*;

  [[nodiscard]]
  auto pieceAt(glm::ivec3 voxel) -> VoxelPiece*;

  void keepGrids(bool keep) noexcept { m_keep_grids = keep; }
 
  struct Composed {
    voxel::Volume volume;
    glm::ivec3 origin {0};    
  };

  [[nodiscard]]
  auto composePieces(std::span<VoxelPiece* const> only) -> std::optional<Composed>;
 
protected:
  void buildShape() override;
  auto shapeKey() -> uint64_t override;
  auto buildsAsync() -> bool override;
  void tickAsyncBuild() override;

  void drawDebug() override;
 
  void end();
  void destroy();
 
private:
  struct Collected {
    VoxelPiece* piece = nullptr;
    glm::mat4 to_root {1.0f};
  };

  struct Landing {
    VoxelPiece* piece = nullptr;    
    VoxelPiece::GridRef grid;
    voxel::LatticePlacement placement;
    voxel::PaletteRemapTable remap {};
    PieceKind kind = PieceKind::fill;
    voxel::WriteMode mode = voxel::WriteMode::replace;
    uint8_t match_id = 0;
  };
 
  struct ComposeInput;
  struct ComposeOutput;
 
  void collect(Node& node, const glm::mat4& to_root, std::vector<Collected>& out);
 
  struct BucketFill {
    VoxelBucket* bucket = nullptr;
    glm::ivec3 seed {0};
  };

  void collectBuckets(Node& node, const glm::mat4& to_root, std::vector<BucketFill>& out);

  [[nodiscard]]
  auto land(const std::vector<Collected>& pieces, bool wait) -> std::vector<Landing>;

  static auto apply(voxel::Volume& target, const Landing& landing, glm::ivec3 origin) -> voxel::EditResult;

  [[nodiscard]]
  static auto compose(const ComposeInput& input) -> std::shared_ptr<ComposeOutput>;
 
  [[nodiscard]]
  auto keyOf(const std::vector<Collected>& pieces) -> uint64_t;

  [[nodiscard]]
  auto layoutOf(const std::vector<Landing>& landings) -> std::vector<PieceLayout>;

  void launchCompose(const std::vector<Collected>& pieces);

  void applyComposed(ComposeOutput& output);
 
  [[nodiscard]]
  auto averageColor(const Landing& landing) -> glm::vec3;
 
  [[nodiscard]]
  auto remapFor(const VoxelPiece& piece) -> voxel::PaletteRemapTable;
 
  [[nodiscard]]
  auto toolPiece() -> VoxelPiece*;
 
  std::unique_ptr<voxel::Volume> m_highlight;
  UID m_highlight_for;
 
  std::vector<PieceLayout> m_layout;
  std::vector<PieceLayout> m_pending_layout;
  bool m_keep_grids = false;
 
  std::future<std::shared_ptr<ComposeOutput>> m_compose_job;
  std::shared_ptr<ComposeOutput> m_last_compose;
  bool m_compose_wanted = false;
  bool m_pending_projections = false;
 
  struct CachedRemap {
    voxel::PaletteRemapTable table {};
    uint64_t target_uid = 0;
    uint32_t source_revision = 0;
    uint32_t target_revision = 0;
  };
 
  std::unordered_map<uint64_t, CachedRemap> m_remaps;
};

[[nodiscard]]
TOAST_API auto insideProceduralVoxel(Node& node) -> bool;

[[nodiscard]]
TOAST_API auto owningProceduralVoxel(Node& node) -> ProceduralVoxel*;
 
// Placing pieces, everything in shape voxels

[[nodiscard]]
TOAST_API auto parentToShape(Node& node) -> glm::mat4;

[[nodiscard]]
TOAST_API auto piecePlacement(VoxelPiece& piece) -> voxel::LatticePlacement;

[[nodiscard]]
TOAST_API auto pieceBounds(VoxelPiece& piece) -> voxel::EditBounds;

TOAST_API void placePiece(VoxelPiece& piece, const voxel::LatticeOrientation& orientation, glm::ivec3 min, glm::ivec3 max);

[[nodiscard]]
TOAST_API auto planeToShape(glm::vec4 plane, const voxel::LatticePlacement& placement) noexcept -> glm::vec4;

[[nodiscard]]
TOAST_API auto planeToPiece(glm::vec4 plane, const voxel::LatticePlacement& placement) noexcept -> glm::vec4;
 
}