voxel_node.hpp

Go to the documentation of this file.

 
#pragma once
#include "voxel.hpp"
 
#include <algorithm>
#include <cstdint>
#include <memory>
#include <optional>
#include <toast/assets/types.hpp>
#include <toast/physics/body.hpp>
#include <toast/physics/collision.hpp>
#include <toast/voxel/stamp.hpp>
#include <toast/voxel/voxel_edit.hpp>
#include <vector>
 
namespace assets {
class VoxelModel;
class VoxelPalette;
class PhysicsMaterial;
}
 
namespace physics {
class Simulator;
}
 
namespace toast {
 
namespace _detail {

[[nodiscard]]
inline auto toVoxel(glm::vec3 pos) noexcept -> glm::ivec3 {
  return {glm::floor(pos)};
}

[[nodiscard]]
inline auto toId(int id) noexcept -> uint8_t {
  return static_cast<uint8_t>(std::clamp(id, 0, 255));
}
 
}

enum class SimulationType : uint8_t {
  static_body = 0,    
  kinematic = 1,      
  dynamic = 2,        
};

class [[ToastNode, Icon("BoxMesh")]] TOAST_API VoxelNode : public Voxel {
  friend class physics::Simulator;
 
public:
  VoxelNode() = default;

  VoxelNode(assets::Handle<assets::VoxelModel> model) : m_model(std::move(model)) { }
 
  // Where the shape comes from

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

  [[nodiscard]]
  auto getModel() -> assets::Handle<assets::VoxelModel>&;

  [[Reflect]]
  void setModel(assets::Handle<assets::VoxelModel> model);

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

  [[Reflect]]
  void setPalette(assets::Handle<assets::VoxelPalette> palette);

  [[nodiscard, Reflect]]
  auto paletteUid() const -> uint64_t;

  [[nodiscard]]
  auto resolvedModel() const -> const assets::VoxelModel*;

  [[nodiscard]]
  auto resolvedPalette() -> const voxel::Palette*;

  [[nodiscard]]
  auto resolvedMaterialLibrary() -> const voxel::MaterialLibrary*;
 
  // Building the shape

  // [[Reflect]]
  // void editShape() { }
 
  // Reading voxels

  [[Reflect]]
  auto getVoxel(glm::vec3 pos) -> int;

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

  [[Reflect]]
  auto getBounds() -> std::vector<glm::vec3>;

  [[Reflect]]
  auto getVoxelCount() -> int;

  [[Reflect]]
  auto worldToVoxel(glm::vec3 pos) -> glm::vec3;

  [[Reflect]]
  auto voxelToWorld(glm::vec3 pos) -> glm::vec3;
 
  // Writing voxels
  //
  // Adding voxels grows the shape on its own
  // Writes with a mode use it to pick what they may overwrite
  //   - replace: Just replaces every voxel
  //   - empty_only: Doesn't touch voxels with a Palette ID different than 0
  //   - solid_only: Doesn't touch empty voxels
  //   - match: Passing an extra palette ID (match_id), it replaces every voxel of that ID

