Mesh.h

#pragma once
 
#include "VertexFormats.h"
#include "MeshStreamsLayout.h"
#include "ResourceBase.h"
#include "Resources.h"
 
#include "Rendering/Common.h"
#include "Rendering/VertexFormat.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <array>
#include <cstdint>
#include <span>
#include <vector>
 
namespace Cogs::Core
{
  struct VertexDataType
  {
    enum EVertexDataType : uint8_t
    {
      Positions = 0,
      Normals,
      Tangents,
      Bitangents,
      TexCoords0,
      TexCoords1,
      TexCoords2,
      Colors0,
      Colors1,
      Colors2,
      Colors3,
      Interleaved0,
      Interleaved1,
      LastVertexType,
      Indexes = LastVertexType,
      PoseIndexes,
      SubMeshes,
      Reserved
    };
  };
 
  struct MeshFlags
  {
    enum EMeshFlags : uint16_t
    {
      None = 0x0000,
      StreamsChanged = 0x0001,
      IndexesChanged = 0x0002,
      ClockwiseWinding = 0x0004,
      Indexed = 0x0008,
      BoundingBoxSet = 0x0080,
      Skinned = 0x0100,
      Instanced = 0x200,
    };
  };
 
  struct DataStream
  {
    DataStream() = default;
 
    DataStream(const DataStream & other) = delete;
 
    DataStream(DataStream && other) = default;
 
    COGSCORE_DLL_API void * data();
    COGSCORE_DLL_API const void * data() const;
 
    COGSCORE_DLL_API size_t size() const;
 
    Cogs::Core::ResourceBufferHandle buffer;
 
    VertexFormatHandle format;
 
    uint32_t offset = 0;
 
    uint32_t stride = 0;
 
    uint32_t numElements = 0;
 
    VertexDataType::EVertexDataType type = VertexDataType::Reserved;
  };
 
  template<typename Element>
  struct [[nodiscard]] MappedStream  final
  {
    MappedStream(struct Mesh * mesh, Element * data, VertexDataType::EVertexDataType type)
      : data(data), mesh(mesh), type(type) {}
 
    MappedStream(MappedStream & other) = delete;
 
    MappedStream(MappedStream && other)
      : data(other.data), mesh(other.mesh), type(other.type)
    {
      other.data = nullptr;
      other.mesh = nullptr;
    }
 
    ~MappedStream();
 
    [[nodiscard]] constexpr Element & operator[](const size_t index)
    {
      return data[index];
    }
 
    [[nodiscard]] constexpr const Element & operator[](const size_t index) const
    {
      return data[index];
    }
 
    [[nodiscard]] constexpr bool isValid() const { return data != nullptr; }
 
    [[nodiscard]] constexpr VertexDataType::EVertexDataType getDataType() const { return type; }
 
    Element * data;
 
  private:
    struct Mesh * mesh;
 
    VertexDataType::EVertexDataType type;
  };
 
  template<typename Element>
  struct [[nodiscard]] MappedStreamReadOnly final
  {
    MappedStreamReadOnly() = default;
 
    MappedStreamReadOnly(struct Mesh* mesh, const Element* data, VertexDataType::EVertexDataType type)
      : data(data), mesh(mesh), type(type) {}
 
    [[nodiscard]] bool isValid() const { return data != nullptr; }
 
    [[nodiscard]] constexpr const Element& operator[](const size_t index) const
    {
      return data[index];
    }
 
    [[nodiscard]] VertexDataType::EVertexDataType getDataType() const { return type; }
 
    const Element* data = nullptr;
 
  private:
    struct Mesh* mesh = nullptr;
 
    VertexDataType::EVertexDataType type = VertexDataType::EVertexDataType::Reserved;
  };
 
  inline bool isLine(PrimitiveType::EPrimitiveType primitiveType) { return primitiveType == PrimitiveType::LineList; }
 
  struct SubMesh
  {
    uint32_t startIndex;
 
    uint32_t numIndexes;
 
    PrimitiveType::EPrimitiveType primitiveType;
  };
 
  struct COGSCORE_DLL_API Mesh : public ResourceBase
  {
    Mesh();
 
    Mesh(const Mesh & other) = delete;
 
    Mesh & operator=(const Mesh& other) noexcept = delete;
 
    Mesh(Mesh && other) noexcept = default;
 
    Mesh & operator=(Mesh && other) noexcept = default;
 
    void setBounds(Geometry::BoundingBox box)
    {
      boundingBox = box;
      setMeshFlag(MeshFlags::BoundingBoxSet);
    }
 
    static constexpr size_t MaxStreams = 16;
 
    static constexpr int NoStream = -1;
 
    void setPositions(std::span<const glm::vec3> positions)
    {
      set(VertexDataType::Positions, VertexFormats::Pos3f, positions);
    }
 
