Mesh.h

Go to the documentation of this file.

#pragma once
 
#include "Core.h"
#include "Tags.h"
#include "MeshLayout.h"
 
#include <vector>
#include <span>
#include <SDL3/SDL_assert.h>
#include <entt/entity/registry.hpp>
#include <entt/entity/handle.hpp>
 
namespace candlewick {

class MeshView {
  friend class Mesh;
  MeshView() noexcept = default;
 
public:
  std::vector<SDL_GPUBuffer *> vertexBuffers;
  SDL_GPUBuffer *indexBuffer;

  Uint32 vertexOffset;
  Uint32 vertexCount;

  Uint32 indexOffset;
  Uint32 indexCount;
 
  bool isIndexed() const { return indexBuffer != nullptr; }
 
  MeshView(const MeshView &parent, Uint32 subVertexOffset,
           Uint32 vertexSubCount, Uint32 subIndexOffset, Uint32 indexSubCount);
};

class Mesh {
  SDL_GPUDevice *m_device{nullptr};
  std::vector<MeshView> m_views;
  MeshLayout m_layout;
 
public:
  Uint32 vertexCount;
  Uint32 indexCount{0u};

  std::vector<SDL_GPUBuffer *> vertexBuffers;

  SDL_GPUBuffer *indexBuffer{nullptr};
 
  explicit Mesh(const Device &device, const MeshLayout &layout);
 
  const MeshLayout &layout() const { return m_layout; }
 
  Mesh(NoInitT);
  Mesh(const Mesh &) = delete;
  Mesh(Mesh &&other) noexcept;
 
  Mesh &operator=(const Mesh &) = delete;
  Mesh &operator=(Mesh &&other) noexcept;
 
  const MeshView &view(size_t i) const { return m_views[i]; }
  std::span<const MeshView> views() const { return m_views; }
  size_t numViews() const { return m_views.size(); }

  MeshView &addView(Uint32 vertexOffset, Uint32 vertexSubCount,
                    Uint32 indexOffset, Uint32 indexSubCount);

  Mesh &bindVertexBuffer(Uint32 slot, SDL_GPUBuffer *buffer);

  Mesh &setIndexBuffer(SDL_GPUBuffer *buffer);

  Uint32 numVertexBuffers() const {
    return static_cast<Uint32>(vertexBuffers.size());
  }
 
  bool isIndexed() const { return indexBuffer != nullptr; }

  void release() noexcept;
  ~Mesh() noexcept { release(); }
 
  SDL_GPUBufferBinding getVertexBinding(Uint32 slot) const {
    return {.buffer = vertexBuffers[slot], .offset = 0u};
  }
 
  SDL_GPUBufferBinding getIndexBinding() const {
    return {.buffer = indexBuffer, .offset = 0u};
  }
};

[[nodiscard]] inline bool validateMesh(const Mesh &mesh) {
  if (!validateMeshLayout(mesh.layout()))
    return false;
  if (mesh.views().size() == 0)
    return false;
  for (size_t i = 0; i < mesh.numVertexBuffers(); i++) {
    if (!mesh.vertexBuffers[i])
      return false;
  }
  // check that if we are indexed iff we have positive index count.
  return mesh.isIndexed() == (mesh.indexCount > 0);
}

[[nodiscard]] inline bool validateMeshView(const MeshView &view) {
  for (auto vb : view.vertexBuffers) {
    if (!vb)
      return false;
  }
  // views of indexed meshes cannot have zero indices.
  if (view.isIndexed() != (view.indexCount > 0))
    return false;
  return view.vertexCount > 0;
}
 
} // namespace candlewick