mesh.hpp

Go to the documentation of this file.

 
#pragma once
#include "core_types.hpp"
 
#include <glm/glm.hpp>
#include <memory>
#include <toast/export.hpp>
#include <toast/log.hpp>
#include <toast/renderer/vertex.hpp>
 
namespace renderer {
class VulkanMesh;
}
 
namespace assets {
 
namespace _detail {
 
inline constexpr uint16_t mesh_format_version = 7;

struct MeshFileHeader {
  std::array<uint8_t, 6> magic = {'T', 'M', 'E', 'S', 'H', '\0'};
  // Defaulted from the constant rather than repeating the number: these two drifted apart once already
  // (writer stamped 5, reader accepted only 4) and every mesh in the project silently failed to load
  uint16_t version = mesh_format_version;
  uint32_t vertex_count = 0;
  uint32_t index_count = 0;
};
}

TOAST_API void generateTangents(std::vector<renderer::Vertex>& vertices, const std::vector<uint32_t>& indices);
 
class TOAST_API Mesh final : public Asset {
public:
  using Index = uint32_t;
 
  explicit Mesh(const std::vector<uint8_t>& data);
  Mesh(std::string_view name, std::vector<renderer::Vertex>&& vertices, std::vector<uint32_t>&& indices);
  Mesh(
      std::string_view name, std::vector<renderer::Vertex>&& vertices, std::vector<uint32_t>&& indices,
      std::vector<renderer::SkinVertex>&& skin_vertices
  );
  ~Mesh() override;
 
  [[nodiscard]]
  auto type() const -> std::string_view override {
    return "mesh";
  }
 
  [[nodiscard]]
  auto vertices() const -> const std::vector<renderer::Vertex>& {
    return m_vertices;
  }
 
  [[nodiscard]]
  auto indices() const -> const std::vector<Index>& {
    return m_indices;
  }

  [[nodiscard]]
  auto skinVertices() const -> const std::vector<renderer::SkinVertex>& {
    return m_skin_vertices;
  }
 
  [[nodiscard]]
  auto isSkinned() const noexcept -> bool {
    return !m_skin_vertices.empty();
  }

  [[nodiscard]]
  auto boundingSphere() const -> const glm::vec4&;
 
  [[nodiscard]]
  auto gpuMesh() const -> const renderer::VulkanMesh&;
 
  [[nodiscard]]
  auto gpuMesh() -> renderer::VulkanMesh&;
 
  [[nodiscard]]
  auto name() const -> const std::string& {
    return m_name;
  }
 
  [[nodiscard]]
  auto toBinary() const -> std::vector<uint8_t>;
 
private:
  std::string m_name;
  std::vector<renderer::Vertex> m_vertices;
  std::vector<Index> m_indices;
  std::vector<renderer::SkinVertex> m_skin_vertices;
 
  mutable std::optional<glm::vec4> m_bounding_sphere;
 
  std::unique_ptr<renderer::VulkanMesh> m_gpu_mesh;
};
 
}