    void setColors(std::span<const glm::vec4> colors)
    {
      set(VertexDataType::Colors0, VertexFormats::Color4f, colors);
    }
 
    void setInstancePositions(std::span<const glm::vec3> positions)
    {
      set(VertexDataType::Positions, VertexFormats::InstancePos3f, positions);
    }
 
    void setInstanceColors(std::span<const glm::vec4> colors)
    {
      set(VertexDataType::Colors0, VertexFormats::InstanceColor4f, colors);
    }
 
    template<typename Iterator>
    void setPositions(Iterator begin, Iterator end)
    {
      set(VertexDataType::Positions, VertexFormats::Pos3f, begin, end);
    }
 
    [[nodiscard]] MappedStream<glm::vec3> mapPositions(const size_t start, const size_t end)
    {
      return map<glm::vec3>(VertexDataType::Positions, VertexFormats::Pos3f, start, end-start);
    }
 
    [[nodiscard]] MappedStreamReadOnly<glm::vec3> mapPositionsReadOnly(const size_t start, const size_t end)
    {
      return mapReadOnly<glm::vec3>(VertexDataType::Positions, VertexFormats::Pos3f, start, end - start);
    }
 
    void setNormals(std::span<const glm::vec3> normals)
    {
      set(VertexDataType::Normals, VertexFormats::Norm3f, normals);
    }
 
    template<typename Iterator>
    void setNormals(Iterator begin, Iterator end)
    {
      set(VertexDataType::Normals, VertexFormats::Norm3f, begin, end);
    }
 
    [[nodiscard]] MappedStream<glm::vec3> mapNormals(const size_t start, const size_t end)
    {
      return map<glm::vec3>(VertexDataType::Normals, VertexFormats::Norm3f, start, end-start);
    }
 
    [[nodiscard]] MappedStreamReadOnly<glm::vec3> mapNormalsReadOnly(const size_t start, const size_t end)
    {
      return mapReadOnly<glm::vec3>(VertexDataType::Normals, VertexFormats::Norm3f, start, end - start);
    }
 
    void setTangents(std::span<const glm::vec3> tangents)
    {
      set(VertexDataType::Tangents, VertexFormats::Tang3f, tangents);
    }
 
    template<typename Iterator>
    void setTangents(Iterator begin, Iterator end)
    {
      set(VertexDataType::Tangents, VertexFormats::Tang3f, begin, end);
    }
 
    [[nodiscard]] MappedStream<glm::vec3> mapTangents(const size_t start, const size_t end)
    {
      return map<glm::vec3>(VertexDataType::Tangents, VertexFormats::Tang3f, start, end-start);
    }
 
    [[nodiscard]] MappedStreamReadOnly<glm::vec3> mapTangentsReadOnly(const size_t start, const size_t end)
    {
      return mapReadOnly<glm::vec3>(VertexDataType::Tangents, VertexFormats::Tang3f, start, end - start);
    }
 
    void setTexCoords(std::span<const glm::vec2> texCoords)
    {
      set(VertexDataType::TexCoords0, VertexFormats::Tex2f, texCoords);
    }
 
    template<typename Iterator>
    void setTexCoords(Iterator begin, Iterator end)
    {
      set(VertexDataType::TexCoords0, VertexFormats::Tex2f, begin, end);
    }
 
    [[nodiscard]] MappedStream<glm::vec2> mapTexCoords(const size_t start, const size_t end)
    {
      return map<glm::vec2>(VertexDataType::TexCoords0, VertexFormats::Tex2f, start, end-start);
    }
 
    [[nodiscard]] MappedStreamReadOnly<glm::vec2> mapTexCoordsReadOnly(const size_t start, const size_t end)
    {
      return mapReadOnly<glm::vec2>(VertexDataType::TexCoords0, VertexFormats::Tex2f, start, end - start);
    }
 
    template<typename Element>
    [[nodiscard]] MappedStream<Element> map(const VertexDataType::EVertexDataType type, VertexFormatHandle format, const size_t count)
    {
      return map<Element>(type, format, 0, count);
    }
 
    static constexpr uint16_t toFlag(VertexDataType::EVertexDataType type)
    {
      return (0x1 << type);
    }
 
    void setIndexes(std::span<const uint32_t> collection)
    {
      setIndexData(collection.data(), collection.size());
    }
 
    void clearIndexes()
    {
      if (isIndexed()) {
        auto & stream = getStream(VertexDataType::Indexes);
        clearStream(stream);
        setMeshFlag(MeshFlags::IndexesChanged);
        unsetMeshFlag(MeshFlags::Indexed);
      }
      if (hasStream(VertexDataType::SubMeshes)) {
        DataStream& subMeshes = getStream(VertexDataType::SubMeshes);
        clearStream(subMeshes);
      }
      submeshCount = 0;
    }
 
