MRMeshFwd.h File Reference

#include "config.h"
#include "MRMesh/MRCanonicalTypedefs.h"
#include "MRPch/MRBindingMacros.h"
#include <array>
#include <vector>
#include <string>
#include <parallel_hashmap/phmap_fwd_decl.h>
#include <functional>
#include <cassert>

Go to the source code of this file.

Classes
struct	MR::NoInit
struct	MR::overloaded< Ts >

Namespaces
namespace	MR
	only for bindings generation
namespace	MR::SceneSave
namespace	MR::ObjectSave
namespace	MR::MeshBuilder
	Building topologies by triangles.
namespace	MR::Locale

Macros
#define	MR_CPP_STANDARD_DATE   __cplusplus
	Check C++ version.
#define	MRMESH_API   __attribute__((visibility("default")))
#define	MRMESH_CLASS   __attribute__((visibility("default")))
#define	MR_UNREACHABLE   { assert( false ); return {}; }
#define	MR_UNREACHABLE_NO_RETURN   assert( false );
#define	_t(...)

Typedefs
using	MR::EdgePath = std::vector<EdgeId>
using	MR::EdgeLoop = std::vector<EdgeId>
using	MR::EdgeLoops = std::vector<EdgeLoop>
template<typename T>
using	MR::TaggedBitSet = TypedBitSet<Id<T>>
using	MR::Int64 = std::int64_t
using	MR::Uint64 = std::uint64_t
template<typename T>
using	MR::AffineXf3 = AffineXf<Vector3<T>>
template<typename T>
using	MR::Sphere3 = Sphere<Vector3<T>>
template<typename T>
using	MR::Line3 = Line<Vector3<T>>
template<typename T>
using	MR::LineSegm3 = LineSegm<Vector3<T>>
template<typename T>
using	MR::Contour2 = Contour<Vector2<T>>
template<typename T>
using	MR::Contour3 = Contour<Vector3<T>>
using	MR::Contour2d = Contour2<double>
using	MR::Contour2f = Contour2<float>
using	MR::Contour3d = Contour3<double>
using	MR::Contour3f = Contour3<float>
template<typename V>
using	MR::Contours = std::vector<Contour<V>>
template<typename T>
using	MR::Contours2 = Contours<Vector2<T>>
template<typename T>
using	MR::Contours3 = Contours<Vector3<T>>
using	MR::Contours2d = Contours2<double>
using	MR::Contours2f = Contours2<float>
using	MR::Contours3d = Contours3<double>
using	MR::Contours3f = Contours3<float>
template<typename T>
using	MR::MinMax = Box<T>
using	MR::MinMaxf = MinMax<float>
using	MR::MinMaxd = MinMax<double>
using	MR::MinMaxi = MinMax<int>
template<typename T>
using	MR::Box1 = Box<T>
template<typename T>
using	MR::Box2 = Box<Vector2<T>>
template<typename T>
using	MR::Box3 = Box<Vector3<T>>
template<typename T>
using	MR::Ball1 = Ball<T>
template<typename T>
using	MR::Ball2 = Ball<Vector2<T>>
template<typename T>
using	MR::Ball3 = Ball<Vector3<T>>
template<typename T>
using	MR::CubicBezierCurve2 = CubicBezierCurve<Vector2<T>>
template<typename T>
using	MR::CubicBezierCurve3 = CubicBezierCurve<Vector3<T>>
template<typename T>
using	MR::QuadraticForm3 = QuadraticForm<Vector3<T>>
using	MR::Triangle3i = Triangle3<int>
using	MR::Triangle3f = Triangle3<float>
using	MR::Triangle3d = Triangle3<double>
using	MR::MeshEdgePoint = EdgePoint
using	MR::SurfacePath = std::vector<MeshEdgePoint>
using	MR::SurfacePaths = std::vector<SurfacePath>
using	MR::IsoLine = SurfacePath
using	MR::IsoLines = SurfacePaths
using	MR::PlaneSection = SurfacePath
using	MR::PlaneSections = SurfacePaths
using	MR::VertPair = std::pair<VertId, VertId>
using	MR::FacePair = std::pair<FaceId, FaceId>
using	MR::EdgePair = std::pair<EdgeId, EdgeId>
using	MR::UndirectedEdgePair = std::pair<UndirectedEdgeId, UndirectedEdgeId>
using	MR::UVCoord = Vector2f
using	MR::TwoVertIds = std::array<VertId, 2>
	two vertex ids describing an edge with the ends in vertices given by their ids
