shape.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "aabb.hpp"
#include "body.hpp"
#include "material_defaults.hpp"
 
#include <compare>
#include <cstdint>
#include <glm/glm.hpp>
#include <limits>
 
namespace physics {
 
struct PhysicsMaterial {
  float restitution = material_defaults::k_restitution;
  float static_friction = material_defaults::k_static_friction;
  float dynamic_friction = material_defaults::k_dynamic_friction;
  float rolling_friction = material_defaults::k_rolling_friction;
  float spin_friction = material_defaults::k_spin_friction;
};
 
struct ShapeID {
  uint32_t slot = std::numeric_limits<uint32_t>::max();
  uint32_t generation = 0;
  auto operator<=>(const ShapeID&) const = default;
};
 
enum class FeatureType : uint8_t {
  sphere_surface = 1,
  capsule_cap_a,
  capsule_side,
  capsule_cap_b,
  box_face,
  box_edge,
  box_vertex,
  box_clip,
  voxel_face,
  voxel_edge,
};
 
struct ContactFeatureID {
  uint64_t value = 0;
  auto operator<=>(const ContactFeatureID&) const = default;
};
 
inline constexpr uint64_t contact_feature_payload_mask = 0x00ff'ffff'ffff'ffffULL;
 
[[nodiscard]]
constexpr auto makeContactFeature(FeatureType type, uint64_t payload = 0) -> ContactFeatureID {
  return ContactFeatureID {(static_cast<uint64_t>(type) << 56) | (payload & contact_feature_payload_mask)};
}
 
[[nodiscard]]
constexpr auto capsuleFeature(float parameter) -> ContactFeatureID {
  if (parameter <= 0.0f) {
    return makeContactFeature(FeatureType::capsule_cap_a);
  }
  if (parameter >= 1.0f) {
    return makeContactFeature(FeatureType::capsule_cap_b);
  }
  return makeContactFeature(FeatureType::capsule_side);
}
 
[[nodiscard]]
constexpr auto boxFaceFeature(int axis, bool positive) -> ContactFeatureID {
  return makeContactFeature(FeatureType::box_face, static_cast<uint64_t>(axis) | (static_cast<uint64_t>(positive) << 2));
}
 
[[nodiscard]]
constexpr auto boxEdgeFeature(int direction_axis, uint8_t positive_mask) -> ContactFeatureID {
  return makeContactFeature(
      FeatureType::box_edge, static_cast<uint64_t>(direction_axis) | (static_cast<uint64_t>(positive_mask & 0x7u) << 2)
  );
}
 
[[nodiscard]]
constexpr auto boxVertexFeature(uint8_t positive_mask) -> ContactFeatureID {
  return makeContactFeature(FeatureType::box_vertex, positive_mask & 0x7u);
}
 
[[nodiscard]]
constexpr auto boxClipFeature(int reference_axis, bool reference_positive, int side_axis, bool side_positive)
    -> ContactFeatureID {
  uint64_t payload = static_cast<uint64_t>(reference_axis);
  payload |= static_cast<uint64_t>(reference_positive) << 2;
  payload |= static_cast<uint64_t>(side_axis) << 3;
  payload |= static_cast<uint64_t>(side_positive) << 5;
  return makeContactFeature(FeatureType::box_clip, payload);
}
 
[[nodiscard]]
constexpr auto voxelFeature(FeatureType type, uint32_t brick_slot, uint16_t local_index, uint8_t normal_index)
    -> ContactFeatureID {
  uint64_t payload = static_cast<uint64_t>(local_index) & 0x1FFu;
  payload |= (static_cast<uint64_t>(normal_index) & 0x1Fu) << 9;
  payload |= (static_cast<uint64_t>(brick_slot) & 0xFFFF'FFFFu) << 14;
  return makeContactFeature(type, payload);
}
 
struct VoxelFeaturePayload {
  uint32_t slot = 0;
  uint16_t local_index = 0;
  uint8_t normal_index = 0;
};
 
[[nodiscard]]
constexpr auto unpackVoxelFeature(ContactFeatureID id) -> VoxelFeaturePayload {
  const uint64_t payload = id.value & contact_feature_payload_mask;
  return {
    .slot = static_cast<uint32_t>((payload >> 14) & 0xFFFF'FFFFu),
    .local_index = static_cast<uint16_t>(payload & 0x1FFu),
    .normal_index = static_cast<uint8_t>((payload >> 9) & 0x1Fu),
  };
}
 
enum class ShapeType : uint8_t {
  sphere,
  box,
  capsule,
  voxel
};
 
struct SphereShape {
  glm::vec3 local_center = {};
  float radius = 0.5f;
};
 
struct BoxShape {
  glm::vec3 local_center = {};
  glm::quat local_rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
  glm::vec3 size = {1.0f, 1.0f, 1.0f};
};
 
struct CapsuleShape {
  glm::vec3 local_center = {};
  glm::quat local_rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
  float radius = 0.5f;
  float height = 1.0f;
};
 
struct VoxelDataID {
  uint32_t slot = std::numeric_limits<uint32_t>::max();
  uint32_t generation = 0;
  auto operator<=>(const VoxelDataID&) const = default;
};
 
struct VoxelShape {
  VoxelDataID data;
  glm::vec3 local_center = {};
  glm::quat local_rotation = {1.0f, 0.0f, 0.0f, 0.0f};
  AABB local_bounds = {};
};
 
struct Shape {
  BodyID owner;
  ShapeType type = ShapeType::sphere;
  bool enabled = true;
  PhysicsMaterial material;
 
  union {
    SphereShape sphere;
    BoxShape box;
    CapsuleShape capsule;
    VoxelShape voxel;
  };
 
  [[nodiscard]]
  auto getLocalCenter() const -> glm::vec3 {
    switch (type) {
      case ShapeType::sphere: return sphere.local_center;
      case ShapeType::box: return box.local_center;
      case ShapeType::capsule: return capsule.local_center;
      case ShapeType::voxel: return voxel.local_center;
    }
    return glm::vec3(0.0f);
  }
 
  [[nodiscard]]
  auto getLocalRotation() const -> glm::quat {
    switch (type) {
      case ShapeType::sphere: return {1.0f, 0.0f, 0.0f, 0.0f};
      case ShapeType::box: return box.local_rotation;
      case ShapeType::capsule: return capsule.local_rotation;
      case ShapeType::voxel: return voxel.local_rotation;
    }
    return {1.0f, 0.0f, 0.0f, 0.0f};
  }
};
 
struct ShapeSlot {
  Shape shape;
  uint32_t generation = 1;
  uint32_t revision = 1;
  bool occupied = false;
};
 
inline constexpr ContactFeatureID sphere_surface_feature = makeContactFeature(FeatureType::sphere_surface);
 
}