Mesh.h

// Copyright (c) 2024 Michael Carlie. All Rights Reserved.
//
// This software is released under the MIT License.
// https://opensource.org/licenses/MIT
 
#ifndef INCLUDE_VULKANENGINE_MESH_H_
#define INCLUDE_VULKANENGINE_MESH_H_
 
#include <VulkanEngine/IndexAttribute.h>
#include <VulkanEngine/MeshBase.h>
#include <VulkanEngine/VertexAttribute.h>
 
#include <Eigen/Eigen>
#include <memory>
#include <tuple>
#include <vector>
 
namespace VulkanEngine {
 
template <
    typename PositionType,              // NOLINT(whitespace/indent_namespace)
    typename IndexType,                 // NOLINT(whitespace/indent_namespace)
    class... AdditionalAttributeTypes>  // NOLINT(whitespace/indent_namespace)
class Mesh : public MeshBase {
  static_assert(sizeof(IndexType) == sizeof(uint16_t) ||
                    sizeof(IndexType) == sizeof(uint32_t),
                "Mesh IndexType template parameter must be the same size as "
                "either uint16_t or uint32_t");
 
 public:
  template <typename T>
  using AttributeContainer = std::vector<std::shared_ptr<VertexAttribute<T>>>;
 
  Mesh();
 
  Mesh(const std::shared_ptr<VertexAttribute<PositionType>>& _positions,
       const std::shared_ptr<IndexAttribute<IndexType>>& _indices,
       const std::tuple<AttributeContainer<AdditionalAttributeTypes>...>&
           _attributes,
       const std::shared_ptr<Shader>& _shader);
 
  virtual ~Mesh();
 
  void setPositions(
      const std::shared_ptr<VertexAttribute<PositionType>>& _positions);
 
  void setIndices(const std::shared_ptr<IndexAttribute<IndexType>>& _indices);
 
  void setAttributes(
      const std::tuple<AttributeContainer<AdditionalAttributeTypes>...>&
          _attributes);
 
  void setBoundingBox(const PositionType& max, const PositionType& min);
 
  virtual const vk::PipelineVertexInputStateCreateInfo&
  createVkPipelineVertexInputStateCreateInfo();
 
  virtual const vk::PipelineInputAssemblyStateCreateInfo&
  createVkPipelineInputAssemblyStateCreateInfo();
 
  virtual void transferBuffers(
      const vk::CommandBuffer& command_buffer = nullptr);
 
  virtual void bindVertexBuffers(const vk::CommandBuffer& command_buffer);
 
  virtual void bindIndexBuffer(const vk::CommandBuffer& command_buffer);
 
  virtual void draw(const vk::CommandBuffer& command_buffer);
 
 private:
  std::shared_ptr<VertexAttribute<PositionType>> positions;
 
  std::shared_ptr<IndexAttribute<IndexType>> indices;
 
  std::tuple<AttributeContainer<AdditionalAttributeTypes>...> attributes;
 
  std::vector<vk::VertexInputBindingDescription> binding_descriptions;
 
  std::vector<vk::VertexInputAttributeDescription> attribute_descriptions;
 
  vk::PipelineVertexInputStateCreateInfo pipeline_vertex_input_state_info;
 
  vk::PipelineInputAssemblyStateCreateInfo pipeline_input_assembly_state_info;
 
  bool pipeline_input_state_info_initialized;
};
 
}  // namespace VulkanEngine
 
#include <Mesh.cpp>  // NOLINT(build/include)
 
#endif  // INCLUDE_VULKANENGINE_MESH_H_