    void addSubMesh(std::span<uint32_t> collection, PrimitiveType::EPrimitiveType primitiveType);
 
    void setBufferStream(VertexDataType::EVertexDataType type,
                         ResourceBufferHandle buffer,
                         VertexFormatHandle format,
                         uint32_t numElements,
                         uint32_t offset,
                         uint32_t stride);
 
    void clearStream(DataStream & stream);
 
    void clear();
 
    void setMeshFlag(MeshFlags::EMeshFlags flag)
    {
      meshFlags |= flag;
 
      setChanged();
    }
 
    void unsetMeshFlag(MeshFlags::EMeshFlags flag)
    {
      meshFlags &= ~flag;
    }
 
    [[nodiscard]] constexpr bool isMeshFlagSet(MeshFlags::EMeshFlags flag) const
    {
      return (meshFlags & flag) == flag;
    }
 
    [[nodiscard]] bool boundsDirty() const
    {
      return (isMeshFlagSet(MeshFlags::IndexesChanged) || isMeshFlagSet(MeshFlags::StreamsChanged)) && !isMeshFlagSet(MeshFlags::BoundingBoxSet);
    }
 
    void setIndexData(const uint32_t * data, size_t count)
    {
      clearIndexes();
 
      auto streamData = mapStream(VertexDataType::Indexes, 0, count, sizeof(uint32_t), true);
      memcpy(streamData, data, sizeof(uint32_t) * count);
 
      this->count = static_cast<uint32_t>(count);
 
      setMeshFlag(MeshFlags::Indexed);
      setMeshFlag(MeshFlags::IndexesChanged);
    }
 
    void setIndexData(const uint16_t * data, size_t count)
    {
      clearIndexes();
 
      auto streamData = mapStream(VertexDataType::Indexes, 0, count, sizeof(uint16_t), true);
      memcpy(streamData, data, sizeof(uint16_t) * count);
 
      this->count = static_cast<uint32_t>(count);
 
      setMeshFlag(MeshFlags::Indexed);
      setMeshFlag(MeshFlags::IndexesChanged);
    }
 
    void setIndexData(std::span<const uint32_t> data)
    {
      setIndexData(data.data(), data.size());
    }
 
    template<typename Element>
    void setVertexData(Element * elements, size_t count)
    {
      setVertexData(elements, count, Element::getVertexFormat());
    }
 
    template<typename Element>
    void setVertexData(Element * elements, size_t count, VertexFormatHandle format)
    {
      this->count = static_cast<uint32_t>(count);
 
      set(VertexDataType::Interleaved0, format, elements, elements + count);
    }
 
    template<typename Element>
    void set(const VertexDataType::EVertexDataType type, VertexFormatHandle format, Element * begin, Element * end)
    {
      const size_t count = end - begin;
      auto mapped = map<typename std::remove_const<Element>::type>(type, format, 0, end - begin, true);
 
      for (size_t i = 0; i < count; ++i) {
        mapped[i] = *begin++;
      }
      setMeshFlag(MeshFlags::StreamsChanged);
    }
 
    template<typename Collection>
    void set(const VertexDataType::EVertexDataType type, VertexFormatHandle format, const Collection& collection)
    {
      set(type, format, collection.data(), collection.data() + collection.size());
    }
 
    template<typename Element>
    [[nodiscard]] MappedStream<Element> map(const VertexDataType::EVertexDataType type, VertexFormatHandle format, const size_t start, const size_t count, bool resize = false)
    {
      void* stream = mapStream(type, format, start, count, sizeof(Element), resize);
      return MappedStream<Element>{ this, static_cast<Element *>(stream), type };
    }
 
    template<typename Element>
    [[nodiscard]] MappedStreamReadOnly<Element> mapReadOnly(const VertexDataType::EVertexDataType type,
                                              VertexFormatHandle format,
                                              const size_t start,
                                              const size_t count)
    {
      if (!hasStream(type))
        return MappedStreamReadOnly<Element>();
 
      // Check length
      const Cogs::Core::DataStream& stream = getStream(type);
      if (stream.size() < (start + count))
        return MappedStreamReadOnly<Element>();
 
      bool resize = false;
      void* streamData = mapStream(type, format, start, count, sizeof(Element), resize);
      return MappedStreamReadOnly<Element>{ this, static_cast<Element*>(streamData), type };
    }
 
    [[nodiscard]] uint8_t * mapStream(const VertexDataType::EVertexDataType type,
                        VertexFormatHandle format,
                        const size_t start,
                        const size_t count,
                        const size_t elementSize,
                        bool resize = false);
 
    [[nodiscard]] uint8_t * mapStream(const VertexDataType::EVertexDataType type,
                        const size_t start,
                        const size_t count,
                        const size_t stride,
                        bool resize = false);
 