  [[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 fillSphere(glm::vec3 center, float radius, 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 fillLine(
      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 setLayers(int included_layers, int excluded_layers);
 
  [[Reflect]]
  void includeLayer(int layer, bool value = true);
 
  [[Reflect]]
  void excludeLayer(int layer, bool value = true);

  [[Reflect]]
  void carveCylinder(glm::vec3 a, glm::vec3 b, float radius);

  [[Reflect]]
  void carveLine(glm::vec3 a, glm::vec3 b, float radius);

  [[Reflect]]
  void paintBox(glm::vec3 min, glm::vec3 max, int id);

  [[Reflect]]
  void paintSphere(glm::vec3 center, float radius, int id);

  [[Reflect]]
  void replaceId(int from, int to);

  [[Reflect]]
  void slice(glm::vec3 point, glm::vec3 normal, int side);

  [[Reflect]]
  void extrudeFace(glm::vec3 pos, glm::vec3 normal, int distance);

  [[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]]
  auto copy(glm::vec3 min, glm::vec3 max) -> int;

  [[Reflect]]
  void paste(int region, glm::vec3 pos, voxel::WriteMode mode = voxel::WriteMode::replace, int match_id = 0);

  [[Reflect]]
  void clearRegions();
 
  // Shape signals
 
  signals::Signal<> rebuilt_shape;            
  signals::Signal<int, glm::vec3> damaged;    
  signals::Signal<int> broke_apart;           
  signals::Signal<> emptied;                  
 
  // Physics
 
  signals::Signal<toast::Box<toast::Node>> contact_begin;    
  signals::Signal<toast::Box<toast::Node>> contact_end;      
  signals::Signal<> went_to_sleep;                           
  signals::Signal<> woke_up;                                 

  [[Reflect]]
  void sleep();

  [[Reflect]]
  void wake();
 
  // Editor

  [[Reflect, Button("Edit Voxel"), EditorAction("voxel_editor.open")]]
  void editVoxel() { }
 
  // Backend
 
  [[nodiscard]]
  auto volume() -> voxel::Volume*;
 
  [[nodiscard]]
  auto revision() const noexcept -> uint32_t {
    return m_revision;
  }
 
  [[nodiscard]]
  auto voxelOrigin() const noexcept -> glm::ivec3 {
    return m_voxel_origin;
  }
 
  [[nodiscard]]
  auto volumeLocalTransform() const -> glm::mat4;
 
  [[nodiscard, Reflect]]
  auto localBoundingSphere() const -> glm::vec4;
 
  [[nodiscard]]
  auto latticePlacement() const -> std::optional<voxel::LatticePlacement>;
 
  [[nodiscard]]
  auto renderOnly() const noexcept -> bool {
    return render_only;
  }
 
protected:
  virtual void buildShape() { }

  [[nodiscard]]
  virtual auto shapeKey() -> uint64_t {
    return 0;
  }

  void requestRebuild() noexcept { m_rebuild_requested = true; }

  [[nodiscard]]
  virtual auto buildsAsync() -> bool {
    return false;
  }
 
  virtual void tickAsyncBuild() { }
 
  void finishShape();
 
  void init();
  void begin();
  void end();
  void destroy();
  void onEnable();
  void onDisable();
  void editorTick();
  void earlyTick();
  void postPhysics();
  void onReflectedFieldChanged(std::string_view field_name) override;
  void onScriptsReloaded() override;
  void updateInspectorMessages() override;
  void onEditorTransformChanged() override;
  virtual void drawDebug();
 
  void refreshVolume();
  void releaseVolume();
  void retireVolume();
  void recordDamage(uint32_t count, glm::vec3 index_sum);

  auto ensureContains(const voxel::EditBounds& bounds) -> voxel::Volume*;

  auto replaceVolume(const voxel::EditBounds& bounds) -> voxel::Volume*;

  template<typename Kernel>
  void edit(const voxel::EditBounds& local_bounds, bool grows, std::string_view operation, Kernel&& kernel);

  void commitEdit(const voxel::EditResult& result, std::string_view operation);
 
  [[nodiscard]]
  auto toIndex(glm::ivec3 local) const noexcept -> glm::ivec3 {
    return local - m_voxel_origin;
  }
 
  [[nodiscard]]
  auto toIndex(glm::vec3 local) const noexcept -> glm::vec3 {
    return local - glm::vec3(m_voxel_origin);
  }
 
  [[nodiscard]]
  auto toIndex(const voxel::EditBounds& local) const noexcept -> voxel::EditBounds {
    return {local.min - m_voxel_origin, local.max - m_voxel_origin};
  }
 
  struct ActiveContact {
    physics::BodyID other_body;
    toast::Box<toast::Node> other_node;
    uint32_t shape_pair_count = 0;
  };
 
  [[nodiscard]]
  auto physicsBound() const noexcept -> bool {
    return m_body != physics::BodyID {};
  }
 
  void assignBody(physics::BodyID body) noexcept { m_body = body; }
 
  void assignShape(physics::ShapeID shape) noexcept { m_shape = shape; }
 
  [[nodiscard]]
  auto bodyID() const noexcept -> physics::BodyID {
    return m_body;
  }
 
  [[nodiscard]]
  auto shapeID() const noexcept -> physics::ShapeID {
    return m_shape;
  }
 
  void handleContactBegin(const physics::BroadPhasePair& pair);
  void handleContactEnd(const physics::BroadPhasePair& pair);
 
  void applyPhysicsTransform(const glm::vec3& position, const glm::quat& rotation);
  void publishPhysicsState(bool is_awake, const glm::vec3& current_linear_velocity, const glm::vec3& current_angular_velocity);
 
  // Inspector
 
  [[Reflect]]
  assets::Handle<assets::VoxelModel> m_model;
 
  [[Reflect, Name("Palette Override")]]
  assets::Handle<assets::VoxelPalette> m_palette;

  [[Reflect, Name("Simulation Type"), Enum("Static", "Kinematic", "Dynamic")]]
  SimulationType simulation_type = SimulationType::dynamic;
 
  [[Reflect, ReadOnly, Unit("kg")]]
  float mass = 0.0f;

  [[Reflect, Group("Physics")]]
  bool render_only = false;
 
  [[Reflect, Group("Physics"), Layers("excluded"), Name("Layers")]]
  uint32_t included = 1;    // Default
 
  [[Reflect, Group("Physics"), LayersExcluded]]
  uint32_t excluded = 0;
 
  [[Reflect, Group("Physics")]]
  bool allow_sleep = true;
 
  [[Reflect, Group("Physics"), ReadOnly]]
  bool awake = true;
 
  [[Reflect, Group("Physics")]]
  float gravity_scale = 1.0f;

  [[Reflect, Group("Physics")]]
  bool auto_mass_center = true;
 
  [[Reflect, Group("Physics"), Unit("m"), ReadOnly("auto_mass_center")]]
  glm::vec3 center_of_mass = {};
 
  [[Reflect, Group("Physics"), Unit("kg•m²"), ReadOnly("auto_mass_center")]]
  glm::vec3 inertia = {};
 
  [[Reflect, Group("Physics"), Subgroup("Drag"), Unit("1/s")]]
  float linear_damping = 0.0f;
  [[Reflect, Group("Physics"), Subgroup("Drag"), Unit("1/s")]]
  float angular_damping = 0.0f;
  [[Reflect, Group("Physics"), Subgroup("Drag")]]
  float drag_scale = 1.0f;
 
  [[Reflect, Group("Physics"), Subgroup("Velocities"), Unit("m/s"), ReadOnly]]
  glm::vec3 linear_velocity = {};
  [[Reflect, Group("Physics"), Subgroup("Velocities"), Unit("rad/s"), ReadOnly]]
  glm::vec3 angular_velocity = {};
 
  [[Reflect, Group("Physics"), Subgroup("Constant Forces"), Unit("N"), ReadOnly]]
  glm::vec3 constant_force = {};
  [[Reflect, Group("Physics"), Subgroup("Constant Forces"), Unit("N•m"), ReadOnly]]
  glm::vec3 constant_torque = {};
 
  [[Reflect, Name("Lock X"), Group("Physics"), Subgroup("Position Locks"), ReadOnly]]
  bool lock_pos_x = false;
  [[Reflect, Name("Lock Y"), Group("Physics"), Subgroup("Position Locks"), ReadOnly]]
  bool lock_pos_y = false;
  [[Reflect, Name("Lock Z"), Group("Physics"), Subgroup("Position Locks"), ReadOnly]]
  bool lock_pos_z = false;
  [[Reflect, Name("Lock X"), Group("Physics"), Subgroup("Rotation Locks"), ReadOnly]]
  bool lock_rot_x = false;
  [[Reflect, Name("Lock Y"), Group("Physics"), Subgroup("Rotation Locks"), ReadOnly]]
  bool lock_rot_y = false;
  [[Reflect, Name("Lock Z"), Group("Physics"), Subgroup("Rotation Locks"), ReadOnly]]
  bool lock_rot_z = false;
 
  [[Reflect, Name("Show AABB"), Group("AABB")]]
  bool show_aabb = false;
 
  [[Reflect, Color, Name("AABB Color"), Group("AABB")]]
  glm::vec4 aabb_color = glm::vec4(1.0f, 0.75f, 0.15f, 0.6f);

  [[Reflect, Name("Fill Shape"), Group("AABB")]]
  bool aabb_fill = false;
 
  std::unique_ptr<voxel::Volume> m_volume;
  std::vector<std::unique_ptr<voxel::Volume>> m_retired_volumes;
  glm::ivec3 m_voxel_origin {0};
  uint32_t m_revision = 0;
  const assets::VoxelModel* m_instanced_from = nullptr;
  assets::Handle<assets::VoxelPalette> m_model_palette;
  std::vector<std::optional<voxel::Region>> m_regions;
 
  bool m_volume_stale = false;
  bool m_rebuild_requested = false;
  bool m_edit_shape_pending = false;
  bool m_split_pending = false;
  bool m_building_shape = false;
 
  struct PendingEvents {
    uint32_t damaged_voxels = 0;
    glm::vec3 damaged_sum {0.0f};
    std::vector<int> broken_pieces;
    bool emptied = false;
  };
 
  PendingEvents m_pending_events;
 
  physics::BodyID m_body;
  physics::ShapeID m_shape;
  std::vector<ActiveContact> m_active_contacts;
  bool m_registration_requested = false;
 
  bool m_registered_proxy = false;
  bool m_debug_visible = false;
  uint64_t m_shape_key = 0;
 
  uint64_t m_reported_wrong_model = 0;
  uint64_t m_reported_wrong_palette = 0;
};
 
}