using	MR::ThreeVertIds = std::array<VertId, 3>
	three vertex ids describing a triangle with the corners in vertices given by their ids
using	MR::ThreeUVCoords = std::array<UVCoord, 3>
	three UV-coordinates describing texturing of a triangle
using	MR::FacePredicate = std::function<bool( FaceId )>
using	MR::EdgePredicate = std::function<bool( EdgeId )>
using	MR::UndirectedEdgePredicate = std::function<bool( UndirectedEdgeId )>
using	MR::PreCollapseCallback = std::function<bool( EdgeId edgeToCollapse, const Vector3f& newEdgeOrgPos )>
using	MR::OnEdgeSplit = std::function<void( EdgeId e1, EdgeId e )>
using	MR::VertMetric = std::function<float( VertId )>
using	MR::FaceMetric = std::function<float( FaceId )>
using	MR::EdgeMetric = std::function<float( EdgeId )>
using	MR::UndirectedEdgeMetric = std::function<float( UndirectedEdgeId )>
template<typename T, typename Hash = phmap::priv::hash_default_hash<T>, typename Eq = phmap::priv::hash_default_eq<T>>
using	MR::ParallelHashSet = phmap::parallel_flat_hash_set<T, Hash, Eq>
using	MR::FaceHashSet = HashSet<FaceId>
	No canonical typedefs because phmap::... is not under our control.
using	MR::VertHashSet = HashSet<VertId>
using	MR::EdgeHashSet = HashSet<EdgeId>
template<typename K, typename V, typename Hash = phmap::priv::hash_default_hash<K>, typename Eq = phmap::priv::hash_default_eq<K>>
using	MR::HashMap = phmap::flat_hash_map<K, V, Hash, Eq>
template<typename K, typename V, typename Hash = phmap::priv::hash_default_hash<K>, typename Eq = phmap::priv::hash_default_eq<K>>
using	MR::ParallelHashMap = phmap::parallel_flat_hash_map<K, V, Hash, Eq>
using	MR::FaceHashMap = HashMap<FaceId, FaceId>
using	MR::VertHashMap = HashMap<VertId, VertId>
using	MR::EdgeHashMap = HashMap<EdgeId, EdgeId>
using	MR::UndirectedEdgeHashMap = HashMap<UndirectedEdgeId, UndirectedEdgeId>
using	MR::WholeEdgeHashMap = HashMap<UndirectedEdgeId, EdgeId>
	mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored
using	MR::FaceMapOrHashMap = MapOrHashMap<FaceId, FaceId>
using	MR::VertMapOrHashMap = MapOrHashMap<VertId, VertId>
using	MR::EdgeMapOrHashMap = MapOrHashMap<EdgeId, EdgeId>
using	MR::UndirectedEdgeMapOrHashMap = MapOrHashMap<UndirectedEdgeId, UndirectedEdgeId>
using	MR::WholeEdgeMapOrHashMap = MapOrHashMap<UndirectedEdgeId, EdgeId>
	mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored
using	MR::GcodeSource = std::vector<std::string>
typedef std::function< bool(float)>	MR::ProgressCallback

