Buffers replace std::vectors in RenderMeshObject for higher performance

source/MRMesh/MRBuffer.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "MRMeshFwd.h"
+#include <cassert>
+#include <memory>
+
+namespace MR
+{
+
+/**
+ * \brief std::vector<T>-like container that is
+ *  1) resized without initialization of its elements,
+ *  2) much simplified: no push_back and many other methods
+ * \tparam T type of stored elements
+ * \ingroup BasicGroup
+ */
+template <typename T>
+class Buffer
+{
+public:
+    using reference = T&;
+    using const_reference = const T&;
+    using iterator = T*;
+    using const_iterator = const T*;
+
+    Buffer() = default;
+    explicit Buffer( size_t size ) { resize( size ); }
+    Buffer( std::vector<T> && vec ) : data_( std::move( data_ ) ), size_( std::move( size_ ) ) { }
+
+    void clear() { data_.reset(); size_ = 0; }
+
+    [[nodiscard]] auto size() const { return size_; }
+
+    void resize( size_t newSize ) 
+    {
+        if ( newSize == 0 )
+            clear();
+        else if ( newSize != size_ )
+        {
+#if __cpp_lib_smart_ptr_for_overwrite >= 202002L
+            data_ = std::make_unique_for_overwrite<T[]>( size_ = newSize );
+#else
+            // The array elements are value-initialized, so it is much slower - for older compilers
+#pragma message("No std::make_unique_for_overwrite is available")
+            data_ = std::make_unique<T[]>( size_ = newSize );
+#endif
+        }
+    }
+
+    [[nodiscard]] const_reference operator[]( size_t i ) const
+    {
+        assert( i < size_ );
+        return data_[i];
+    }
+    [[nodiscard]] reference operator[]( size_t i )
+    {
+        assert( i < size_ );
+        return data_[i];
+    }
+
+    [[nodiscard]] auto data() { return data_.get(); }
+    [[nodiscard]] auto data() const { return data_.get(); }
+
+    void swap( Buffer & b ) { data_.swap( b.data_ ); std::swap( size_, b.size_ ); }
+
+    /// returns the amount of memory this object occupies on heap
+    [[nodiscard]] size_t heapBytes() const { return size() * sizeof(T); }
+
+private:
+    std::unique_ptr<T[]> data_;
+    size_t size_ = 0;
+};
+
+template <typename T, typename I>
+[[nodiscard]] inline auto begin( const Buffer<T> & a )
+    { return a.data(); }
+
+template <typename T, typename I>
+[[nodiscard]] inline auto begin( Buffer<T> & a )
+    { return a.data(); }
+
+template <typename T, typename I>
+[[nodiscard]] inline auto end( const Buffer<T> & a )
+    { return a.data() + a.size(); }
+
+template <typename T, typename I>
+[[nodiscard]] inline auto end( Buffer<T> & a )
+    { return a.data() + a.size(); }
+
+} // namespace MR

source/MRMesh/MRMesh.vcxproj

@@ -12,6 +12,7 @@
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="MRBooleanOperation.h" />
+    <ClInclude Include="MRBuffer.h" />
     <ClInclude Include="MRChangeVoxelsAction.h" />
     <ClInclude Include="MRChangeLabelAction.h" />
     <ClInclude Include="MRChangePointCloudAction.h" />
@@ -576,4 +577,4 @@ copy $(ProjectDir)..\..\thirdparty\python\python310.zip $(TargetDir)python310.zi
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>

source/MRMesh/MRMesh.vcxproj.filters

@@ -861,6 +861,9 @@
     <ClInclude Include="MRMatrix3Decompose.h">
       <Filter>Source Files\Math</Filter>
     </ClInclude>
+    <ClInclude Include="MRBuffer.h">
+      <Filter>Source Files\Basic</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="MRId.cpp">
@@ -1455,4 +1458,4 @@
   <ItemGroup>
     <None Include="..\.editorconfig" />
   </ItemGroup>
-</Project>
+</Project>

source/MRMesh/MRMeshFwd.h