    void unmap(VertexDataType::EVertexDataType type)
    {
      markStreamChanged(type);
    }
 
    void markStreamChanged(VertexDataType::EVertexDataType type)
    {
      streamsUpdated |= Mesh::toFlag(type);
      setMeshFlag(MeshFlags::StreamsChanged);
    }
 
    [[nodiscard]] DataStream & getStream(const VertexDataType::EVertexDataType dataType);
    [[nodiscard]] const DataStream & getStream(const VertexDataType::EVertexDataType dataType) const;
    [[nodiscard]] DataStream * getAllocatedStream(const VertexDataType::EVertexDataType dataType);
    [[nodiscard]] const DataStream * getAllocatedStream(const VertexDataType::EVertexDataType dataType) const;
 
    [[nodiscard]] bool hasStream(VertexDataType::EVertexDataType type) const
    {
      return streamIndexes[type] != NoStream;
    }
 
    [[nodiscard]] bool isCCW() const
    {
      return !isMeshFlagSet(MeshFlags::ClockwiseWinding);
    }
 
    [[nodiscard]] bool isIndexed() const
    {
      return isMeshFlagSet(MeshFlags::Indexed);
    }
 
    struct StreamReference final
    {
      template<typename T>
      [[nodiscard]]
      inline T& getDataAt(uint32_t index) {
        return *reinterpret_cast<T*>(ptr + index * stride);
      }
 
      template<typename T>
      [[nodiscard]]
      inline const T& getDataAt(const size_t index) const {
        return *reinterpret_cast<const T*>(ptr + index * stride);
      }
 
      [[nodiscard]]
      constexpr bool isValid() const { return ptr != nullptr; }
 
      uint8_t* ptr = nullptr;
      uint32_t count = 0;
      uint32_t stride = 0;
    };
 
    [[nodiscard]] StreamReference getPositionStream();
 
    [[nodiscard]] StreamReference getSemanticStream(ElementSemantic semantic, DataFormat format);
 
    [[nodiscard]] MeshStreamsLayout getStreamsLayout() const;
 
    [[nodiscard]] uint32_t getCount() const { return count; }
 
    void setCount(size_t count) { this->count = static_cast<uint32_t>(count); setMeshFlag(MeshFlags::StreamsChanged); setMeshFlag(MeshFlags::IndexesChanged); }
 
    [[nodiscard]] uint32_t getInstanceCount() const { return instanceCount; }
 
    void setInstanceCount(size_t count) { instanceCount = static_cast<uint16_t>(count); setMeshFlag(MeshFlags::StreamsChanged); setMeshFlag(MeshFlags::IndexesChanged); }
 
    template<typename Datatype>
    [[nodiscard]] Cogs::Memory::TypedBuffer<Datatype> copyData(Cogs::ElementSemantic semantic, DataFormat format)
    {
      Cogs::Memory::TypedBuffer<Datatype> output;
 
      copyData(output, semantic, format);
 
      return output;
    }
 
    template<typename Datatype>
    void copyData(Cogs::Memory::TypedBuffer<Datatype>& output, Cogs::ElementSemantic semantic, DataFormat format)
    {
      if (streams.size()) {
        auto[rawData, count, stride] = getSemanticStream(semantic, format);
 
        output.resize(count, false);
 
        for (size_t i = 0; i < count; ++i) {
          output[i] = *reinterpret_cast<const Datatype *>(rawData + i * stride);
        }
      } else {
        output.clear();
      }
    }
 
    [[nodiscard]]
    class MeshManager * getManager() const;
 
    [[nodiscard]]
    std::span<uint32_t> mapPoseIndexes(uint32_t count);
    [[nodiscard]]
    std::span<const uint32_t> getPoseIndexes() const;
 
    std::span<SubMesh> mapSubMeshes(uint32_t count);
    [[nodiscard]]
    std::span<SubMesh> getSubMeshes();
 
    [[nodiscard]]
    std::span<const uint32_t> getIndexes() const;
    [[nodiscard]]
    std::span<const uint16_t> getIndexesU16() const;
 
    [[nodiscard]]
    bool hasIndexesU16() const;
 
    std::vector<DataStream> streams;
 
    std::array<int8_t, static_cast<size_t>(VertexDataType::Reserved)> streamIndexes;
 
    Geometry::BoundingBox boundingBox;
 
    uint16_t streamsUpdated = 0;
    uint16_t submeshCount = 0;
    uint16_t meshFlags = MeshFlags::None;
    PrimitiveType::EPrimitiveType primitiveType = PrimitiveType::TriangleList;
 
  private:
    uint32_t count = 0;
    uint16_t instanceCount = 0;
  };
 
  template<typename Element>
  MappedStream<Element>::~MappedStream()
  {
    if (mesh) {
      mesh->unmap(type);
    }
  }
}
 
#include "MeshHelper.h"