palette.hpp

Go to the documentation of this file.

 
#pragma once
#include "voxel_constants.hpp"
 
#include <array>
#include <cstdint>
#include <toast/physics/fracture_profile.hpp>
#include <toast/physics/hardness.hpp>
#include <toast/physics/material_defaults.hpp>
#include <vector>
 
namespace voxel {
 
inline constexpr uint32_t k_max_physical_materials = 256;
 
inline constexpr uint8_t k_default_material = 0;
 
inline constexpr uint8_t k_entry_transparent = 1u << 0;

struct PaletteEntry {
  uint8_t albedo_r = 0;
  uint8_t albedo_g = 0;
  uint8_t albedo_b = 0;

  uint8_t roughness = 0;
  uint8_t metallic = 0;

  uint8_t reflectivity = 0;

  uint8_t emissive = 0;
 
  uint8_t material = k_default_material;
 
  uint8_t flags = 0;

  uint8_t transforms_to = 0;
 
  uint8_t alpha = 255;
 
  std::array<uint8_t, 5> reserved {};
 
  [[nodiscard]]
  constexpr auto operator==(const PaletteEntry&) const noexcept -> bool = default;
};
 
static_assert(sizeof(PaletteEntry) == 16, "a palette entry must be sixteen bytes - the shader indexes it that way");

struct Palette {
  std::array<PaletteEntry, k_palette_size> entries {};
 
  float max_emissive = 1.0f;
 
  uint32_t revision = 0;
};
 
[[nodiscard]]
inline auto defaultPalette() -> const Palette& {
  static const Palette palette = [] {
    Palette out;
    for (uint32_t i = 1; i < k_palette_size; ++i) {
      out.entries[i].albedo_r = 160;
      out.entries[i].albedo_g = 160;
      out.entries[i].albedo_b = 160;
      out.entries[i].roughness = 200;
    }
    return out;
  }();
  return palette;
}
 
[[nodiscard]]
inline auto emissiveIntensity(const Palette& palette, uint8_t index) noexcept -> float {
  return static_cast<float>(palette.entries[index].emissive) / 255.0f * palette.max_emissive;
}
 
inline constexpr uint8_t k_material_indestructible = 1u << 0;

inline constexpr uint8_t k_material_passable = 1u << 1;
 
inline constexpr uint8_t k_material_flammable = 1u << 2;
 
struct PhysicalMaterial {
  uint16_t density = static_cast<uint16_t>(physics::material_defaults::k_density);
 
  uint8_t flags = 0;

  physics::Hardness hardness = physics::material_defaults::k_hardness;
  physics::FracturePattern fracture_pattern = physics::material_defaults::k_fracture_pattern;
  physics::PackedFractureProfile fracture_profile = physics::material_defaults::k_fracture_profile;

  float toughness = physics::material_defaults::k_toughness;
 
  float structural_strength = physics::material_defaults::k_structural_strength;
 
  float static_friction = physics::material_defaults::k_static_friction;
  float dynamic_friction = physics::material_defaults::k_dynamic_friction;
  float restitution = physics::material_defaults::k_restitution;
  float rolling_friction = physics::material_defaults::k_rolling_friction;
  float spin_friction = physics::material_defaults::k_spin_friction;
 
  float ignition_energy = 0.0f;
  float burn_rate = 0.0f;
  float fuel = 0.0f;
 
  [[nodiscard]]
  constexpr auto isIndestructible() const noexcept -> bool {
    return (flags & k_material_indestructible) != 0;
  }
 
  [[nodiscard]]
  constexpr auto breakableBy(physics::Hardness max_hardness) const noexcept -> bool {
    return not isIndestructible() && physics::canBreak(max_hardness, hardness);
  }
 
  [[nodiscard]]
  constexpr auto collides() const noexcept -> bool {
    return (flags & k_material_passable) == 0;
  }
 
  [[nodiscard]]
  constexpr auto isFlammable() const noexcept -> bool {
    return (flags & k_material_flammable) != 0;
  }
};
 
static_assert(sizeof(PhysicalMaterial) <= 64, "a physical material must fit in one cache line");
 
struct MaterialLibrary {
  std::vector<PhysicalMaterial> materials;
};

[[nodiscard]]
inline auto resolveMaterialIndex(const Palette& palette, const MaterialLibrary& library, uint8_t palette_index) noexcept
    -> uint32_t {
  const uint8_t material = palette.entries[palette_index].material;
  return material < library.materials.size() ? material : k_default_material;
}
 
[[nodiscard]]
inline auto densityTable(const Palette& palette, const MaterialLibrary& library) -> std::array<uint32_t, k_palette_size> {
  std::array<uint32_t, k_palette_size> out {};
  for (uint32_t i = 0; i < k_palette_size; ++i) {
    out[i] = library.materials[resolveMaterialIndex(palette, library, static_cast<uint8_t>(i))].density;
  }
  return out;
}
 
[[nodiscard]]
inline auto massPerVoxel(const PhysicalMaterial& material, float voxel_size = k_voxel_size) noexcept -> float {
  return static_cast<float>(material.density) * voxel_size * voxel_size * voxel_size;
}
 
enum class TableIssue : uint8_t {
  library_empty,
  library_too_large,
  zero_density,
  out_of_range,
  reserved_slot_used,
  unknown_material,
};

struct TableProblem {
  TableIssue issue = TableIssue::library_empty;
  uint32_t index = 0;
 
  [[nodiscard]]
  constexpr auto operator==(const TableProblem&) const noexcept -> bool = default;
};
 
[[nodiscard]]
inline auto validateLibrary(const MaterialLibrary& library) -> std::vector<TableProblem> {
  std::vector<TableProblem> out;
  if (library.materials.empty()) {
    out.push_back({TableIssue::library_empty, 0});
    return out;
  }
  if (library.materials.size() > k_max_physical_materials) {
    out.push_back({TableIssue::library_too_large, static_cast<uint32_t>(library.materials.size())});
  }
 
  // !(x >= 0) also catches NaN
  const auto negative = [](float value) { return !(value >= 0.0f); };
 
  for (uint32_t i = 0; i < library.materials.size(); ++i) {
    const PhysicalMaterial& m = library.materials[i];
    if (m.density == 0) {
      out.push_back({TableIssue::zero_density, i});
    }
    if (negative(m.toughness) || negative(m.structural_strength) || negative(m.static_friction) || negative(m.dynamic_friction) ||
        negative(m.rolling_friction) || negative(m.spin_friction) || negative(m.restitution) || m.restitution > 1.0f ||
        negative(m.ignition_energy) || negative(m.burn_rate) || negative(m.fuel)) {
      out.push_back({TableIssue::out_of_range, i});
    }
  }
  return out;
}
 
[[nodiscard]]
inline auto validatePalette(const Palette& palette, const MaterialLibrary& library) -> std::vector<TableProblem> {
  std::vector<TableProblem> out;
  if (!(palette.entries[k_empty_palette_index] == PaletteEntry {})) {
    out.push_back({TableIssue::reserved_slot_used, k_empty_palette_index});
  }
  if (library.materials.empty()) {
    out.push_back({TableIssue::library_empty, 0});
    return out;
  }
  for (uint32_t i = 1; i < k_palette_size; ++i) {
    if (palette.entries[i].material >= library.materials.size()) {
      out.push_back({TableIssue::unknown_material, i});
    }
  }
  return out;
}
 
}