remove Mesh constructor 'attrs' argument & format Mesh.hpp

src/graphics/core/Batch2D.cpp

@@ -9,7 +9,7 @@
 
 Batch2D::Batch2D(size_t capacity) : capacity(capacity), color(1.0f){
     buffer = std::make_unique<Batch2DVertex[]>(capacity );
-    mesh = std::make_unique<Mesh<Batch2DVertex>>(buffer.get(), 0, Batch2DVertex::ATTRIBUTES);
+    mesh = std::make_unique<Mesh<Batch2DVertex>>(buffer.get(), 0);
     index = 0;
 
     const ubyte pixels[] = {

src/graphics/core/Batch3D.cpp

@@ -11,7 +11,7 @@ Batch3D::Batch3D(size_t capacity)
 
 
     buffer = std::make_unique<Batch3DVertex[]>(capacity);
-    mesh = std::make_unique<Mesh<Batch3DVertex>>(buffer.get(), 0, Batch3DVertex::ATTRIBUTES);
+    mesh = std::make_unique<Mesh<Batch3DVertex>>(buffer.get(), 0);
     index = 0;
 
     const ubyte pixels[] = {

src/graphics/core/LineBatch.cpp

@@ -7,7 +7,7 @@
 LineBatch::LineBatch(size_t capacity) : capacity(capacity) {
 
     buffer = std::make_unique<LineVertex[]>(capacity * 2);
-    mesh = std::make_unique<Mesh<LineVertex>>(buffer.get(), 0, LineVertex::ATTRIBUTES);
+    mesh = std::make_unique<Mesh<LineVertex>>(buffer.get(), 0);
     index = 0;
 }
 

src/graphics/core/Mesh.hpp

@@ -8,35 +8,40 @@ struct MeshStats {
     static int drawCalls;
 };
 
-
-template<typename VertexStructure>
+template <typename VertexStructure>
 class Mesh {
     unsigned int vao;
     unsigned int vbo;
     unsigned int ibo;
     size_t vertexCount;
     size_t indexCount;
-    size_t vertexSize;
-
 public:
-    explicit Mesh(const MeshData<VertexStructure> &data);
+    explicit Mesh(const MeshData<VertexStructure>& data);
 
-    Mesh(const VertexStructure *vertexBuffer, size_t vertices, const uint32_t *indexBuffer, size_t indices,
-         const VertexAttribute *attrs);
+    Mesh(
+        const VertexStructure* vertexBuffer,
+        size_t vertices,
+        const uint32_t* indexBuffer,
+        size_t indices
+    );
 
-    Mesh(const VertexStructure *vertexBuffer, size_t vertices, const VertexAttribute *attrs) : Mesh<VertexStructure>(
-        vertexBuffer, vertices, nullptr, 0, attrs) {
-    };
+    Mesh(const VertexStructure* vertexBuffer, size_t vertices)
+        : Mesh<VertexStructure>(vertexBuffer, vertices, nullptr, 0) {};
 
     ~Mesh();
 
-    /// @brief Update GL vertex and index buffers data without changing VAO attributes
+    /// @brief Update GL vertex and index buffers data without changing VAO
+    /// attributes
     /// @param vertexBuffer vertex data buffer
     /// @param vertexCount number of vertices in new buffer
     /// @param indexBuffer indices buffer
     /// @param indexCount number of values in indices buffer
-    void reload(const VertexStructure *vertexBuffer, size_t vertexCount, const uint32_t *indexBuffer = nullptr,
-                size_t indexCount = 0);
+    void reload(
+        const VertexStructure* vertexBuffer,
+        size_t vertexCount,
+        const uint32_t* indexBuffer = nullptr,
+        size_t indexCount = 0
+    );
 
     /// @brief Draw mesh with specified primitives type
     /// @param primitive primitives type
@@ -44,8 +49,6 @@ public:
 
     /// @brief Draw mesh as triangles
     void draw() const;
-
-    /// @brief Total numbers of alive mesh objects
 };
 
 #include "graphics/core/Mesh.inl"

src/graphics/core/Mesh.inl

@@ -3,14 +3,21 @@
 #include "MeshData.hpp"
 #include "gl_util.hpp"
 
+inline constexpr size_t calc_size(const VertexAttribute attrs[]) {
+    size_t vertexSize = 0;
+    for (int i = 0; attrs[i].count; i++) {
+        vertexSize += attrs[i].size();
+    }
+    return vertexSize;
+}
+
 template <typename VertexStructure>
 Mesh<VertexStructure>::Mesh(const MeshData<VertexStructure>& data)
     : Mesh(
           data.vertices.data(),
           data.vertices.size(),
           data.indices.data(),
-          data.indices.size(),
-          data.attrs.data()
+          data.indices.size()
       ) {
 }
 
@@ -19,18 +26,15 @@ Mesh<VertexStructure>::Mesh(
     const VertexStructure* vertexBuffer,
     size_t vertices,
     const uint32_t* indexBuffer,
-    size_t indices,
-    const VertexAttribute* attrs
+    size_t indices
 )
     : vao(0), vbo(0), ibo(0), vertexCount(0), indexCount(0) {
+    static_assert(
+        calc_size(VertexStructure::ATTRIBUTES) == sizeof(VertexStructure)
+    );
+    
+    const auto& attrs = VertexStructure::ATTRIBUTES;
     MeshStats::meshesCount++;
-    vertexSize = 0;
-    for (int i = 0; attrs[i].count; i++) {
-        vertexSize += attrs[i].size();
-    }
-    if (vertexSize != sizeof(VertexStructure)) {
-        throw std::runtime_error("Vertex size mismatch!");
-    }
 
     glGenVertexArrays(1, &vao);
     glGenBuffers(1, &vbo);
@@ -80,7 +84,7 @@ void Mesh<VertexStructure>::reload(
     if (vertexBuffer != nullptr && vertexCount != 0) {
         glBufferData(
             GL_ARRAY_BUFFER,
-            vertexCount * vertexSize,
+            vertexCount * sizeof(VertexStructure),
             vertexBuffer,
             GL_STREAM_DRAW
         );

src/graphics/core/MeshData.hpp

@@ -18,7 +18,7 @@ struct VertexAttribute {
     bool normalized = false;
     ubyte count = 0;
 
-    [[nodiscard]] uint32_t size() const {
+    [[nodiscard]] constexpr uint32_t size() const {
         switch (type) {
             case Type::FLOAT:
                 return count * sizeof(float);
@@ -31,9 +31,8 @@ struct VertexAttribute {
             case Type::UNSIGNED_BYTE:
             case Type::BYTE:
                 return count * sizeof(int8_t);
-            default:
-                throw std::runtime_error("VertexAttribute type is not supported");
         }
+        return 0;
     }
 };
 

src/graphics/core/PostProcessing.cpp

@@ -21,7 +21,7 @@ PostProcessing::PostProcessing(size_t effectSlotsCount)
             {{1.0f, -1.0f}},
     };
 
-    quadMesh = std::make_unique<Mesh<PostProcessingVertex>>(meshData, 6, PostProcessingVertex::ATTRIBUTES);
+    quadMesh = std::make_unique<Mesh<PostProcessingVertex>>(meshData, 6);
 }
 
 PostProcessing::~PostProcessing() = default;

src/graphics/core/gl_util.hpp

@@ -43,5 +43,6 @@ namespace gl {
             case Type::BYTE:
                 return GL_BYTE;
         }
+        return 0;
     }
 }

src/graphics/render/BlocksRenderer.cpp

@@ -662,7 +662,7 @@ ChunkMesh BlocksRenderer::render(const Chunk *chunk, const Chunks *chunks) {
     build(chunk, chunks);
 
     return ChunkMesh{std::make_unique<Mesh<ChunkVertex>>(
-        vertexBuffer.get(), vertexCount, indexBuffer.get(), indexCount, ChunkVertex::ATTRIBUTES
+        vertexBuffer.get(), vertexCount, indexBuffer.get(), indexCount
     ), std::move(sortingMesh)};
 }
 

src/graphics/render/ChunksRenderer.cpp

@@ -289,9 +289,7 @@ void ChunksRenderer::drawSortedMeshes(const Camera& camera, Shader& shader) {
             auto& entry = chunkEntries.at(0);
             if (found->second.sortedMesh == nullptr) {
                 found->second.sortedMesh = std::make_unique<Mesh<ChunkVertex>>(
-                    entry.vertexData.data(),
-                    entry.vertexData.size(),
-                    ChunkVertex::ATTRIBUTES
+                    entry.vertexData.data(), entry.vertexData.size()
                 );
             }
             found->second.sortedMesh->draw();
@@ -316,7 +314,7 @@ void ChunksRenderer::drawSortedMeshes(const Camera& camera, Shader& shader) {
             }
             write_sorting_mesh_entries(buffer.data(), chunkEntries);
             found->second.sortedMesh = std::make_unique<Mesh<ChunkVertex>>(
-                buffer.data(), size, ChunkVertex::ATTRIBUTES
+                buffer.data(), size
             );
         }
         found->second.sortedMesh->draw();

src/graphics/render/MainBatch.cpp

@@ -11,7 +11,7 @@ MainBatch::MainBatch(size_t capacity)
         : buffer(std::make_unique<MainBatchVertex[]>(capacity)),
           capacity(capacity),
           index(0),
-          mesh(std::make_unique<Mesh<MainBatchVertex>>(buffer.get(), 0, MainBatchVertex::ATTRIBUTES)) {
+          mesh(std::make_unique<Mesh<MainBatchVertex>>(buffer.get(), 0)) {
 
     const ubyte pixels[] = {
             255, 255, 255, 255,

src/graphics/render/Skybox.cpp

@@ -44,7 +44,7 @@ Skybox::Skybox(uint size, Shader& shader)
         {{1.0f, -1.0f}}
     };
 
-    mesh = std::make_unique<Mesh<SkyboxVertex>>(vertices, 6, SkyboxVertex::ATTRIBUTES);
+    mesh = std::make_unique<Mesh<SkyboxVertex>>(vertices, 6);
 
     sprites.push_back(skysprite {
         "misc/moon",

src/voxels/Chunks.cpp

@@ -10,7 +10,6 @@
 #include "coders/byte_utils.hpp"
 #include "content/Content.hpp"
 #include "world/files/WorldFiles.hpp"
-#include "graphics/core/Mesh.hpp"
 #include "lighting/Lightmap.hpp"
 #include "maths/aabb.hpp"
 #include "maths/rays.hpp"