@@ -49,6 +49,7 @@ class MRMESH_CLASS VoxelTag;
 
 template <typename T> class Id;
 template <typename T, typename I> class Vector;
+template <typename T> class Buffer;
 
 using EdgeId = Id<EdgeTag>;
 using UndirectedEdgeId = Id<UndirectedEdgeTag>;

source/MRViewer/MRRenderGLHelpers.h

@@ -2,12 +2,12 @@
 
 namespace MR
 {
-template<typename T>
+template<typename T, template<typename, typename...> class C, typename... args>
 GLint bindVertexAttribArray(
     const GLuint program_shader,
     const std::string& name,
     GLuint bufferID,
-    const std::vector<T>& V,
+    const C<T, args...>& V,
     int baseTypeElementsNumber,
     bool refresh,
     bool forceUse = false )

source/MRViewer/MRRenderMeshObject.cpp

@@ -193,14 +193,14 @@ void RenderMeshObject::renderPicker( const BaseRenderParams& parameters, unsigne
 
 size_t RenderMeshObject::heapBytes() const
 {
-    return MR::heapBytes( vertPosBufferObj_ ) 
-        + MR::heapBytes( vertNormalsBufferObj_ )
-        + MR::heapBytes( vertColorsBufferObj_ )
-        + MR::heapBytes( vertUVBufferObj_ )
-        + MR::heapBytes( facesIndicesBufferObj_ )
-        + MR::heapBytes( edgesIndicesBufferObj_ )
-        + MR::heapBytes( faceSelectionTexture_ )
-        + MR::heapBytes( faceNormalsTexture_ )
+    return vertPosBufferObj_.heapBytes()
+        + vertNormalsBufferObj_.heapBytes()
+        + vertColorsBufferObj_.heapBytes()
+        + vertUVBufferObj_.heapBytes()
+        + facesIndicesBufferObj_.heapBytes()
+        + edgesIndicesBufferObj_.heapBytes()
+        + faceSelectionTexture_.heapBytes()
+        + faceNormalsTexture_.heapBytes()
         + MR::heapBytes( borderHighlightPoints_ )
         + MR::heapBytes( selectedEdgesPoints_ );
 }

source/MRViewer/MRRenderMeshObject.h

@@ -1,6 +1,8 @@
 #pragma once
+
 #include "MRMesh/MRIRenderObject.h"
 #include "MRMesh/MRMeshTexture.h"
+#include "MRMesh/MRBuffer.h"
 
 namespace MR
 {
@@ -18,14 +20,14 @@ class RenderMeshObject : public IRenderObject
     const ObjectMeshHolder* objMesh_;
 
     // need this to use per corner rendering (this is not simple copy of mesh vertices etc.)
-    mutable std::vector<Vector3f> vertPosBufferObj_;
-    mutable std::vector<Vector3f> vertNormalsBufferObj_;
-    mutable std::vector<Color> vertColorsBufferObj_;
-    mutable std::vector<UVCoord> vertUVBufferObj_;
-    mutable std::vector<Vector3i> facesIndicesBufferObj_;
-    mutable std::vector<Vector2i> edgesIndicesBufferObj_;
-    mutable std::vector<unsigned> faceSelectionTexture_;
-    mutable std::vector<Vector4f> faceNormalsTexture_;
+    mutable Buffer<Vector3f> vertPosBufferObj_;
+    mutable Buffer<Vector3f> vertNormalsBufferObj_;
+    mutable Buffer<Color> vertColorsBufferObj_;
+    mutable Buffer<UVCoord> vertUVBufferObj_;
+    mutable Buffer<Vector3i> facesIndicesBufferObj_;
+    mutable Buffer<Vector2i> edgesIndicesBufferObj_;
+    mutable Buffer<unsigned> faceSelectionTexture_;
+    mutable Buffer<Vector4f> faceNormalsTexture_;
     mutable std::vector<Vector3f> borderHighlightPoints_;
     mutable std::vector<Vector3f> selectedEdgesPoints_;