Small optim for vertex streams

Author: gan74

yave/meshes/MeshData.cpp

@@ -47,8 +47,11 @@ MeshData::MeshData(MeshVertexStreams streams, core::Span<IndexedTriangle> triang
 }
 
 void MeshData::add_sub_mesh(const MeshVertexStreams& streams, core::Span<IndexedTriangle> triangles) {
+    add_sub_mesh(triangles, add_vertices_from_streams(streams));
+}
+
+u32 MeshData::add_vertices_from_streams(const MeshVertexStreams& streams) {
     y_debug_assert(!streams.is_empty());
-    y_debug_assert(!triangles.is_empty());
 
     // AABB
     {
@@ -72,7 +75,12 @@ void MeshData::add_sub_mesh(const MeshVertexStreams& streams, core::Span<Indexed
     const u32 vertex_offset = u32(_vertex_streams.vertex_count());
     _vertex_streams = _vertex_streams.merged(streams);
 
-    // Triangles
+    return vertex_offset;
+}
+
+void MeshData::add_sub_mesh(core::Span<IndexedTriangle> triangles, u32 vertex_offset) {
+    y_debug_assert(!triangles.is_empty());
+
     const u32 first_triangle = u32(_triangles.size());
     _triangles.set_min_capacity(_triangles.size() + triangles.size());
     std::transform(triangles.begin(), triangles.end(), std::back_inserter(_triangles), [=](IndexedTriangle tri) {

yave/meshes/MeshData.h

@@ -49,6 +49,9 @@ class MeshData {
         void add_sub_mesh(core::Span<FullVertex> vertices, core::Span<IndexedTriangle> triangles);
         void add_sub_mesh(core::Span<PackedVertex> vertices, core::Span<IndexedTriangle> triangles);
 
+        u32 add_vertices_from_streams(const MeshVertexStreams& streams);
+        void add_sub_mesh(core::Span<IndexedTriangle> triangles, u32 vertex_offset);
+
         float radius() const;
         const AABB& aabb() const;
 

yave/meshes/MeshVertexStreams.cpp

@@ -26,11 +26,14 @@ SOFTWARE.
 namespace yave {
 
 MeshVertexStreams::MeshVertexStreams(usize vertices) : _vertex_count(vertices) {
+    usize offset = 0;
     for(usize i = 0; i != stream_count; ++i) {
         const usize stream_elem_size = vertex_stream_element_size(VertexStreamType(i));
         const usize stream_byte_size = _vertex_count * stream_elem_size;
-        _streams[i] = core::FixedArray<u8>(stream_byte_size);
+        _stream_offsets[i] = offset;
+        offset += stream_byte_size;
     }
+    _storage = core::FixedArray<u8>(offset);
 }
 
 MeshVertexStreams::MeshVertexStreams(core::Span<PackedVertex> vertices) : MeshVertexStreams(vertices.size()) {
@@ -47,8 +50,8 @@ MeshVertexStreams MeshVertexStreams::merged(const MeshVertexStreams& other) cons
         const usize stream_elem_size = vertex_stream_element_size(type);
 
         const usize stream_total_size = vertex_count() * stream_elem_size;
-        std::memcpy(str._streams[i].data(), data(type), stream_total_size);
-        std::memcpy(str._streams[i].data() + stream_total_size, other.data(type), other.vertex_count() * stream_elem_size);
+        std::memcpy(str.data(type), data(type), stream_total_size);
+        std::memcpy(str.data(type) + stream_total_size, other.data(type), other.vertex_count() * stream_elem_size);
     }
 
     return str;
@@ -98,11 +101,13 @@ bool MeshVertexStreams::has_stream(VertexStreamType type) const {
 }
 
 u8* MeshVertexStreams::data(VertexStreamType type) {
-    return _streams[usize(type)].data();
+    const usize offset = _stream_offsets[usize(type)];
+    return _storage.data() + offset;
 }
 
 const u8* MeshVertexStreams::data(VertexStreamType type) const {
-    return _streams[usize(type)].data();
+    const usize offset = _stream_offsets[usize(type)];
+    return _storage.data() + offset;
 }
 
 }

yave/meshes/MeshVertexStreams.h

@@ -107,21 +107,22 @@ class MeshVertexStreams {
         }
 
         inline void* vertex_stream_data(VertexStreamType type, usize index) {
-            return _streams[usize(type)].data() + index * vertex_stream_element_size(type);
+            return data(type) + index * vertex_stream_element_size(type);
         }
 
         inline const void* vertex_stream_data(VertexStreamType type, usize index) const {
-            return _streams[usize(type)].data() + index * vertex_stream_element_size(type);
+            return data(type) + index * vertex_stream_element_size(type);
         }
 
 
-        y_reflect(MeshVertexStreams, _vertex_count, _streams);
+        y_reflect(MeshVertexStreams, _vertex_count, _stream_offsets, _storage);
 
     private:
         void set_vertex(usize index, PackedVertex vertex);
 
         usize _vertex_count = 0;
-        std::array<core::FixedArray<u8>, stream_count> _streams;
+        std::array<usize, stream_count> _stream_offsets;
+        core::FixedArray<u8> _storage;
 
 };