From 56f74510c2d1a64d3aafcfc8934ab702041c2b15 Mon Sep 17 00:00:00 2001 From: Yao Zi Date: Thu, 19 Mar 2026 04:57:46 +0000 Subject: [PATCH] [freecad] 1.0.2-1: init package --- 0001-Drop-Boost-system.patch | 13 + 0002-Link-libOpenGL-instead-of-libGL.patch | 26 + ...y3.13-Update-PyCXX-to-version-7.1.11.patch | 86 ++ ...-Disable-Py_UNICODE-support-in-PyCXX.patch | 115 ++ 0005-VTK-9.6-compatiblity-fixes.patch | 1242 +++++++++++++++++ 0006-do-not-include-execinfo.patch | 46 + 0007-Mod-Part-Do-not-use-ARB-API.patch | 76 + 0008-CMake-Fix-Eigen3-version-search.patch | 53 + ...QuarterWidget-request-OpenGL-compati.patch | 74 + PKGBUILD | 109 ++ 10 files changed, 1840 insertions(+) create mode 100644 0001-Drop-Boost-system.patch create mode 100644 0002-Link-libOpenGL-instead-of-libGL.patch create mode 100644 0003-Py3.13-Update-PyCXX-to-version-7.1.11.patch create mode 100644 0004-Py3.13-Disable-Py_UNICODE-support-in-PyCXX.patch create mode 100644 0005-VTK-9.6-compatiblity-fixes.patch create mode 100644 0006-do-not-include-execinfo.patch create mode 100644 0007-Mod-Part-Do-not-use-ARB-API.patch create mode 100644 0008-CMake-Fix-Eigen3-version-search.patch create mode 100644 0009-Gui-Application-QuarterWidget-request-OpenGL-compati.patch create mode 100644 PKGBUILD diff --git a/0001-Drop-Boost-system.patch b/0001-Drop-Boost-system.patch new file mode 100644 index 00000000..4bcbe5c0 --- /dev/null +++ b/0001-Drop-Boost-system.patch @@ -0,0 +1,13 @@ +diff --git a/cMake/FreeCAD_Helpers/SetupBoost.cmake b/cMake/FreeCAD_Helpers/SetupBoost.cmake +index 0bb1343c3f11..1a389bf797c2 100644 +--- a/cMake/FreeCAD_Helpers/SetupBoost.cmake ++++ b/cMake/FreeCAD_Helpers/SetupBoost.cmake +@@ -3,7 +3,7 @@ macro(SetupBoost) + + set(_boost_TEST_VERSIONS ${Boost_ADDITIONAL_VERSIONS}) + +- set (BOOST_COMPONENTS filesystem program_options regex system thread date_time) ++ set (BOOST_COMPONENTS filesystem program_options regex thread date_time) + find_package(Boost ${BOOST_MIN_VERSION} + COMPONENTS ${BOOST_COMPONENTS} REQUIRED) + diff --git a/0002-Link-libOpenGL-instead-of-libGL.patch b/0002-Link-libOpenGL-instead-of-libGL.patch new file mode 100644 index 00000000..afe911eb --- /dev/null +++ b/0002-Link-libOpenGL-instead-of-libGL.patch @@ -0,0 +1,26 @@ +diff --git a/src/Gui/CMakeLists.txt b/src/Gui/CMakeLists.txt +index b928eccc124f..18329a26692e 100644 +--- a/src/Gui/CMakeLists.txt ++++ b/src/Gui/CMakeLists.txt +@@ -93,7 +93,7 @@ else(MSVC) + FreeCADApp + ${COIN3D_LIBRARIES} + ${Boost_LIBRARIES} +- ${OPENGL_gl_LIBRARY} ++ ${OPENGL_opengl_LIBRARY} + ${3DCONNEXION_LINKFLAGS} + ) + endif(MSVC) +diff --git a/src/Mod/CAM/PathSimulator/AppGL/CMakeLists.txt b/src/Mod/CAM/PathSimulator/AppGL/CMakeLists.txt +index 9191cbdc1ffd..1ad2e5492921 100644 +--- a/src/Mod/CAM/PathSimulator/AppGL/CMakeLists.txt ++++ b/src/Mod/CAM/PathSimulator/AppGL/CMakeLists.txt +@@ -26,7 +26,7 @@ set(CAMSimulator_LIBS + FreeCADApp + FreeCADGui + ${QtOpenGL_LIBRARIES} +- ${OPENGL_gl_LIBRARY} ++ ${OPENGL_opengl_LIBRARY} + ) + + SET(CAMSimulator_SRCS_Python diff --git a/0003-Py3.13-Update-PyCXX-to-version-7.1.11.patch b/0003-Py3.13-Update-PyCXX-to-version-7.1.11.patch new file mode 100644 index 00000000..4644e454 --- /dev/null +++ b/0003-Py3.13-Update-PyCXX-to-version-7.1.11.patch @@ -0,0 +1,86 @@ +From 39ca75bac294a69504e1ea551e1615816e3aec06 Mon Sep 17 00:00:00 2001 +From: wmayer +Date: Tue, 27 May 2025 11:34:34 +0200 +Subject: [PATCH] Py3.13: Update PyCXX to version 7.1.11 + +--- + src/CXX/Python3/Objects.hxx | 12 ++++++------ + src/CXX/Python3/cxxsupport.cxx | 2 +- + src/CXX/Version.hxx | 2 +- + 3 files changed, 8 insertions(+), 8 deletions(-) + +diff --git a/src/CXX/Python3/Objects.hxx b/src/CXX/Python3/Objects.hxx +index 4894ba9c2821..0ed3fc969b33 100644 +--- a/src/CXX/Python3/Objects.hxx ++++ b/src/CXX/Python3/Objects.hxx +@@ -1787,8 +1787,8 @@ namespace Py + typedef std::basic_string unicodestring; + extern Py_UNICODE unicode_null_string[1]; + #endif +- typedef std::basic_string ucs4string; +- extern Py_UCS4 ucs4_null_string[1]; ++ typedef std::basic_string ucs4string; ++ extern char32_t ucs4_null_string[1]; + + class PYCXX_EXPORT Byte: public Object + { +@@ -2152,13 +2152,13 @@ namespace Py + // Need these c'tors becuase Py_UNICODE is 2 bytes + // User may use "int" or "unsigned int" as the unicode type + String( const unsigned int *s, int length ) +- : SeqBase( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, reinterpret_cast( s ), length ), true ) ++ : SeqBase( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, reinterpret_cast( s ), length ), true ) + { + validate(); + } + + String( const int *s, int length ) +- : SeqBase( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, reinterpret_cast( s ), length ), true ) ++ : SeqBase( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, reinterpret_cast( s ), length ), true ) + { + validate(); + } +@@ -2196,7 +2196,7 @@ namespace Py + #if !defined( Py_UNICODE_WIDE ) && !defined( Py_LIMITED_API ) + String &operator=( const ucs4string &v ) + { +- set( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, reinterpret_cast( v.data() ), v.length() ), true ); ++ set( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, reinterpret_cast( v.data() ), v.length() ), true ); + return *this; + } + #endif +@@ -2237,7 +2237,7 @@ namespace Py + { + ifPyErrorThrowCxxException(); + } +- ucs4string ucs4( buf, size() ); ++ ucs4string ucs4( reinterpret_cast(buf), size() ); + delete[] buf; + + return ucs4; +diff --git a/src/CXX/Python3/cxxsupport.cxx b/src/CXX/Python3/cxxsupport.cxx +index a22160bd026a..3c58afe9600d 100644 +--- a/src/CXX/Python3/cxxsupport.cxx ++++ b/src/CXX/Python3/cxxsupport.cxx +@@ -48,7 +48,7 @@ Py_ssize_t numeric_limits_max() + #if !defined(Py_LIMITED_API) + Py_UNICODE unicode_null_string[1] = { 0 }; + #endif +-Py_UCS4 ucs4_null_string[1] = { 0 }; ++char32_t ucs4_null_string[1] = { 0 }; + + Type Object::type() const + { +diff --git a/src/CXX/Version.hxx b/src/CXX/Version.hxx +index 59fe3c203b86..a814ac92d6aa 100644 +--- a/src/CXX/Version.hxx ++++ b/src/CXX/Version.hxx +@@ -40,7 +40,7 @@ + + #define PYCXX_VERSION_MAJOR 7 + #define PYCXX_VERSION_MINOR 1 +-#define PYCXX_VERSION_PATCH 9 ++#define PYCXX_VERSION_PATCH 11 + #define PYCXX_MAKEVERSION( major, minor, patch ) ((major<<16)|(minor<<8)|(patch)) + #define PYCXX_VERSION PYCXX_MAKEVERSION( PYCXX_VERSION_MAJOR, PYCXX_VERSION_MINOR, PYCXX_VERSION_PATCH ) + #endif diff --git a/0004-Py3.13-Disable-Py_UNICODE-support-in-PyCXX.patch b/0004-Py3.13-Disable-Py_UNICODE-support-in-PyCXX.patch new file mode 100644 index 00000000..77a28952 --- /dev/null +++ b/0004-Py3.13-Disable-Py_UNICODE-support-in-PyCXX.patch @@ -0,0 +1,115 @@ +From 692d40916a61c813560c72c80c7c91c8c44b672a Mon Sep 17 00:00:00 2001 +From: wmayer +Date: Tue, 27 May 2025 11:54:04 +0200 +Subject: [PATCH] Py3.13: Disable Py_UNICODE support in PyCXX + +--- + src/CXX/Python3/Config.hxx | 4 ++++ + src/CXX/Python3/Objects.hxx | 16 ++++++++-------- + src/CXX/Python3/cxxsupport.cxx | 2 +- + 3 files changed, 13 insertions(+), 9 deletions(-) + +diff --git a/src/CXX/Python3/Config.hxx b/src/CXX/Python3/Config.hxx +index 08aa49526957..76bd4b786bdc 100644 +--- a/src/CXX/Python3/Config.hxx ++++ b/src/CXX/Python3/Config.hxx +@@ -133,6 +133,10 @@ + typedef long int Py_hash_t; + #endif + ++#if PY_VERSION_HEX >= 0x030d0000 ++#define Py_UNICODE_DEPRECATED ++#endif ++ + #ifndef PYCXX_PYTHON_2TO3 + #define PYCXX_PYTHON_2TO3 + #endif +diff --git a/src/CXX/Python3/Objects.hxx b/src/CXX/Python3/Objects.hxx +index 0ed3fc969b33..e216d6858d8a 100644 +--- a/src/CXX/Python3/Objects.hxx ++++ b/src/CXX/Python3/Objects.hxx +@@ -1783,7 +1783,7 @@ namespace Py + // Python strings return strings as individual elements. + // I'll try having a class Char which is a String of length 1 + // +-#if !defined(Py_LIMITED_API) ++#if !defined(Py_LIMITED_API) && !defined(Py_UNICODE_DEPRECATED) + typedef std::basic_string unicodestring; + extern Py_UNICODE unicode_null_string[1]; + #endif +@@ -1979,7 +1979,7 @@ namespace Py + validate(); + } + +-#if !defined( Py_LIMITED_API ) ++#if !defined( Py_LIMITED_API ) && !defined(Py_UNICODE_DEPRECATED) + Char( Py_UNICODE v ) + : Object( PyUnicode_FromOrdinal( v ), true ) + { +@@ -1987,7 +1987,7 @@ namespace Py + } + #endif + +-#if !defined( Py_LIMITED_API ) ++#if !defined( Py_LIMITED_API ) && !defined(Py_UNICODE_DEPRECATED) + Char( const unicodestring &v ) + : Object( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, const_cast( v.data() ),1 ), true ) + { +@@ -2008,7 +2008,7 @@ namespace Py + return *this; + } + +-#if !defined( Py_LIMITED_API ) ++#if !defined( Py_LIMITED_API ) && !defined(Py_UNICODE_DEPRECATED) + Char &operator=( const unicodestring &v ) + { + set( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, const_cast( v.data() ), 1 ), true ); +@@ -2016,7 +2016,7 @@ namespace Py + } + #endif + +-#if !defined( Py_LIMITED_API ) ++#if !defined( Py_LIMITED_API ) && !defined(Py_UNICODE_DEPRECATED) + Char &operator=( int v_ ) + { + Py_UNICODE v( v_ ); +@@ -2025,7 +2025,7 @@ namespace Py + } + #endif + +-#if !defined( Py_LIMITED_API ) ++#if !defined( Py_LIMITED_API ) && !defined(Py_UNICODE_DEPRECATED) + Char &operator=( Py_UNICODE v ) + { + set( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, &v, 1 ), true ); +@@ -2164,7 +2164,7 @@ namespace Py + } + #endif + +-#if !defined( Py_LIMITED_API ) ++#if !defined( Py_LIMITED_API ) && !defined(Py_UNICODE_DEPRECATED) + String( const Py_UNICODE *s, int length ) + : SeqBase( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, s, length ), true ) + { +@@ -2185,7 +2185,7 @@ namespace Py + return *this; + } + +-#if !defined( Py_LIMITED_API ) ++#if !defined( Py_LIMITED_API ) && !defined(Py_UNICODE_DEPRECATED) + String &operator=( const unicodestring &v ) + { + set( PyUnicode_FromKindAndData( PyUnicode_4BYTE_KIND, const_cast( v.data() ), v.length() ), true ); +diff --git a/src/CXX/Python3/cxxsupport.cxx b/src/CXX/Python3/cxxsupport.cxx +index 3c58afe9600d..dad7198648dc 100644 +--- a/src/CXX/Python3/cxxsupport.cxx ++++ b/src/CXX/Python3/cxxsupport.cxx +@@ -45,7 +45,7 @@ Py_ssize_t numeric_limits_max() + return std::numeric_limits::max(); + } + +-#if !defined(Py_LIMITED_API) ++#if !defined(Py_LIMITED_API) && !defined(Py_UNICODE_DEPRECATED) + Py_UNICODE unicode_null_string[1] = { 0 }; + #endif + char32_t ucs4_null_string[1] = { 0 }; diff --git a/0005-VTK-9.6-compatiblity-fixes.patch b/0005-VTK-9.6-compatiblity-fixes.patch new file mode 100644 index 00000000..dafb8072 --- /dev/null +++ b/0005-VTK-9.6-compatiblity-fixes.patch @@ -0,0 +1,1242 @@ +From bd90728f886bbeb6d69aafd4f68f934109b96f91 Mon Sep 17 00:00:00 2001 +From: Louis Gombert +Date: Thu, 27 Nov 2025 19:45:04 +0100 +Subject: [PATCH 1/6] Smesh: Remove the VTK_CELL_ARRAY_V2 compatibility define + +This define was introduced in 9.0 for compatiblity with vtk 8.X, and removed for VTK 9.6. As we now support VTK>=9.1, it is not necessary to keep it. +--- + .../salomesmesh/inc/SMDS_MeshElement.hxx | 4 --- + .../salomesmesh/inc/SMDS_UnstructuredGrid.hxx | 8 ++--- + .../salomesmesh/src/SMDS/SMDS_BallElement.cpp | 7 ---- + .../salomesmesh/src/SMDS/SMDS_Mesh.cpp | 8 ++--- + .../src/SMDS/SMDS_Mesh0DElement.cpp | 13 ------- + .../src/SMDS/SMDS_UnstructuredGrid.cpp | 36 ++----------------- + .../salomesmesh/src/SMDS/SMDS_VtkEdge.cpp | 15 -------- + .../salomesmesh/src/SMDS/SMDS_VtkFace.cpp | 23 ------------ + .../salomesmesh/src/SMDS/SMDS_VtkVolume.cpp | 15 -------- + + src/Mod/Fem/App/PropertyPostDataObject.cpp | 2 -- + +Requires manual fixup for backporting, see end of the patch. + + src/Mod/Fem/Gui/ViewProviderFemPostObject.cpp | 4 --- + 11 files changed, 7 insertions(+), 128 deletions(-) + +diff --git a/src/3rdParty/salomesmesh/inc/SMDS_MeshElement.hxx b/src/3rdParty/salomesmesh/inc/SMDS_MeshElement.hxx +index d97a37bc51b8..184e10d9c120 100644 +--- a/src/3rdParty/salomesmesh/inc/SMDS_MeshElement.hxx ++++ b/src/3rdParty/salomesmesh/inc/SMDS_MeshElement.hxx +@@ -45,11 +45,7 @@ + //typedef unsigned short UShortType; + typedef short ShortType; + typedef int LongType; +-#ifdef VTK_CELL_ARRAY_V2 + typedef const vtkIdType* vtkIdTypePtr; +-#else +-typedef vtkIdType* vtkIdTypePtr; +-#endif + class SMDS_MeshNode; + class SMDS_MeshEdge; + class SMDS_MeshFace; +diff --git a/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx b/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx +index f02337cf52af..4baa06f2a245 100644 +--- a/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx ++++ b/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx +@@ -95,14 +95,10 @@ public: + std::map >& nodeQuadDomains); + vtkCellLinks* GetLinks() + { +-#ifdef VTK_CELL_ARRAY_V2 +- #if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER_QUICK >= 90300000000 + return static_cast(vtkUnstructuredGrid::GetLinks()); +- #else +- return static_cast(GetCellLinks()); +- #endif + #else +- return Links; ++ return static_cast(GetCellLinks()); + #endif + } + SMDS_Downward* getDownArray(unsigned char vtkType) +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_BallElement.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_BallElement.cpp +index c5fd8c91cd07..e257960ac65e 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_BallElement.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_BallElement.cpp +@@ -67,16 +67,9 @@ void SMDS_BallElement::SetDiameter(double diameter) + bool SMDS_BallElement::ChangeNode (const SMDS_MeshNode * node) + { + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); +-#ifdef VTK_CELL_ARRAY_V2 + vtkNew cellPoints; + grid->GetCellPoints(myVtkID, cellPoints.GetPointer()); + cellPoints->SetId(0, node->getVtkId()); +-#else +- vtkIdType npts = 0; +- vtkIdType* pts = 0; +- grid->GetCellPoints(myVtkID, npts, pts); +- pts[0] = node->getVtkId(); +-#endif + SMDS_Mesh::_meshList[myMeshId]->setMyModified(); + return true; + } +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp +index baa6eadc9319..012a4d908c9a 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp +@@ -4712,14 +4712,10 @@ void SMDS_Mesh::dumpGrid(string ficdump) + ficcon << endl; + } + ficcon << "-------------------------------- connectivity " << nbPoints << endl; +-#ifdef VTK_CELL_ARRAY_V2 +- #if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER_QUICK >= 90300000000 + vtkCellLinks *links = static_cast(myGrid->GetLinks()); +- #else +- vtkCellLinks *links = static_cast(myGrid->GetCellLinks()); +- #endif + #else +- vtkCellLinks *links = myGrid->GetCellLinks(); ++ vtkCellLinks *links = static_cast(myGrid->GetCellLinks()); + #endif + for (int i=0; igetGrid(); +-#ifdef VTK_CELL_ARRAY_V2 + vtkNew cellPoints; + grid->GetCellPoints(myVtkID, cellPoints.GetPointer()); + if (nbNodes != cellPoints->GetNumberOfIds()) +@@ -156,18 +155,6 @@ bool SMDS_Mesh0DElement::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbN + } + myNode = nodes[0]; + cellPoints->SetId(0, myNode->getVtkId()); +-#else +- vtkIdType npts = 0; +- vtkIdType* pts = 0; +- grid->GetCellPoints(myVtkID, npts, pts); +- if (nbNodes != npts) +- { +- MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes); +- return false; +- } +- myNode = nodes[0]; +- pts[0] = myNode->getVtkId(); +-#endif + + SMDS_Mesh::_meshList[myMeshId]->setMyModified(); + return true; +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +index 4e9d6dc05764..bedf100002dc 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +@@ -341,11 +341,7 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes, + // (n1,n2,n3) and (id1,id2,...,idn1,id1,id2,...,idn2, ...) + // The Locations array in vtk 7.x kept the positions of the n's of the above array: (0, idn1 + 1, idn2 + 2). + // In vtk 9.x this array doesn't exist any more but its values can be determined with idni + i +-#ifdef VTK_CELL_ARRAY_V2 + vtkIdType oldLoc = ((vtkIdTypeArray *)(this->Connectivity->GetOffsetsArray()))->GetValue( j ) + j; +-#else +- vtkIdType oldLoc = this->Locations->GetValue(j); +-#endif + vtkIdType nbpts; + vtkIdTypePtr oldPtsCell = 0; + this->Connectivity->GetCell(oldLoc, nbpts, oldPtsCell); +@@ -965,7 +961,6 @@ void SMDS_UnstructuredGrid::GetNodeIds(std::set& nodeSet, int downId, unsig + */ + void SMDS_UnstructuredGrid::ModifyCellNodes(int vtkVolId, std::map localClonedNodeIds) + { +-#ifdef VTK_CELL_ARRAY_V2 + vtkNew cellPoints; + this->GetCellPoints(vtkVolId, cellPoints.GetPointer()); + for (vtkIdType i = 0; i < cellPoints->GetNumberOfIds(); i++) +@@ -979,22 +974,6 @@ void SMDS_UnstructuredGrid::ModifyCellNodes(int vtkVolId, std::map loc + //this->AddReferenceToCell(pts[i], vtkVolId); + } + } +-#else +- vtkIdType npts = 0; +- vtkIdType *pts; // will refer to the point id's of the face +- this->GetCellPoints(vtkVolId, npts, pts); +- for (int i = 0; i < npts; i++) +- { +- if (localClonedNodeIds.count(pts[i])) +- { +- vtkIdType oldpt = pts[i]; +- pts[i] = localClonedNodeIds[oldpt]; +- //MESSAGE(oldpt << " --> " << pts[i]); +- //this->RemoveReferenceToCell(oldpt, vtkVolId); +- //this->AddReferenceToCell(pts[i], vtkVolId); +- } +- } +-#endif + } + + /*! reorder the nodes of a face +@@ -1024,25 +1003,16 @@ void SMDS_UnstructuredGrid::BuildLinks() + this->Links->UnRegister(this); + } + +-#ifdef VTK_CELL_ARRAY_V2 + this->Links = SMDS_CellLinks::New(); + GetLinks()->Allocate(this->GetNumberOfPoints()); + GetLinks()->Register(this); +-//FIXME: vtk9 +- #if VTK_VERSION_NUMBER < VTK_VERSION_CHECK(9,3,0) ++#if VTK_VERSION_NUMBER < VTK_VERSION_CHECK(9,3,0) + GetLinks()->BuildLinks(this); +- #else ++#else + GetLinks()->SetDataSet(this); + GetLinks()->BuildLinks(); +- #endif +- GetLinks()->Delete(); +-#else +- this->Links = SMDS_CellLinks::New(); +- this->Links->Allocate(this->GetNumberOfPoints()); +- this->Links->Register(this); +- this->Links->BuildLinks(this, this->Connectivity); +- this->Links->Delete(); + #endif ++ GetLinks()->Delete(); + } + + /*! Create a volume (prism or hexahedron) by duplication of a face. +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkEdge.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkEdge.cpp +index 6d772a3cd4a0..d36e02049207 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkEdge.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkEdge.cpp +@@ -67,7 +67,6 @@ bool SMDS_VtkEdge::ChangeNodes(const SMDS_MeshNode * node1, const SMDS_MeshNode + bool SMDS_VtkEdge::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes) + { + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); +-#ifdef VTK_CELL_ARRAY_V2 + vtkNew cellPoints; + grid->GetCellPoints(myVtkID, cellPoints.GetPointer()); + if (nbNodes != cellPoints->GetNumberOfIds()) +@@ -79,20 +78,6 @@ bool SMDS_VtkEdge::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes) + { + cellPoints->SetId(i, nodes[i]->getVtkId()); + } +-#else +- vtkIdType npts = 0; +- vtkIdType* pts = 0; +- grid->GetCellPoints(myVtkID, npts, pts); +- if (nbNodes != npts) +- { +- MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes); +- return false; +- } +- for (int i = 0; i < nbNodes; i++) +- { +- pts[i] = nodes[i]->getVtkId(); +- } +-#endif + SMDS_Mesh::_meshList[myMeshId]->setMyModified(); + return true; + } +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkFace.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkFace.cpp +index cb981bfb18e6..4528cd7b5f5e 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkFace.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkFace.cpp +@@ -101,7 +101,6 @@ void SMDS_VtkFace::initQuadPoly(const std::vector& nodeIds, SMDS_Mesh + bool SMDS_VtkFace::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes) + { + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); +-#ifdef VTK_CELL_ARRAY_V2 + vtkNew cellPoints; + grid->GetCellPoints(myVtkID, cellPoints.GetPointer()); + if (nbNodes != cellPoints->GetNumberOfIds()) +@@ -113,20 +112,6 @@ bool SMDS_VtkFace::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes) + { + cellPoints->SetId(i, nodes[i]->getVtkId()); + } +-#else +- vtkIdType npts = 0; +- vtkIdType* pts = 0; +- grid->GetCellPoints(myVtkID, npts, pts); +- if (nbNodes != npts) +- { +- MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes); +- return false; +- } +- for (int i = 0; i < nbNodes; i++) +- { +- pts[i] = nodes[i]->getVtkId(); +- } +-#endif + SMDS_Mesh::_meshList[myMeshId]->setMyModified(); + return true; + } +@@ -372,18 +357,10 @@ SMDS_NodeIteratorPtr SMDS_VtkFace::interlacedNodesIterator() const + void SMDS_VtkFace::ChangeApex(SMDS_MeshNode* node) + { + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); +-#ifdef VTK_CELL_ARRAY_V2 + vtkNew cellPoints; + grid->GetCellPoints(myVtkID, cellPoints.GetPointer()); + grid->RemoveReferenceToCell(cellPoints->GetId(0), myVtkID); + cellPoints->SetId(0, node->getVtkId()); +-#else +- vtkIdType npts = 0; +- vtkIdType* pts = 0; +- grid->GetCellPoints(myVtkID, npts, pts); +- grid->RemoveReferenceToCell(pts[0], myVtkID); +- pts[0] = node->getVtkId(); +-#endif + node->AddInverseElement(this), + SMDS_Mesh::_meshList[myMeshId]->setMyModified(); + } +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp +index 19ebd0746c8f..ffc2aa5d2553 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp +@@ -133,7 +133,6 @@ void SMDS_VtkVolume::initPoly(const std::vector& nodeIds, + bool SMDS_VtkVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes) + { + vtkUnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); +-#ifdef VTK_CELL_ARRAY_V2 + vtkNew cellPoints; + grid->GetCellPoints(myVtkID, cellPoints.GetPointer()); + if (nbNodes != cellPoints->GetNumberOfIds()) +@@ -145,20 +144,6 @@ bool SMDS_VtkVolume::ChangeNodes(const SMDS_MeshNode* nodes[], const int nbNodes + { + cellPoints->SetId(i, nodes[i]->getVtkId()); + } +-#else +- vtkIdType npts = 0; +- vtkIdType* pts = 0; +- grid->GetCellPoints(myVtkID, npts, pts); +- if (nbNodes != npts) +- { +- MESSAGE("ChangeNodes problem: not the same number of nodes " << npts << " -> " << nbNodes); +- return false; +- } +- for (int i = 0; i < nbNodes; i++) +- { +- pts[i] = nodes[i]->getVtkId(); +- } +-#endif + SMDS_Mesh::_meshList[myMeshId]->setMyModified(); + return true; + } +diff --git a/src/Mod/Fem/Gui/ViewProviderFemPostObject.cpp b/src/Mod/Fem/Gui/ViewProviderFemPostObject.cpp +index fb4fffb4098f..034513abcec2 100644 +--- a/src/Mod/Fem/Gui/ViewProviderFemPostObject.cpp ++++ b/src/Mod/Fem/Gui/ViewProviderFemPostObject.cpp +@@ -75,11 +75,7 @@ + using namespace FemGui; + namespace sp = std::placeholders; + +-#ifdef VTK_CELL_ARRAY_V2 + using vtkIdTypePtr = const vtkIdType*; +-#else +-using vtkIdTypePtr = vtkIdType*; +-#endif + + // ---------------------------------------------------------------------------- + +-- +2.53.0 + + +From c9acda2a659f9ac079fefd2c0b8d6ff9c8a8238e Mon Sep 17 00:00:00 2001 +From: Louis Gombert +Date: Thu, 27 Nov 2025 20:46:57 +0100 +Subject: [PATCH 2/6] Standardize VTK version check pre-processing directives + +Check for the build date of the exact introduction of the feature instead of the next tagged version +--- + .../salomesmesh/inc/SMDS_UnstructuredGrid.hxx | 3 ++- + src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp | 3 ++- + src/3rdParty/salomesmesh/src/SMDS/SMDS_MeshNode.cpp | 13 +++++++------ + .../salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp | 2 +- + .../salomesmesh/src/SMESH/SMESH_MeshEditor.cpp | 5 +++-- + + src/Mod/Fem/App/FemPostPipeline.h | 2 +- + src/Mod/Fem/App/PreCompiled.h | 2 +- + +Changes to this two headers depend on other commits, and are not +necessary when backporting. + + 7 files changed, 17 insertions(+), 13 deletions(-) + +diff --git a/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx b/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx +index 4baa06f2a245..e8bfa90f4eb8 100644 +--- a/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx ++++ b/src/3rdParty/salomesmesh/inc/SMDS_UnstructuredGrid.hxx +@@ -28,6 +28,7 @@ + + #include + #include ++#include + + #include + #include +@@ -95,7 +96,7 @@ public: + std::map >& nodeQuadDomains); + vtkCellLinks* GetLinks() + { +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + return static_cast(vtkUnstructuredGrid::GetLinks()); + #else + return static_cast(GetCellLinks()); +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp +index 012a4d908c9a..c9a8c4a90cbc 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp +@@ -53,6 +53,7 @@ + #include + #include + #include ++#include + + #include + #include +@@ -4712,7 +4713,7 @@ void SMDS_Mesh::dumpGrid(string ficdump) + ficcon << endl; + } + ficcon << "-------------------------------- connectivity " << nbPoints << endl; +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks *links = static_cast(myGrid->GetLinks()); + #else + vtkCellLinks *links = static_cast(myGrid->GetCellLinks()); +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_MeshNode.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_MeshNode.cpp +index f5fc373f5dff..420c3a9bafeb 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_MeshNode.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_MeshNode.cpp +@@ -31,6 +31,7 @@ + #include "SMDS_IteratorOfElements.hxx" + #include "SMDS_Mesh.hxx" + #include ++#include + + #include "utilities.h" + #include "Utils_SALOME_Exception.hxx" +@@ -69,7 +70,7 @@ void SMDS_MeshNode::init(int id, int meshId, int shapeId, double x, double y, do + SMDS_UnstructuredGrid * grid = mesh->getGrid(); + vtkPoints *points = grid->GetPoints(); + points->InsertPoint(myVtkID, x, y, z); +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + SMDS_CellLinks *cellLinks = dynamic_cast(grid->GetLinks()); + #else + SMDS_CellLinks *cellLinks = dynamic_cast(grid->GetCellLinks()); +@@ -195,7 +196,7 @@ public: + SMDS_ElemIteratorPtr SMDS_MeshNode:: + GetInverseElementIterator(SMDSAbs_ElementType type) const + { +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks())->GetLink(myVtkID); + #else + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetCellLinks())->GetLink(myVtkID); +@@ -259,7 +260,7 @@ elementsIterator(SMDSAbs_ElementType type) const + return SMDS_MeshElement::elementsIterator(SMDSAbs_Node); + else + { +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks())->GetLink(myVtkID); + #else + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetCellLinks())->GetLink(myVtkID); +@@ -362,7 +363,7 @@ void SMDS_MeshNode::AddInverseElement(const SMDS_MeshElement* ME) + const SMDS_MeshCell *cell = dynamic_cast (ME); + assert(cell); + SMDS_UnstructuredGrid* grid = SMDS_Mesh::_meshList[myMeshId]->getGrid(); +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks *Links = static_cast(grid->GetLinks()); + #else + vtkCellLinks *Links = static_cast(grid->GetCellLinks()); +@@ -382,7 +383,7 @@ void SMDS_MeshNode::ClearInverseElements() + + bool SMDS_MeshNode::emptyInverseElements() + { +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks())->GetLink(myVtkID); + #else + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetCellLinks())->GetLink(myVtkID); +@@ -398,7 +399,7 @@ bool SMDS_MeshNode::emptyInverseElements() + + int SMDS_MeshNode::NbInverseElements(SMDSAbs_ElementType type) const + { +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetLinks())->GetLink(myVtkID); + #else + vtkCellLinks::Link l = static_cast(SMDS_Mesh::_meshList[myMeshId]->getGrid()->GetCellLinks())->GetLink(myVtkID); +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +index bedf100002dc..24b4ce856bac 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +@@ -1006,7 +1006,7 @@ void SMDS_UnstructuredGrid::BuildLinks() + this->Links = SMDS_CellLinks::New(); + GetLinks()->Allocate(this->GetNumberOfPoints()); + GetLinks()->Register(this); +-#if VTK_VERSION_NUMBER < VTK_VERSION_CHECK(9,3,0) ++#if VTK_VERSION_NUMBER < VTK_VERSION_CHECK(9, 2, 20221112) + GetLinks()->BuildLinks(this); + #else + GetLinks()->SetDataSet(this); +diff --git a/src/3rdParty/salomesmesh/src/SMESH/SMESH_MeshEditor.cpp b/src/3rdParty/salomesmesh/src/SMESH/SMESH_MeshEditor.cpp +index 49b5f99cd6a2..990e310d3dda 100644 +--- a/src/3rdParty/salomesmesh/src/SMESH/SMESH_MeshEditor.cpp ++++ b/src/3rdParty/salomesmesh/src/SMESH/SMESH_MeshEditor.cpp +@@ -57,6 +57,7 @@ + #include "utilities.h" + #include "chrono.hxx" + ++#include + #include + #include + #include +@@ -11348,7 +11349,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vector= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks::Link l = static_cast(grid->GetLinks())->GetLink(oldId); + #else + vtkCellLinks::Link l = static_cast(grid->GetCellLinks())->GetLink(oldId); +@@ -11712,7 +11713,7 @@ bool SMESH_MeshEditor::DoubleNodesOnGroupBoundaries( const std::vectorfirst; + //MESSAGE(" node " << oldId); +-#if VTK_VERSION_NUMBER_QUICK >= 90300000000 ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 2, 20221112) + vtkCellLinks::Link l = static_cast(grid->GetLinks())->GetLink(oldId); + #else + vtkCellLinks::Link l = static_cast(grid->GetCellLinks())->GetLink(oldId); +-- +2.53.0 + + +From 6d4ce9e9b84963688e283adaf775ed40d5d775a1 Mon Sep 17 00:00:00 2001 +From: Louis Gombert +Date: Thu, 27 Nov 2025 21:17:44 +0100 +Subject: [PATCH 3/6] Remove usages of non thread-safe + vtkUnstructuredGrid::GetFaceStream + +This overload was deprecated in VTK 9.4 and removed in VTK 9.6. Replace with with the thread-safe version, that was already present in VTK 9.1 +--- + .../src/SMDS/SMDS_VtkCellIterator.cpp | 7 ++- + .../salomesmesh/src/SMDS/SMDS_VtkVolume.cpp | 56 +++++++++++-------- + 2 files changed, 36 insertions(+), 27 deletions(-) + +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkCellIterator.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkCellIterator.cpp +index 63b6eabb7041..acbb8f57c317 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkCellIterator.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkCellIterator.cpp +@@ -182,9 +182,10 @@ SMDS_VtkCellIteratorPolyH::SMDS_VtkCellIteratorPolyH(SMDS_Mesh* mesh, int vtkCel + case SMDSEntity_Polyhedra: + { + //MESSAGE("SMDS_VtkCellIterator Polyhedra"); +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(_cellId, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( vtkCellId, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + int id = 0; + _nbNodesInFaces = 0; + for (int i = 0; i < nFaces; i++) +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp +index ffc2aa5d2553..7c1c0936de06 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_VtkVolume.cpp +@@ -205,9 +205,10 @@ int SMDS_VtkVolume::NbFaces() const + break; + case VTK_POLYHEDRON: + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + nbFaces = nFaces; + break; + } +@@ -234,9 +235,10 @@ int SMDS_VtkVolume::NbNodes() const + } + else + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + int id = 0; + for (int i = 0; i < nFaces; i++) + { +@@ -274,9 +276,10 @@ int SMDS_VtkVolume::NbEdges() const + break; + case VTK_POLYHEDRON: + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + nbEdges = 0; + int id = 0; + for (int i = 0; i < nFaces; i++) +@@ -310,9 +313,10 @@ int SMDS_VtkVolume::NbFaceNodes(const int face_ind) const + int nbNodes = 0; + if (aVtkType == VTK_POLYHEDRON) + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + int id = 0; + for (int i = 0; i < nFaces; i++) + { +@@ -340,9 +344,10 @@ const SMDS_MeshNode* SMDS_VtkVolume::GetFaceNode(const int face_ind, const int n + const SMDS_MeshNode* node = 0; + if (aVtkType == VTK_POLYHEDRON) + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + int id = 0; + for (int i = 0; i < nFaces; i++) + { +@@ -370,9 +375,10 @@ std::vector SMDS_VtkVolume::GetQuantities() const + vtkIdType aVtkType = grid->GetCellType(this->myVtkID); + if (aVtkType == VTK_POLYHEDRON) + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + int id = 0; + for (int i = 0; i < nFaces; i++) + { +@@ -428,9 +434,10 @@ const SMDS_MeshNode* SMDS_VtkVolume::GetNode(const int ind) const + vtkIdType aVtkType = grid->GetCellType(this->myVtkID); + if ( aVtkType == VTK_POLYHEDRON) + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + int id = 0, nbPoints = 0; + for (int i = 0; i < nFaces; i++) + { +@@ -459,9 +466,10 @@ int SMDS_VtkVolume::GetNodeIndex( const SMDS_MeshNode* node ) const + const vtkIdType aVtkType = grid->GetCellType(this->myVtkID); + if ( aVtkType == VTK_POLYHEDRON) + { +- vtkIdType nFaces = 0; +- vtkIdTypePtr ptIds = 0; +- grid->GetFaceStream(this->myVtkID, nFaces, ptIds); ++ vtkNew faceStream; ++ grid->GetFaceStream( this->myVtkID, faceStream); ++ vtkIdType nFaces = faceStream->GetId(0); ++ vtkIdType *ptIds = faceStream->GetPointer(1); + int id = 0; + for (int iF = 0; iF < nFaces; iF++) + { +-- +2.53.0 + + +From ff3e419d2ea4603ed8a28d3777f0d75b2a2af194 Mon Sep 17 00:00:00 2001 +From: Louis Gombert +Date: Thu, 27 Nov 2025 23:10:21 +0100 +Subject: [PATCH 4/6] smesh: update for VTK 9.4 polyhedron rework + +Implement new compactGrid method based on the upstream smesh version. The compatibility layer was removed for VTK 9.6. +--- + .../src/SMDS/SMDS_UnstructuredGrid.cpp | 66 +++++++++++++++++++ + 1 file changed, 66 insertions(+) + +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +index 24b4ce856bac..d2e90d7e5847 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +@@ -250,6 +250,71 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n + } + } + ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 3, 20240112) ++ if ( this->FaceLocations ) ++ { ++ vtkIdTypeArray *iniFaceLocO = (vtkIdTypeArray *)this->FaceLocations->GetOffsetsArray(); ++ vtkIdTypeArray *iniFaceLocC = (vtkIdTypeArray *)this->FaceLocations->GetConnectivityArray(); ++ vtkIdTypeArray *iniFaceO = (vtkIdTypeArray *)this->Faces->GetOffsetsArray(); ++ vtkIdTypeArray *iniFaceC = (vtkIdTypeArray *)this->Faces->GetConnectivityArray(); ++ // ++ vtkNew facesLoc_o; facesLoc_o->Initialize(); facesLoc_o->InsertNextValue(0); ++ vtkNew facesLoc_c; facesLoc_c->Initialize(); ++ vtkNew faces_o; faces_o->Initialize(); faces_o->InsertNextValue(0); ++ vtkNew faces_c; faces_c->Initialize(); ++ int newFaceId( 0 ); ++ vtkIdType facesLoc_o_cur(0),faces_o_cur(0); ++ // for ( vtkIdType newCellID = 0; newCellID < newCellSize; newCellID++ ) ++ for (int oldCellId = 0; oldCellId < oldCellSize; oldCellId++) ++ { ++ int newCellId = idCellsOldToNew[oldCellId]; ++ if ( this->Types->GetValue(newCellId) == VTK_POLYHEDRON ) ++ { ++ vtkIdType oldStartFaceLocOff = iniFaceLocO->GetValue( oldCellId ); ++ vtkIdType nCellFaces = iniFaceLocO->GetValue( oldCellId + 1 ) - oldStartFaceLocOff; ++ facesLoc_o_cur += nCellFaces; ++ facesLoc_o->InsertNextValue( facesLoc_o_cur ); ++ for ( int n = 0; n < nCellFaces; n++ ) ++ { ++ facesLoc_c->InsertNextValue( newFaceId++ ); ++ int curFaceId = iniFaceLocC->GetValue( oldStartFaceLocOff + n ); ++ int oldStartPtOfFaceOff = iniFaceO->GetValue( curFaceId ); ++ int nbOfPts = iniFaceO->GetValue( curFaceId + 1 ) - oldStartPtOfFaceOff; ++ faces_o_cur += nbOfPts; ++ faces_o->InsertNextValue( faces_o_cur ); ++ for( int m = 0 ; m < nbOfPts ; m++ ) ++ { ++ vtkIdType oldpt = iniFaceC->GetValue( oldStartPtOfFaceOff + m ); ++ int curPt = idNodesOldToNew[ oldpt ]; ++ faces_c->InsertNextValue( curPt ); ++ } ++ } ++ } ++ else ++ { ++ facesLoc_o->InsertNextValue(facesLoc_o_cur); ++ } ++ } ++ { ++ faces_o->Squeeze(); faces_c->Squeeze(); ++ facesLoc_o->Squeeze(); facesLoc_c->Squeeze(); ++ // ++ vtkNew outFaces; ++ outFaces->SetData( faces_o, faces_c ); ++ vtkNew outFaceLocations; ++ outFaceLocations->SetData( facesLoc_o, facesLoc_c ); ++ // ++ this->SetPolyhedralCells(newTypes, newConnectivity, outFaceLocations, outFaces); ++ } ++ } ++ else ++ { ++ { ++ this->SetCells(newTypes,newConnectivity); ++ } ++ //this->CellLocations = newLocations; ++ } ++#else + vtkIdTypeArray* thisFaceLocations = GetFaceLocations(); + vtkIdTypeArray* thisFaces = GetFaces(); + if (thisFaceLocations) +@@ -297,6 +362,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n + { + this->SetCells(newTypes, newLocations, newConnectivity, thisFaceLocations, thisFaces); + } ++#endif + + newPoints->Delete(); + newTypes->Delete(); +-- +2.53.0 + + +From 3a68d91ae306d88703d203d2ac8d41b2e5ce12dd Mon Sep 17 00:00:00 2001 +From: Louis Gombert +Date: Thu, 27 Nov 2025 23:22:36 +0100 +Subject: [PATCH 5/6] smesh: update for VTK 9.6 Types array + +UG::Types is now a vtkDataArray, that should be accessed through GetCellType +--- + .../salomesmesh/src/SMDS/SMDS_Mesh.cpp | 108 ++++++++++++++++++ + .../src/SMDS/SMDS_UnstructuredGrid.cpp | 15 +-- + 2 files changed, 116 insertions(+), 7 deletions(-) + +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp +index c9a8c4a90cbc..a076d2fb6f91 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_Mesh.cpp +@@ -284,7 +284,11 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diame + ball->init(n->getVtkId(), diameter, this); + if (!this->registerElement(ID,ball)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(ball->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(ball->getVtkId(), VTK_EMPTY_CELL); ++#endif + myBallPool->destroy(ball); + return 0; + } +@@ -344,7 +348,11 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, + edgevtk->init(nodeIds, this); + if (!this->registerElement(ID,edgevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(edgevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myEdgePool->destroy(edgevtk); + return 0; + } +@@ -628,7 +636,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -735,7 +747,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -848,7 +864,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -983,7 +1003,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -1105,7 +1129,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -1308,7 +1336,11 @@ SMDS_Mesh::AddPolygonalFaceWithID (const vector & nodes, + facevtk->initPoly(myNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -1373,7 +1405,11 @@ SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector & node + facevtk->initQuadPoly(myNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -1453,7 +1489,11 @@ SMDS_Mesh::AddPolyhedralVolumeWithID (const vector& nodes, + volvtk->initPoly(myNodeIds, quantities, this); + if (!this->registerElement(ID, volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -1509,7 +1549,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeFromVtkIdsWithID(const std::vectorinit(vtkNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -1568,7 +1612,11 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector& + facevtk->init(vtkNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -1716,7 +1764,11 @@ SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1, + facevtk->init(myNodeIds, this); // put in vtkUnstructuredGrid + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -1770,7 +1822,11 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1, + facevtk->init(myNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -2101,7 +2157,11 @@ SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1, + edgevtk->init(myNodeIds, this); + if (!this->registerElement(ID,edgevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(edgevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myEdgePool->destroy(edgevtk); + return 0; + } +@@ -3312,7 +3372,11 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement * elem, + if (vtkid >= 0) + { + //MESSAGE("VTK_EMPTY_CELL in " << vtkid); ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(vtkid, VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL); ++#endif + } + it++; + } +@@ -3417,7 +3481,11 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem) + } + myElementIDFactory->ReleaseID(elemId, vtkId); + ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(vtkId, VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(vtkId, VTK_EMPTY_CELL); ++#endif + // --- to do: keep vtkid in a list of reusable cells + } + } +@@ -3599,7 +3667,11 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1, + edgevtk->init(myNodeIds, this); + if (!this->registerElement(ID,edgevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(edgevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myEdgePool->destroy(edgevtk); + return 0; + } +@@ -3682,7 +3754,11 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, + facevtk->init(myNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -3769,7 +3845,11 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, + facevtk->init(myNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -3860,7 +3940,11 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, + facevtk->init(myNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -3954,7 +4038,11 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1, + facevtk->init(myNodeIds, this); + if (!this->registerElement(ID,facevtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myFacePool->destroy(facevtk); + return 0; + } +@@ -4057,7 +4145,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -4172,7 +4264,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -4299,7 +4395,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -4446,7 +4546,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +@@ -4626,7 +4730,11 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1, + volvtk->init(myNodeIds, this); + if (!this->registerElement(ID,volvtk)) + { ++#if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 5, 20251004) ++ this->myGrid->GetCellTypes()->SetTuple1(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#else + this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL); ++#endif + myVolumePool->destroy(volvtk); + return 0; + } +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +index d2e90d7e5847..ce9b01a4d2c4 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +@@ -214,11 +214,11 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n + while ( i < oldCellSize ) + { + // skip a hole if any +- while ( i < oldCellSize && this->Types->GetValue(i) == VTK_EMPTY_CELL ) ++ while ( i < oldCellSize && this->GetCellType(i) == VTK_EMPTY_CELL ) + ++i; + int startBloc = i; + // look for a block end +- while ( i < oldCellSize && this->Types->GetValue(i) != VTK_EMPTY_CELL ) ++ while ( i < oldCellSize && this->GetCellType(i) != VTK_EMPTY_CELL ) + ++i; + int endBloc = i; + if ( endBloc > startBloc ) +@@ -242,7 +242,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n + { + for (int oldCellID = 0; oldCellID < oldCellSize; oldCellID++) + { +- if (this->Types->GetValue(oldCellID) == VTK_EMPTY_CELL) ++ if (this->GetCellType(oldCellID) == VTK_EMPTY_CELL) + continue; + int newCellId = idCellsOldToNew[ oldCellID ]; + if (newTypes->GetValue(newCellId) == VTK_POLY_VERTEX) +@@ -268,7 +268,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n + for (int oldCellId = 0; oldCellId < oldCellSize; oldCellId++) + { + int newCellId = idCellsOldToNew[oldCellId]; +- if ( this->Types->GetValue(newCellId) == VTK_POLYHEDRON ) ++ if ( this->GetCellType(newCellId) == VTK_POLYHEDRON ) + { + vtkIdType oldStartFaceLocOff = iniFaceLocO->GetValue( oldCellId ); + vtkIdType nCellFaces = iniFaceLocO->GetValue( oldCellId + 1 ) - oldStartFaceLocOff; +@@ -327,7 +327,7 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n + newFaces->Allocate(thisFaces->GetSize()); + for (int i = 0; i < oldCellSize; i++) + { +- if (this->Types->GetValue(i) == VTK_EMPTY_CELL) ++ if (this->GetCellType(i) == VTK_EMPTY_CELL) + continue; + int newCellId = idCellsOldToNew[i]; + if (newTypes->GetValue(newCellId) == VTK_POLYHEDRON) +@@ -399,7 +399,7 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes, + //MESSAGE("copyBloc " << alreadyCopied << " " << start << " " << end << " size: " << end - start << " total: " << alreadyCopied + end - start); + for (int j = start; j < end; j++) + { +- newTypes->SetValue(alreadyCopied, this->Types->GetValue(j)); ++ newTypes->SetValue(alreadyCopied, this->GetCellType(j)); + idCellsOldToNew[j] = alreadyCopied; // old vtkId --> new vtkId + // The difference is mainly the internal representation of vtkCellArray between vtk 7.x and vtk 9.x + // In the old version a single array of the form (n1,id1,id2,...,idn1, n2,id1,id2,...,idn2, ...) is used +@@ -412,7 +412,7 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes, + vtkIdTypePtr oldPtsCell = 0; + this->Connectivity->GetCell(oldLoc, nbpts, oldPtsCell); + assert(nbpts < NBMAXNODESINCELL); +- //MESSAGE(j << " " << alreadyCopied << " " << (int)this->Types->GetValue(j) << " " << oldLoc << " " << nbpts ); ++ //MESSAGE(j << " " << alreadyCopied << " " << (int)this->GetCellType(j) << " " << oldLoc << " " << nbpts ); + for (int l = 0; l < nbpts; l++) + { + int oldval = oldPtsCell[l]; +@@ -1076,6 +1076,7 @@ void SMDS_UnstructuredGrid::BuildLinks() + GetLinks()->BuildLinks(this); + #else + GetLinks()->SetDataSet(this); ++ std::cout << this->GetNumberOfPoints() << std::endl; + GetLinks()->BuildLinks(); + #endif + GetLinks()->Delete(); +-- +2.53.0 + + +From 261ca3905b47b251b0751fd7af45ad5c3fd129e4 Mon Sep 17 00:00:00 2001 +From: Louis Gombert +Date: Sun, 30 Nov 2025 18:36:20 +0100 +Subject: [PATCH 6/6] Smesh: patch other VTK UG deprecations + +--- + .../salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp | 7 ++++--- + 1 file changed, 4 insertions(+), 3 deletions(-) + +diff --git a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +index ce9b01a4d2c4..f5b91ff80097 100644 +--- a/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp ++++ b/src/3rdParty/salomesmesh/src/SMDS/SMDS_UnstructuredGrid.cpp +@@ -193,8 +193,8 @@ void SMDS_UnstructuredGrid::compactGrid(std::vector& idNodesOldToNew, int n + + vtkCellArray *newConnectivity = vtkCellArray::New(); + newConnectivity->Initialize(); +- int oldCellDataSize = this->Connectivity->GetData()->GetSize(); +- newConnectivity->Allocate(oldCellDataSize); ++ int oldCellDataSize = this->GetCells()->GetConnectivityArray()->GetSize(); ++ newConnectivity->AllocateExact(oldCellDataSize, oldCellDataSize); + MESSAGE("oldCellSize="<< oldCellSize << " oldCellDataSize=" << oldCellDataSize); + + vtkUnsignedCharArray *newTypes = vtkUnsignedCharArray::New(); +@@ -420,7 +420,8 @@ void SMDS_UnstructuredGrid::copyBloc(vtkUnsignedCharArray *newTypes, + //MESSAGE(" " << oldval << " " << pointsCell[l]); + } + /*int newcnt = */newConnectivity->InsertNextCell(nbpts, pointsCell); +- int newLoc = newConnectivity->GetInsertLocation(nbpts); ++ int newLoc = this->GetCells()->GetOffsetsArray()->GetNumberOfValues() - 1 ++ + this->GetCells()->GetConnectivityArray()->GetNumberOfValues() - nbpts - 1; + //MESSAGE(newcnt << " " << newLoc); + newLocations->SetValue(alreadyCopied, newLoc); + alreadyCopied++; +-- +2.53.0 + +diff --git a/src/Mod/Fem/App/PropertyPostDataObject.cpp b/src/Mod/Fem/App/PropertyPostDataObject.cpp +index f416dd7aa20d..28908608d008 100644 +--- a/src/Mod/Fem/App/PropertyPostDataObject.cpp ++++ b/src/Mod/Fem/App/PropertyPostDataObject.cpp +@@ -322,14 +322,12 @@ void PropertyPostDataObject::SaveDocFile(Base::Writer& writer) const + xmlWriter->SetFileName(fi.filePath().c_str()); + xmlWriter->SetDataModeToBinary(); + +-#ifdef VTK_CELL_ARRAY_V2 + // Looks like an invalid data object that causes a crash with vtk9 + vtkUnstructuredGrid* dataGrid = vtkUnstructuredGrid::SafeDownCast(m_dataObject); + if (dataGrid && (dataGrid->GetPiece() < 0 || dataGrid->GetNumberOfPoints() <= 0)) { + std::cerr << "PropertyPostDataObject::SaveDocFile: ignore empty vtkUnstructuredGrid\n"; + return; + } +-#endif + + if (xmlWriter->Write() != 1) { + // Note: Do NOT throw an exception here because if the tmp. file could diff --git a/0006-do-not-include-execinfo.patch b/0006-do-not-include-execinfo.patch new file mode 100644 index 00000000..fc1c8381 --- /dev/null +++ b/0006-do-not-include-execinfo.patch @@ -0,0 +1,46 @@ +diff --git a/src/3rdParty/salomesmesh/src/DriverSTL/Basics_Utils.cpp b/src/3rdParty/salomesmesh/src/DriverSTL/Basics_Utils.cpp +index 23c5083fdf25..7a166b89df31 100644 +--- a/src/3rdParty/salomesmesh/src/DriverSTL/Basics_Utils.cpp ++++ b/src/3rdParty/salomesmesh/src/DriverSTL/Basics_Utils.cpp +@@ -29,7 +29,6 @@ + #ifndef WIN32 + #include + #include +-#include + #endif + + +@@ -109,20 +108,7 @@ namespace Kernel_Utils + #ifndef WIN32 + void print_traceback() + { +- void *array[50]; +- size_t size; +- char **strings; +- size_t i; +- +- size = backtrace (array, 40); +- strings = backtrace_symbols (array, size); +- +- for (i = 0; i < size; i++) +- { +- std::cerr << strings[i] << std::endl; +- } +- +- free (strings); ++ std::cerr << "TODO: implement backtrace for musl!" << std::endl; + } + #else + #if (_MSC_VER >= 1400) // Visual Studio 2005 +diff --git a/src/App/Application.cpp b/src/App/Application.cpp +index 0d89d9ec0e81..a37db3014d0b 100644 +--- a/src/App/Application.cpp ++++ b/src/App/Application.cpp +@@ -1810,7 +1810,6 @@ static void freecadNewHandler () + #endif + + #if defined(FC_OS_LINUX) +-#include + #include + #include + diff --git a/0007-Mod-Part-Do-not-use-ARB-API.patch b/0007-Mod-Part-Do-not-use-ARB-API.patch new file mode 100644 index 00000000..6fa18550 --- /dev/null +++ b/0007-Mod-Part-Do-not-use-ARB-API.patch @@ -0,0 +1,76 @@ +diff --git a/src/Mod/Part/Gui/SoBrepFaceSet.cpp b/src/Mod/Part/Gui/SoBrepFaceSet.cpp +index 7610c2d16bcd..3bb2a80fe53c 100644 +--- a/src/Mod/Part/Gui/SoBrepFaceSet.cpp ++++ b/src/Mod/Part/Gui/SoBrepFaceSet.cpp +@@ -141,7 +141,7 @@ public: + PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)cc_glglue_getprocaddress(glue, "glDeleteBuffersARB"); + #endif + auto &buffer = it->second; +- glDeleteBuffersARB(2, buffer.myvbo); ++ glDeleteBuffers(2, buffer.myvbo); + self->vbomap.erase(it); + } + } +@@ -1412,7 +1412,7 @@ void SoBrepFaceSet::VBO::render(SoGLRenderAction * action, + const cc_glglue * glue = cc_glglue_instance(action->getCacheContext()); + PFNGLGENBUFFERSPROC glGenBuffersARB = (PFNGLGENBUFFERSPROC)cc_glglue_getprocaddress(glue, "glGenBuffersARB"); + #endif +- glGenBuffersARB(2, buf.myvbo); ++ glGenBuffers(2, buf.myvbo); + buf.vertex_array_size = 0; + buf.index_array_size = 0; + buf.vboLoaded = false; +@@ -1442,8 +1442,8 @@ void SoBrepFaceSet::VBO::render(SoGLRenderAction * action, + #endif + // We must manage buffer size increase let's clear everything and re-init to test the + // clearing process +- glDeleteBuffersARB(2, buf.myvbo); +- glGenBuffersARB(2, buf.myvbo); ++ glDeleteBuffers(2, buf.myvbo); ++ glGenBuffers(2, buf.myvbo); + vertex_array = ( float * ) malloc ( sizeof(float) * num_indices * 10 ); + index_array = ( GLuint *) malloc ( sizeof(GLuint) * num_indices ); + buf.vertex_array_size = sizeof(float) * num_indices * 10; +@@ -1641,14 +1641,14 @@ void SoBrepFaceSet::VBO::render(SoGLRenderAction * action, + } + } + +- glBindBufferARB(GL_ARRAY_BUFFER_ARB, buf.myvbo[0]); +- glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float) * indice , vertex_array, GL_DYNAMIC_DRAW_ARB); ++ glBindBuffer(GL_ARRAY_BUFFER, buf.myvbo[0]); ++ glBufferData(GL_ARRAY_BUFFER, sizeof(float) * indice , vertex_array, GL_DYNAMIC_DRAW); + +- glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buf.myvbo[1]); +- glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, sizeof(GLuint) * this->indice_array , &index_array[0], GL_DYNAMIC_DRAW_ARB); ++ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf.myvbo[1]); ++ glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * this->indice_array , &index_array[0], GL_DYNAMIC_DRAW); + +- glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); +- glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); ++ glBindBuffer(GL_ARRAY_BUFFER, 0); ++ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + + buf.vboLoaded = true; + buf.updateVbo = false; +@@ -1663,8 +1663,8 @@ void SoBrepFaceSet::VBO::render(SoGLRenderAction * action, + #endif + + if (!buf.updateVbo) { +- glBindBufferARB(GL_ARRAY_BUFFER_ARB, buf.myvbo[0]); +- glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, buf.myvbo[1]); ++ glBindBuffer(GL_ARRAY_BUFFER, buf.myvbo[0]); ++ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buf.myvbo[1]); + } + + glEnableClientState(GL_VERTEX_ARRAY); +@@ -1680,8 +1680,8 @@ void SoBrepFaceSet::VBO::render(SoGLRenderAction * action, + glDisableClientState(GL_COLOR_ARRAY); + glDisableClientState(GL_NORMAL_ARRAY); + glDisableClientState(GL_VERTEX_ARRAY); +- glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); +- glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); ++ glBindBuffer(GL_ARRAY_BUFFER, 0); ++ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); + buf.updateVbo = false; + // The data is within the VBO we can clear it at application level + } diff --git a/0008-CMake-Fix-Eigen3-version-search.patch b/0008-CMake-Fix-Eigen3-version-search.patch new file mode 100644 index 00000000..10b1a57f --- /dev/null +++ b/0008-CMake-Fix-Eigen3-version-search.patch @@ -0,0 +1,53 @@ +From 8547e798fb3b0f51953b18a2cb98f60aec0a7e33 Mon Sep 17 00:00:00 2001 +From: marioalexis +Date: Sat, 20 Sep 2025 19:42:37 -0300 +Subject: [PATCH] CMake: Fix Eigen3 version search + +--- + cMake/FindEigen3.cmake | 29 ++++++++++++++++++++--------- + 1 file changed, 20 insertions(+), 9 deletions(-) + +diff --git a/cMake/FindEigen3.cmake b/cMake/FindEigen3.cmake +index 57ee44be2a0f..ebddf5b6a159 100644 +--- a/cMake/FindEigen3.cmake ++++ b/cMake/FindEigen3.cmake +@@ -23,16 +23,27 @@ if(NOT Eigen3_FIND_VERSION) + endif(NOT Eigen3_FIND_VERSION) + + macro(_eigen3_check_version) +- file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header) ++ # file Version exists from Eigen3 5.0.0 ++ if (EXISTS "${EIGEN3_INCLUDE_DIR}/Eigen/Version") ++ file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/Version" _eigen3_version_header) ++ string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}") ++ set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}") ++ string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}") ++ set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}") ++ string(REGEX MATCH "define[ \t]+EIGEN_PATCH_VERSION[ \t]+([0-9]+)" _eigen3_patch_version_match "${_eigen3_version_header}") ++ set(EIGEN3_PATCH_VERSION "${CMAKE_MATCH_1}") ++ set(EIGEN3_VERSION ${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION}.${EIGEN3_PATCH_VERSION}) ++ else() ++ file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header) ++ string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}") ++ set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}") ++ string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}") ++ set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}") ++ string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}") ++ set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}") ++ set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION}) ++ endif() + +- string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}") +- set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}") +- string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}") +- set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}") +- string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}") +- set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}") +- +- set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION}) + if(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION}) + set(EIGEN3_VERSION_OK FALSE) + message(STATUS "Eigen3 version ${EIGEN3_VERSION} found in ${EIGEN3_INCLUDE_DIR}, " +-- +2.53.0 + diff --git a/0009-Gui-Application-QuarterWidget-request-OpenGL-compati.patch b/0009-Gui-Application-QuarterWidget-request-OpenGL-compati.patch new file mode 100644 index 00000000..a786e66f --- /dev/null +++ b/0009-Gui-Application-QuarterWidget-request-OpenGL-compati.patch @@ -0,0 +1,74 @@ +From b3e8ed7814ac54598474a2f20ea56ea5420c44ea Mon Sep 17 00:00:00 2001 +From: Sami Liedes +Date: Tue, 30 Sep 2025 02:22:29 +0200 +Subject: [PATCH] Gui/Application, QuarterWidget: request OpenGL compatibility + profile (#23768) +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +On Wayland with Qt, the default OpenGL context often ends up being +OpenGL ES. ES is a stricter API based on the "core" profile and lacks +many legacy functions (e.g. glEnd). FreeCAD relies on some of these +functions, which work under Mesa’s permissive stack but fail outright +with NVIDIA’s proprietary drivers, resulting in a blank 3D view. + +Fix this by explicitly requesting a desktop OpenGL compatibility +profile both before QApplication creation and in QuarterWidget. This +ensures the presence of the legacy entry points required by Coin/SoQt. + +(NB: both requests appear to be necessary; a single change was not +sufficient in testing.) +--- + src/Gui/Application.cpp | 7 +++++++ + src/Gui/Quarter/QuarterWidget.cpp | 9 +++++++++ + 2 files changed, 16 insertions(+) + +diff --git a/src/Gui/Application.cpp b/src/Gui/Application.cpp +index 9166183fab0a..0ec6a3998027 100644 +--- a/src/Gui/Application.cpp ++++ b/src/Gui/Application.cpp +@@ -35,6 +35,7 @@ + #include + #include + #include ++#include + #include + #include + #include +@@ -2383,6 +2384,12 @@ void Application::runApplication() + { + StartupProcess::setupApplication(); + ++ QSurfaceFormat fmt; ++ fmt.setRenderableType(QSurfaceFormat::OpenGL); ++ fmt.setProfile(QSurfaceFormat::CompatibilityProfile); ++ fmt.setOption(QSurfaceFormat::DeprecatedFunctions, true); ++ QSurfaceFormat::setDefaultFormat(fmt); ++ + // A new QApplication + Base::Console().log("Init: Creating Gui::Application and QApplication\n"); + +diff --git a/src/Gui/Quarter/QuarterWidget.cpp b/src/Gui/Quarter/QuarterWidget.cpp +index b69b87ca5d8a..eb4867361890 100644 +--- a/src/Gui/Quarter/QuarterWidget.cpp ++++ b/src/Gui/Quarter/QuarterWidget.cpp +@@ -160,6 +160,15 @@ public: + //surfaceFormat.setMajorVersion(3); + //surfaceFormat.setMinorVersion(2); + //surfaceFormat.setProfile(QSurfaceFormat::CoreProfile); ++ ++ // On Wayland, we typically get a core profile unless we explicitly ++ // request a compatibility profile. On llvmpipe, this still seems to ++ // "just work" even if out of spec; on proprietary Nvidia drivers, it ++ // does not. ++ surfaceFormat.setRenderableType(QSurfaceFormat::OpenGL); ++ surfaceFormat.setProfile(QSurfaceFormat::CompatibilityProfile); ++ surfaceFormat.setOption(QSurfaceFormat::DeprecatedFunctions, true); ++ + #if defined (_DEBUG) && 0 + surfaceFormat.setOption(QSurfaceFormat::DebugContext); + #endif +-- +2.53.0 + diff --git a/PKGBUILD b/PKGBUILD new file mode 100644 index 00000000..f507df33 --- /dev/null +++ b/PKGBUILD @@ -0,0 +1,109 @@ +# Maintainer: Yao Zi + +pkgname=freecad +pkgver=1.0.2 +pkgrel=1 +pkgdesc='Free multiplatform 3D parametric modeler' +url='https://www.freecad.org' +arch=(x86_64 aarch64 riscv64 loongarch64) +license=(LGPL-2.0-or-later) +depends=(musl yaml-cpp libspnav vtk zlib-ng xerces-c llvm-libs onetbb python + libspnav med openmp freetype2 fmt boost-libs qt6-base qt6-tools qt6-svg + libglvnd glu coin pyside6 python-pivy) +makedepends=(cmake doxygen boost shiboken6) +# Too many ODR violations to enable LTO :( +# https://github.com/FreeCAD/FreeCAD/issues/13173 +options=(!lto) +# 0001: Downstream, don't look for Boost::system which is dropped by 1.89. +# Upstream commit 0f6d00d2a547 ("fix issue #23829 build with boost v1.89 and greater") +# resolved the issue, but couldn't be backporte to 1.0.x. +# 0003: Backport 39ca75bac294 ("Py3.13: Update PyCXX to version 7.1.11") +# to fix PyCXX compatibility with libc++ 20, which deprecated +# instantiation of std::basic_string<> against non-character types since +# it's considered UB by LWG 2994. +# 0004: Backport 692d40916a61 ("Py3.13: Disable Py_UNICODE support in PyCXX"), +# Py_UNICODE has been deprecated in Python since 3.13 +# Reference: https://github.com/python/cpython/issues/105156 +# Note 0003 and 0004 are manually patched with s%3rdParty/PyCXX/%%g, as PyCXX +# source is moved from src to src/3rdParty/PyCXX. +# 0005: Backports, fix compatibility issues with VTK 9.6, consists multiple +# upstream commits, +# +# 3d2b7dc9c7ac Use vtkUnstructuredGrid::GetLinks instead of vtkUnstructuredGrid::GetCellLinks for VTK >= 9.3 +# 261ca3905b47 Smesh: patch other VTK UG deprecations +# 3a68d91ae306 smesh: update for VTK 9.6 Types array +# ff3e419d2ea4 smesh: update for VTK 9.4 polyhedron rework +# 6d4ce9e9b849 Remove usages of non thread-safe vtkUnstructuredGrid::GetFaceStream +# c9acda2a659f Standardize VTK version check pre-processing directives +# bd90728f886b Smesh: Remove the VTK_CELL_ARRAY_V2 compatibility define +# +# mostly generated by +# +# (git format-patch --stdout -1 3d2b7dc9c7ac898b30fe469b7cbd424ed1bca0a2; +# git format-patch --stdout 261ca3905b47b251b0751fd7af45ad5c3fd129e4 -6) +# +# Manually edited parts are annoted in the patch. +# 0006: Should be upstreamed, avoid including execinfo.h which is glibc-specific +# 0007: Should be upstreamed, dropping usage of *ARB API for vertex_array_object, +# which has been standard profile since OpenGL 1.5 +# 0008: Backport 8547e798fb3b ("CMake: Fix Eigen3 version search") +# Fix detection logic compatibility with Eigen 5.x +# 0009: Backport b3e8ed7814ac ("Gui/Application, QuarterWidget: request OpenGL compatibility profile (#23768)") +# Fix 3D view rendering under Wayland. Qt by default requests a context +# with OpenGL ES API, while FreeCAD requires OpenGL and compatibility +# profile, causing API errors in glMatrixMode() etc. +source=("https://github.com/FreeCAD/FreeCAD/releases/download/$pkgver/freecad_source.tar.gz" + 0001-Drop-Boost-system.patch + 0002-Link-libOpenGL-instead-of-libGL.patch + 0003-Py3.13-Update-PyCXX-to-version-7.1.11.patch + 0004-Py3.13-Disable-Py_UNICODE-support-in-PyCXX.patch + 0005-VTK-9.6-compatiblity-fixes.patch + 0006-do-not-include-execinfo.patch + 0007-Mod-Part-Do-not-use-ARB-API.patch + 0008-CMake-Fix-Eigen3-version-search.patch + 0009-Gui-Application-QuarterWidget-request-OpenGL-compati.patch) +sha256sums=('c9b8e19dbf20cea387c432890ea059059ff6b57ec4cd77820cd1202d1247bbde' + '8adaeb92a094ac9aa067799f55476bae3c32e6b662f1a7d152ec3e9a9337c0c9' + 'e95d21b28a4cface0365d14636a1f3d6e9f3c4933dc1c0879795903efcbe87bf' + 'ad078224681c671055ba64ad7698e93836ca80ba64aedd245033ea38de3aaa5d' + '145b118b2ccd5e726a5987d83378f84ab11e82eff53b9c411ff7306911e4b112' + '2794ab584c1af1d7cb3e2d6f9609664328bebc4daf5e7c51460734d2ee79c913' + '0df1d4f0108cf5ec2db2ca8ed4fcf07049f56d92b5fbbeb48f419748004340e9' + '755f16e0356913b972ba6cc7c66d0f4fc11c023db1ca0838db31923607a5ba0d' + 'c67c75a00f879330830b064d7fb20993f35460e2ff9149d2a29ce3d7d2e0a71d' + '84bec627f1910149e11168921c598943fb7d60735fb3e4db9f6f4cbf9118e4c8') + +prepare() { + _patch_ . +} + +build() { + # BUILD_VR: missing Rift + # CMAKE_INSTALL_* is to work around the weird installation paths. + cmake -S . -B pkgbuild -Wno-dev \ + -DCMAKE_BUILD_TYPE=RelWithDebInfo \ + -DCMAKE_INSTALL_BINDIR=/usr/lib/freecad/bin \ + -DCMAKE_INSTALL_DATADIR=/usr/share/freecad \ + -DCMAKE_INSTALL_DATAROOTDIR=/usr/share \ + -DCMAKE_INSTALL_DOCDIR=/usr/share/doc \ + -DCMAKE_INSTALL_LIBDIR=/usr/lib/freecad/lib \ + -DCMAKE_INSTALL_PREFIX=/usr/lib/freecad \ + -DINSTALL_TO_SITEPACKAGES=ON \ + -DOPENGL_GL_PREFERENCE=GLVND \ + -DOPENGL_USE_GLES2=ON \ + -DOPENGL_USE_OPENGL=ON \ + -DOPENGL_USE_GLX=OFF \ + -DOPENGL_USE_EGL=ON \ + -DBUILD_GUI=ON \ + -DBUILD_VR=OFF \ + -DENABLE_DEVELOPER_TESTS=OFF + + cmake --build pkgbuild +} + +package() { + DESTDIR="$pkgdir" cmake --install pkgbuild + + install -dm755 "$pkgdir"/usr/bin + ln -s ../lib/freecad/bin/FreeCAD "$pkgdir"/usr/bin/FreeCAD +}