Functions
template<typename T>
class MRMESH_CLASS	MR::Id (EdgeId, Id< EdgeTag >)(UndirectedEdgeId
class MRMESH_CLASS	MR::Id< UndirectedEdgeTag > (FaceId, Id< FaceTag >)(VertId
class MRMESH_CLASS	MR::Id< VertTag > (PixelId, Id< PixelTag >)(VoxelId
class MRMESH_CLASS	MR::Id< VoxelTag > (RegionId, Id< RegionTag >)(NodeId
class MRMESH_CLASS	MR::Id< NodeTag > (ObjId, Id< ObjTag >)(TextureId
class MRMESH_CLASS	MR::Id< TextureTag > (GraphVertId, Id< GraphVertTag >)(GraphEdgeId
template<typename T>
class MRMESH_CLASS	MR::NoInitId (NoInitNodeId, NoInitId< NodeTag >)) template< typename T
template<typename I>
class MRMESH_CLASS	MR::TypedBitSet (FaceBitSet, TypedBitSet< FaceId >)(VertBitSet
class MRMESH_CLASS	MR::TypedBitSet< VertId > (EdgeBitSet, TypedBitSet< EdgeId >)(UndirectedEdgeBitSet
class MRMESH_CLASS	MR::TypedBitSet< UndirectedEdgeId > (PixelBitSet, TypedBitSet< PixelId >)(VoxelBitSet
class MRMESH_CLASS	MR::TypedBitSet< VoxelId > (RegionBitSet, TypedBitSet< RegionId >)(NodeBitSet
class MRMESH_CLASS	MR::TypedBitSet< NodeId > (ObjBitSet, TypedBitSet< ObjId >)(TextureBitSet
class MRMESH_CLASS	MR::TypedBitSet< TextureId > (GraphVertBitSet, TypedBitSet< GraphVertId >)(GraphEdgeBitSet
template<typename T>
class MRMESH_CLASS	MR::SetBitIteratorT (SetBitIterator, SetBitIteratorT< BitSet >)(FaceSetBitIterator
class MRMESH_CLASS	MR::SetBitIteratorT< FaceBitSet > (VertSetBitIterator, SetBitIteratorT< VertBitSet >)(EdgeSetBitIterator
class MRMESH_CLASS	MR::SetBitIteratorT< EdgeBitSet > (UndirectedEdgeSetBitIterator, SetBitIteratorT< UndirectedEdgeBitSet >)) struct Color
MRMESH_CLASS	MR::Vector2< bool > (Vector2i, Vector2< int >)(Vector2i64
MRMESH_CLASS	MR::Vector2< Int64 > (Vector2f, Vector2< float >)(Vector2d
MRMESH_CLASS	MR::Vector3< bool > (Vector3i, Vector3< int >)(Vector3i64
MRMESH_CLASS	MR::Vector3< Int64 > (Vector3f, Vector3< float >)(Vector3d
	MR::Vector4< bool > (Vector4i, Vector4< int >)(Vector4i64
	MR::Vector4< Int64 > (Vector4f, Vector4< float >)(Vector4d
	MR::Matrix2< bool > (Matrix2i, Matrix2< int >)(Matrix2i64
	MR::Matrix2< Int64 > (Matrix2f, Matrix2< float >)(Matrix2d
	MR::Matrix3< bool > (Matrix3i, Matrix3< int >)(Matrix3i64
	MR::Matrix3< Int64 > (Matrix3f, Matrix3< float >)(Matrix3d
	MR::Matrix4< bool > (Matrix4i, Matrix4< int >)(Matrix4i64
	MR::Matrix4< Int64 > (Matrix4f, Matrix4< float >)(Matrix4d
	MR::SymMatrix2< bool > (SymMatrix2i, SymMatrix2< int >)(SymMatrix2i64
	MR::SymMatrix2< Int64 > (SymMatrix2f, SymMatrix2< float >)(SymMatrix2d
	MR::SymMatrix3< bool > (SymMatrix3i, SymMatrix3< int >)(SymMatrix3i64
	MR::SymMatrix3< Int64 > (SymMatrix3f, SymMatrix3< float >)(SymMatrix3d
	MR::SymMatrix4< bool > (SymMatrix4i, SymMatrix4< int >)(SymMatrix4i64
	MR::SymMatrix4< Int64 > (SymMatrix4f, SymMatrix4< float >)(SymMatrix4d
	MR::AffineXf< Vector2< float > > (AffineXf2d, AffineXf< Vector2< double > >)(AffineXf3f
	MR::AffineXf< Vector3< float > > (AffineXf3d, AffineXf< Vector3< double > >)) template< typename T > using AffineXf2
	MR::RigidXf3< float > (RigidXf3d, RigidXf3< double >)) 1((template< typename T > struct)
	MR::RigidScaleXf3< float > (RigidScaleXf3d, RigidScaleXf3< double >)) class PointToPointAligningTransform
	MR::Sphere< Vector2< float > > (Sphere2d, Sphere< Vector2< double > >)(Sphere3f
	MR::Sphere< Vector3< float > > (Sphere3d, Sphere< Vector3< double > >)) template< typename T > using Sphere2
	MR::Line< Vector2< float > > (Line2d, Line< Vector2< double > >)(Line3f
	MR::Line< Vector3< float > > (Line3d, Line< Vector3< double > >)) template< typename T > using Line2
	MR::LineSegm< Vector2< float > > (LineSegm2d, LineSegm< Vector2< double > >)(LineSegm3f
	MR::LineSegm< Vector3< float > > (LineSegm3d, LineSegm< Vector3< double > >)) template< typename T > using LineSegm2
	MR::Parabola< float > (Parabolad, Parabola< double >)) 1((template< typename T > class)
	MR::BestFitParabola< float > (BestFitParabolad, BestFitParabola< double >)) 1((template< typename T > class)
	MR::Cylinder3< float > (Cylinder3d, Cylinder3< double >)) 1((template< typename T > class)
	MR::Cone3< float > (Cone3d, Cone3< double >)) template< typename V > using Contour
	No canonical typedefs here, because those ultimately boil to std::vector, which isn't under our control.
	MR::Plane3< float > (Plane3d, Plane3< double >)) 1((template< typename V > struct MRMESH_CLASS)
	MR::Box< int > (Box1i64, Box< Int64 >)(Box1f
	MR::Box< float > (Box1d, Box< double >)(Box2i
	MR::Box< Vector2< int > > (Box2i64, Box< Vector2< Int64 > >)(Box2f
	MR::Box< Vector2< float > > (Box2d, Box< Vector2< double > >)(Box3i
	MR::Box< Vector3< int > > (Box3i64, Box< Vector3< Int64 > >)(Box3f
	MR::Box< Vector3< float > > (Box3d, Box< Vector3< double > >)) using Box1ll
template<typename V>
struct MRMESH_CLASS	MR::Ball (Ball1f, Ball< float >)(Ball1d
struct MRMESH_CLASS	MR::Ball< double > (Ball2f, Ball< Vector2< float > >)(Ball2d
struct MRMESH_CLASS	MR::Ball< Vector2< double > > (Ball3f, Ball< Vector3< float > >)(Ball3d
template<typename V>
struct MRMESH_CLASS	MR::CubicBezierCurve (CubicBezierCurve2f, CubicBezierCurve< Vector2< float > >)(CubicBezierCurve2d
struct MRMESH_CLASS	MR::CubicBezierCurve< Vector2< double > > (CubicBezierCurve3f, CubicBezierCurve< Vector3< float > >)(CubicBezierCurve3d
	MR::QuadraticForm< Vector2< float > > (QuadraticForm2d, QuadraticForm< Vector2< double > >)(QuadraticForm3f
	MR::QuadraticForm< Vector3< float > > (QuadraticForm3d, QuadraticForm< Vector3< double > >)) template< typename T > using QuadraticForm2
	MR::Quaternion< float > (Quaterniond, Quaternion< double >)) template< typename T > using Triangle3
	No canonical typedefs because std::array is not under our control.
	MR::SegmPoint< float > (SegmPointd, SegmPoint< double >)) struct EdgePoint
	MR::TriPoint< float > (TriPointd, TriPoint< double >)) struct PointOnFace
template<typename T, typename I>
class MRMESH_CLASS	MR::Vector (Edges, Vector< TwoVertIds, UndirectedEdgeId >)(Triangulation
	mapping from UndirectedEdgeId to its end vertices
class MRMESH_CLASS	MR::Vector< ThreeVertIds, FaceId > (TriCornerUVCoords, Vector< ThreeUVCoords, FaceId >)(Dipoles
	mapping from FaceId to a triple of UV-coordinates
class MRMESH_CLASS	MR::Vector< Dipole, NodeId > (FaceMap, Vector< FaceId, FaceId >)(VertMap
class MRMESH_CLASS	MR::Vector< VertId, VertId > (EdgeMap, Vector< EdgeId, EdgeId >)(UndirectedEdgeMap
class MRMESH_CLASS	MR::Vector< UndirectedEdgeId, UndirectedEdgeId > (ObjMap, Vector< ObjId, ObjId >)(WholeEdgeMap
	mapping of whole edges: map[e]->f, map[e.sym()]->f.sym(), where only map[e] for even edges is stored
class MRMESH_CLASS	MR::Vector< EdgeId, UndirectedEdgeId > (UndirectedEdge2RegionMap, Vector< RegionId, UndirectedEdgeId >)(Face2RegionMap
class MRMESH_CLASS	MR::Vector< RegionId, FaceId > (Vert2RegionMap, Vector< RegionId, VertId >)(VertCoords
class MRMESH_CLASS	MR::Vector< Vector3f, VertId > (VertCoords2, Vector< Vector2f, VertId >)(VertNormals
class MRMESH_CLASS	MR::Vector< Vector3f, VertId > (VertUVCoords, Vector< UVCoord, VertId >)(FaceNormals
class MRMESH_CLASS	MR::Vector< Vector3f, FaceId > (TexturePerFace, Vector< TextureId, FaceId >)(VertColors
class MRMESH_CLASS	MR::Vector< Color, VertId > (FaceColors, Vector< Color, FaceId >)(EdgeColors
class MRMESH_CLASS	MR::Vector< Color, EdgeId > (UndirectedEdgeColors, Vector< Color, UndirectedEdgeId >)(VertScalars
class MRMESH_CLASS	MR::Vector< float, VertId > (FaceScalars, Vector< float, FaceId >)(EdgeScalars
class MRMESH_CLASS	MR::Vector< float, EdgeId > (UndirectedEdgeScalars, Vector< float, UndirectedEdgeId >)) using VertPredicate
template<typename T>
bool	MR::contains (const std::function< bool(Id< T >)> &pred, Id< T > id)
template<typename T, typename I>
struct MRMESH_CLASS	MR::BMap (FaceBMap, BMap< FaceId, FaceId >)(VertBMap
struct MRMESH_CLASS	MR::BMap< VertId, VertId > (EdgeBMap, BMap< EdgeId, EdgeId >)(UndirectedEdgeBMap
struct MRMESH_CLASS	MR::BMap< UndirectedEdgeId, UndirectedEdgeId > (WholeEdgeBMap, BMap< EdgeId, UndirectedEdgeId >)) template< typename T
template<typename T>
struct MRMESH_CLASS	MR::MeshRegion (MeshPart, MeshRegion< FaceTag >)(MeshVertPart
	MR::Polyline< Vector2f > (Polyline3, Polyline< Vector3f >)) 1((template< typename V > class MRMESH_CLASS)
	MR::AABBTreePolyline< Vector2f > (AABBTreePolyline3, AABBTreePolyline< Vector3f >)) template< typename T > struct IntersectionPrecomputes
	MR::PolylineProjectionResult< Vector2f > (PolylineProjectionResult3, PolylineProjectionResult< Vector3f >)) 1((template< typename V > struct)
	MR::PolylineProjectionWithOffsetResult< Vector2f > (PolylineProjectionWithOffsetResult3, PolylineProjectionWithOffsetResult< Vector3f >)) class DistanceMap
template<typename Tag>
class MRMESH_CLASS	MR::ColorMapAggregator (VertColorMapAggregator, ColorMapAggregator< VertTag >)(UndirEdgeColorMapAggregator
class MRMESH_CLASS	MR::ColorMapAggregator< UndirectedEdgeTag > (FaceColorMapAggregator, ColorMapAggregator< FaceTag >)) template< typename T > class FewSmallest
template<typename T>
constexpr T	MR::sqr (T x) noexcept
	squared value
template<typename T>
constexpr int	MR::sgn (T x) noexcept
	sign of given value in { -1, 0, 1 }
template<typename T>
constexpr T	MR::distance (T x, T y) noexcept
	absolute difference between two value
template<typename T>
constexpr T	MR::distanceSq (T x, T y) noexcept
	squared difference between two value
template<typename V, typename T>
constexpr auto	MR::lerp (V v0, V v1, T t) noexcept
	Linear interpolation: returns v0 when t==0 and v1 when t==1.
template<class... Ts>
	MR::overloaded (Ts...) -> overloaded< Ts... >
	explicit deduction guide (not needed as of C++20, but still needed in Clang)
constexpr auto	MR::Locale::translate_noop (const char *str) noexcept
	special no-op inline functions to mark string literal as translatable
constexpr auto	MR::Locale::translate_noop (const char *ctx, const char *str) noexcept
constexpr auto	MR::Locale::translate_noop (const char *single, const char *plural, Int64 n) noexcept
constexpr auto	MR::Locale::translate_noop (const char *ctx, const char *single, const char *plural, Int64 n) noexcept

Variables
constexpr NoInit	MR::noInit
template<typename T>
struct MRMESH_CLASS	MR::NoDefInit
class MRMESH_CLASS	MR::EdgeTag
class MRMESH_CLASS	MR::UndirectedEdgeTag
class MRMESH_CLASS	MR::FaceTag
class MRMESH_CLASS	MR::VertTag
class MRMESH_CLASS	MR::PixelTag
class MRMESH_CLASS	MR::VoxelTag
class MRMESH_CLASS	MR::RegionTag
class MRMESH_CLASS	MR::NodeTag
class MRMESH_CLASS	MR::ObjTag
class MRMESH_CLASS	MR::TextureTag
class MRMESH_CLASS	MR::GraphVertTag
class MRMESH_CLASS	MR::GraphEdgeTag
template<>
class MRMESH_CLASS Id< GraphEdgeTag > class MR::EdgeId	MR::Id< EdgeTag >
template<>
class MR::VoxelId	MR::Id< VoxelTag >
class MRMESH_CLASS	MR::I = size_t> class MRMESH_CLASS Buffer
class MRMESH_CLASS	MR::BitSet
template<typename T>
	MR::struct
MRMESH_CLASS	MR::Vector2
MRMESH_CLASS	MR::Vector2b
MRMESH_CLASS	MR::Vector3
MRMESH_CLASS	MR::Vector3b
	MR::Vector4
	MR::Vector4b
	MR::Matrix2
	MR::Matrix2b
	MR::Matrix3
	MR::Matrix3b
	MR::Matrix4
	MR::Matrix4b
	MR::SymMatrix2
	MR::SymMatrix2b
	MR::SymMatrix3
	MR::SymMatrix3b
	MR::SymMatrix4
	MR::SymMatrix4b
	MR::AffineXf
	MR::AffineXf2f
	MR::RigidXf3
	MR::RigidXf3f
	MR::RigidScaleXf3
	MR::RigidScaleXf3f
	MR::Sphere
	MR::Sphere2f
	MR::Line
	MR::Line2f
	MR::LineSegm
	MR::LineSegm2f
	MR::Parabola
	MR::Parabolaf
	MR::BestFitParabola
	MR::BestFitParabolaf
	MR::Cylinder3
	MR::Cylinder3f
	MR::Cone3
	MR::Cone3f
	MR::Plane3
	MR::Plane3f
	MR::Box
	MR::Box1i
	MR::QuadraticForm
	MR::QuadraticForm2f
	MR::Quaternion
	MR::Quaternionf
	MR::SegmPoint
	MR::SegmPointf
	MR::TriPoint
	MR::TriPointf
struct MRMESH_CLASS	MR::Dipole
struct MRMESH_CLASS	MR::Hash = phmap::priv::hash_default_hash<T>
struct MRMESH_CLASS	MR::Eq
class MRMESH_CLASS	MR::MeshTopology
struct MRMESH_CLASS	MR::Mesh
struct MRMESH_CLASS	MR::EdgeLengthMesh
class MRMESH_CLASS	MR::MeshOrPoints
struct MRMESH_CLASS	MR::PointCloud
struct MRMESH_CLASS	MR::PointCloudPart
class MRMESH_CLASS	MR::AABBTree
class MRMESH_CLASS	MR::AABBTreePoints
class MRMESH_CLASS	MR::AABBTreeObjects
struct MRMESH_CLASS	MR::CloudPartMapping
struct MRMESH_CLASS	MR::PartMapping
	MR::Polyline
	MR::Polyline2
	MR::AABBTreePolyline
	MR::AABBTreePolyline2
	MR::PolylineProjectionWithOffsetResult
	MR::Polyline2ProjectionWithOffsetResult
class MRMESH_CLASS	MR::ChangeSceneAction
template<typename...>
constexpr bool	MR::dependent_false = false

Macro Definition Documentation

_t

#define _t

(

...

)

Value:

MR::Locale::translate_noop( __VA_ARGS__ )

MR_CPP_STANDARD_DATE

#define MR_CPP_STANDARD_DATE   __cplusplus

Check C++ version.

Not-zero _ITERATOR_DEBUG_LEVEL in Microsoft STL greatly reduces the performance of STL containers.

Pre-build binaries from MeshLib distribution are prepared with _ITERATOR_DEBUG_LEVEL=0, and if you build MeshLib by yourself then _ITERATOR_DEBUG_LEVEL=0 is also selected see 1) vcpkg/triplets/x64-windows-meshlib.cmake and 2) MeshLib/source/common.props Please note that all other modules (.exe, .dll, .lib) with MS STL calls in your application also need to define exactly the same value of _ITERATOR_DEBUG_LEVEL to be operational after linking.

If you deliberately would like to work with not zero _ITERATOR_DEBUG_LEVEL, then please define additionally MR_ITERATOR_DEBUG_LEVEL with the same value to indicate that it is done intentionally (and you are ok with up to 100x slowdown).

MR_UNREACHABLE

#define MR_UNREACHABLE   { assert( false ); return {}; }

MR_UNREACHABLE_NO_RETURN

#define MR_UNREACHABLE_NO_RETURN   assert( false );

MRMESH_API

#define MRMESH_API   __attribute__((visibility("default")))

Note 201709. C++20 usually sets 202002, while C++17 sets 201703. This 201709 is what GCC 10 sets on -std=c++20 (presumably to indicate incomplete implementation?). Other compilers we use don't have this issue. Also note __CUDACC__ - currently our Cuda code is compiled as C++17 (compiler doesn't support C++20?), and we carefully avoid headers incomaptible with C++17. – Curently we have no macros that don't work with the old preprocessor. Leaving the check here to possibly be enabled later. Reject old MSVC preprocessor. Note that we exclude Cuda here. Not 100% sure if it has a good preprocessor, or we just avoid including the headers sensitive to it in Cuda. #if defined(_MSC_VER) && !defined(clang) && (!defined(_MSVC_TRADITIONAL) || _MSVC_TRADITIONAL == 1) && !defined(CUDACC) #error MSVC users must enable the new standard-conformant preprocessor using /Zc:preprocessor! #endif

MRMESH_CLASS

#define MRMESH_CLASS   __attribute__((visibility("default")))

to fix undefined reference to typeinfo/vtable Also it's important to use this on any type for which typeid is used in multiple shared libraries, and then passed across library boundaries. Otherwise on Mac the resulting typeids will incorrectly compare not equal. https:/// stackoverflow.com/q/29717029/7325599