[Config] Fix QGLViewer find module on windows

CMakeLists.txt

@@ -6,7 +6,7 @@ include(CMakeDependentOption)
 # Manually define VERSION
 set(Sofa_VERSION_MAJOR 23)
 set(Sofa_VERSION_MINOR 12)
-set(Sofa_VERSION_PATCH 99)
+set(Sofa_VERSION_PATCH 00)
 set(Sofa_VERSION ${Sofa_VERSION_MAJOR}.${Sofa_VERSION_MINOR}.${Sofa_VERSION_PATCH})
 
 set(SOFA_VERSION_STR "\"${Sofa_VERSION}\"")
@@ -37,7 +37,7 @@ option(SOFA_BUILD_RELEASE_PACKAGE "Run package specific configure" OFF)
 # Option to allow some dependencies such as cxxopts to be fetched by cmake if
 # the package is not found
 option(SOFA_ALLOW_FETCH_DEPENDENCIES "Allow compatible dependencies to be fetched if the package is not found by cmake.
-  List of dependencies that can be fetched: cxxopts" ON)
+  List of dependencies that can be fetched: cxxopts, gtest, metis, CImg" ON)
 
 # Option to accelerate the compilation
 # see https://cmake.org/cmake/help/v3.16/command/target_precompile_headers.html
@@ -91,6 +91,7 @@ install(FILES
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/FindEigen3.cmake"
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/macdeployqt.cmake"
     "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/windeployqt.cmake"
+    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/FindTinyXML2.cmake"
     DESTINATION lib/cmake/Modules
     COMPONENT headers
     )

Sofa/Component/Constraint/Projective/tests/FixedPlaneConstraint_test.cpp

@@ -67,7 +67,7 @@ struct FixedPlaneConstraint_test : public BaseSimulationTest
 
         /// Scene initialization
         sofa::simulation::Simulation* simulation;
-        sofa::simulation::setSimulation(simulation = new sofa::simulation::graph::DAGSimulation());
+        simulation = sofa::simulation::getSimulation();
         simulation::Node::SPtr root = simulation->createNewGraph("root");
         root->setGravity( type::Vec3(0,0,0) );
 

Sofa/Component/IO/Mesh/CMakeLists.txt

@@ -52,13 +52,13 @@ set(SOURCE_FILES
     ${SOFACOMPONENTIOMESH_SOURCE_DIR}/STLExporter.cpp
 )
 
-sofa_find_package(TinyXML REQUIRED) # BaseVTKReader
+sofa_find_package(TinyXML2 REQUIRED) # BaseVTKReader
 sofa_find_package(ZLIB REQUIRED) # BlenderExporter
 sofa_find_package(Sofa.Simulation.Core REQUIRED)
 
 add_library(${PROJECT_NAME} SHARED ${HEADER_FILES} ${SOURCE_FILES} ${WRAPPER_FILES})
 target_link_libraries(${PROJECT_NAME} PUBLIC Sofa.Simulation.Core)
-target_link_libraries(${PROJECT_NAME} PRIVATE tinyxml)
+target_link_libraries(${PROJECT_NAME} PRIVATE tinyxml2::tinyxml2)
 target_link_libraries(${PROJECT_NAME} PUBLIC ZLIB::ZLIB)
 if(CMAKE_SYSTEM_NAME STREQUAL Windows)
     sofa_install_libraries(TARGETS ZLIB::ZLIB)

Sofa/Component/IO/Mesh/src/sofa/component/io/mesh/MeshVTKLoader.cpp

@@ -34,12 +34,13 @@ using sofa::component::io::mesh::BaseVTKReader ;
 /// This is needed for template specialization.
 #include <sofa/component/io/mesh/BaseVTKReader.inl>
 
-#include <tinyxml.h>
+#include <tinyxml2.h>
 
 //XML VTK Loader
 #define checkError(A) if (!A) { return false; }
 #define checkErrorPtr(A) if (!A) { return nullptr; }
 #define checkErrorMsg(A, B) if (!A) { msg_error() << B << "\n" ; return false; }
+#define checkErrorMsgAuto(A) if(A != tinyxml2::XML_SUCCESS) { msg_error() << "TinyXML error message : " << tinyxml2::XMLDocument::ErrorIDToName(A) << "\n" ; return false; }
 
 namespace sofa::component::io::mesh
 {
@@ -69,15 +70,15 @@ class XMLVTKReader : public BaseVTKReader
 public:
     bool readFile(const char* filename) override;
 protected:
-    bool loadUnstructuredGrid(TiXmlHandle datasetFormatHandle);
-    bool loadPolydata(TiXmlHandle datasetFormatHandle);
-    bool loadRectilinearGrid(TiXmlHandle datasetFormatHandle);
-    bool loadStructuredGrid(TiXmlHandle datasetFormatHandle);
-    bool loadStructuredPoints(TiXmlHandle datasetFormatHandle);
-    bool loadImageData(TiXmlHandle datasetFormatHandle);
-    BaseVTKDataIO* loadDataArray(TiXmlElement* dataArrayElement, int size, string type);
-    BaseVTKDataIO* loadDataArray(TiXmlElement* dataArrayElement, int size);
-    BaseVTKDataIO* loadDataArray(TiXmlElement* dataArrayElement);
+    bool loadUnstructuredGrid(tinyxml2::XMLHandle datasetFormatHandle);
+    bool loadPolydata(tinyxml2::XMLHandle datasetFormatHandle);
+    bool loadRectilinearGrid(tinyxml2::XMLHandle datasetFormatHandle);
+    bool loadStructuredGrid(tinyxml2::XMLHandle datasetFormatHandle);
+    bool loadStructuredPoints(tinyxml2::XMLHandle datasetFormatHandle);
+    bool loadImageData(tinyxml2::XMLHandle datasetFormatHandle);
+    BaseVTKDataIO* loadDataArray(tinyxml2::XMLElement* dataArrayElement, int size, string type);
+    BaseVTKDataIO* loadDataArray(tinyxml2::XMLElement* dataArrayElement, int size);
+    BaseVTKDataIO* loadDataArray(tinyxml2::XMLElement* dataArrayElement);
 };
 
 ////////////////////////////////////////////////////////////////////////////////////////////
@@ -950,19 +951,19 @@ bool LegacyVTKReader::readFile(const char* filename)
 
 bool XMLVTKReader::readFile(const char* filename)
 {
-    TiXmlDocument vtkDoc(filename);
+    tinyxml2::XMLDocument vtkDoc(true,tinyxml2::COLLAPSE_WHITESPACE);
     //quick check
-    checkErrorMsg(vtkDoc.LoadFile(), "Unknown error while loading VTK Xml doc");
+    checkErrorMsgAuto(vtkDoc.LoadFile(filename))
 
-    const TiXmlHandle hVTKDoc(&vtkDoc);
-    TiXmlElement* pElem;
-    TiXmlHandle hVTKDocRoot(nullptr);
+    tinyxml2::XMLHandle hVTKDoc(&vtkDoc);
+    tinyxml2::XMLElement* pElem;
+    tinyxml2::XMLHandle hVTKDocRoot(nullptr);
 
     //block VTKFile
     pElem = hVTKDoc.FirstChildElement().ToElement();
     checkErrorMsg(pElem, "VTKFile Node not found");
 
-    hVTKDocRoot = TiXmlHandle(pElem);
+    hVTKDocRoot = tinyxml2::XMLHandle(pElem);
 
     //Endianness
     const char* endiannessStrTemp = pElem->Attribute("byte_order");
@@ -1003,7 +1004,7 @@ bool XMLVTKReader::readFile(const char* filename)
         checkErrorMsg(false, "Dataset format " << datasetFormatStr << " not recognized");
     }
 
-    const TiXmlHandle datasetFormatHandle = TiXmlHandle(hVTKDocRoot.FirstChild( datasetFormatStr.c_str() ).ToElement());
+    const tinyxml2::XMLHandle datasetFormatHandle = tinyxml2::XMLHandle(hVTKDocRoot.FirstChildElement( datasetFormatStr.c_str() ));
 
     bool stateLoading = false;
     switch (datasetFormat)
@@ -1035,17 +1036,17 @@ bool XMLVTKReader::readFile(const char* filename)
     return true;
 }
 
-BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(TiXmlElement* dataArrayElement)
+BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(tinyxml2::XMLElement* dataArrayElement)
 {
     return loadDataArray(dataArrayElement, 0);
 }
 
-BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(TiXmlElement* dataArrayElement, int size)
+BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(tinyxml2::XMLElement* dataArrayElement, int size)
 {
     return loadDataArray(dataArrayElement, size, "");
 }
 
-BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(TiXmlElement* dataArrayElement, int size, string type)
+BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(tinyxml2::XMLElement* dataArrayElement, int size, string type)
 {
     //Type
     const char* typeStrTemp;
@@ -1085,7 +1086,7 @@ BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(TiXmlElement* dataArra
 
     //NumberOfComponents
     int numberOfComponents;
-    if (dataArrayElement->QueryIntAttribute("NumberOfComponents", &numberOfComponents) != TIXML_SUCCESS)
+    if (dataArrayElement->QueryIntAttribute("NumberOfComponents", &numberOfComponents) != tinyxml2::XML_SUCCESS)
     {
         numberOfComponents = 1;
     }
@@ -1124,19 +1125,19 @@ BaseVTKReader::BaseVTKDataIO* XMLVTKReader::loadDataArray(TiXmlElement* dataArra
     return d;
 }
 
-bool XMLVTKReader::loadUnstructuredGrid(TiXmlHandle datasetFormatHandle)
+bool XMLVTKReader::loadUnstructuredGrid(tinyxml2::XMLHandle datasetFormatHandle)
 {
-    TiXmlElement* pieceElem = datasetFormatHandle.FirstChild( "Piece" ).ToElement();
+    tinyxml2::XMLElement* pieceElem = datasetFormatHandle.FirstChildElement( "Piece" ).ToElement();
 
     checkError(pieceElem);
     for( ; pieceElem; pieceElem = pieceElem->NextSiblingElement())
     {
         pieceElem->QueryIntAttribute("NumberOfPoints", &numberOfPoints);
         pieceElem->QueryIntAttribute("NumberOfCells", &numberOfCells);
 
-        TiXmlNode* dataArrayNode;
-        TiXmlElement* dataArrayElement;
-        TiXmlNode* node = pieceElem->FirstChild();
+        tinyxml2::XMLNode* dataArrayNode;
+        tinyxml2::XMLElement* dataArrayElement;
+        tinyxml2::XMLNode* node = pieceElem->FirstChild();
 
         for ( ; node ; node = node->NextSibling())
         {
@@ -1145,7 +1146,7 @@ bool XMLVTKReader::loadUnstructuredGrid(TiXmlHandle datasetFormatHandle)
             if (currentNodeName.compare("Points") == 0)
             {
                 /* Points */
-                dataArrayNode = node->FirstChild("DataArray");
+                dataArrayNode = node->FirstChildElement("DataArray");
                 checkError(dataArrayNode);
                 dataArrayElement = dataArrayNode->ToElement();
                 checkError(dataArrayElement);
@@ -1157,8 +1158,8 @@ bool XMLVTKReader::loadUnstructuredGrid(TiXmlHandle datasetFormatHandle)
             if (currentNodeName.compare("Cells") == 0)
             {
                 /* Cells */
-                dataArrayNode = node->FirstChild("DataArray");
-                for ( ; dataArrayNode; dataArrayNode = dataArrayNode->NextSibling( "DataArray"))
+                dataArrayNode = node->FirstChildElement("DataArray");
+                for ( ; dataArrayNode; dataArrayNode = dataArrayNode->NextSiblingElement( "DataArray"))
                 {
                     dataArrayElement = dataArrayNode->ToElement();
                     checkError(dataArrayElement);
@@ -1187,8 +1188,8 @@ bool XMLVTKReader::loadUnstructuredGrid(TiXmlHandle datasetFormatHandle)
 
             if (currentNodeName.compare("PointData") == 0)
             {
-                dataArrayNode = node->FirstChild("DataArray");
-                for ( ; dataArrayNode; dataArrayNode = dataArrayNode->NextSibling( "DataArray"))
+                dataArrayNode = node->FirstChildElement("DataArray");
+                for ( ; dataArrayNode; dataArrayNode = dataArrayNode->NextSiblingElement( "DataArray"))
                 {
                     dataArrayElement = dataArrayNode->ToElement();
                     checkError(dataArrayElement);
@@ -1203,8 +1204,8 @@ bool XMLVTKReader::loadUnstructuredGrid(TiXmlHandle datasetFormatHandle)
             }
             if (currentNodeName.compare("CellData") == 0)
             {
-                dataArrayNode = node->FirstChild("DataArray");
-                for ( ; dataArrayNode; dataArrayNode = dataArrayNode->NextSibling( "DataArray"))
+                dataArrayNode = node->FirstChildElement("DataArray");
+                for ( ; dataArrayNode; dataArrayNode = dataArrayNode->NextSiblingElement( "DataArray"))
                 {
                     dataArrayElement = dataArrayNode->ToElement();
                     checkError(dataArrayElement);
@@ -1221,35 +1222,35 @@ bool XMLVTKReader::loadUnstructuredGrid(TiXmlHandle datasetFormatHandle)
     return true;
 }
 
-bool XMLVTKReader::loadPolydata(TiXmlHandle datasetFormatHandle)
+bool XMLVTKReader::loadPolydata(tinyxml2::XMLHandle datasetFormatHandle)
 {
     SOFA_UNUSED(datasetFormatHandle);
     msg_error() << "Polydata dataset not implemented yet" ;
     return false;
 }
 
-bool XMLVTKReader::loadRectilinearGrid(TiXmlHandle datasetFormatHandle)
+bool XMLVTKReader::loadRectilinearGrid(tinyxml2::XMLHandle datasetFormatHandle)
 {
     SOFA_UNUSED(datasetFormatHandle);
     msg_error() << "RectilinearGrid dataset not implemented yet" ;
     return false;
 }
 
-bool XMLVTKReader::loadStructuredGrid(TiXmlHandle datasetFormatHandle)
+bool XMLVTKReader::loadStructuredGrid(tinyxml2::XMLHandle datasetFormatHandle)
 {
     SOFA_UNUSED(datasetFormatHandle);
     msg_error() << "StructuredGrid dataset not implemented yet" ;
     return false;
 }
 
-bool XMLVTKReader::loadStructuredPoints(TiXmlHandle datasetFormatHandle)
+bool XMLVTKReader::loadStructuredPoints(tinyxml2::XMLHandle datasetFormatHandle)
 {
     SOFA_UNUSED(datasetFormatHandle);
     msg_error() << "StructuredPoints dataset not implemented yet" ;
     return false;
 }
 
-bool XMLVTKReader::loadImageData(TiXmlHandle datasetFormatHandle)
+bool XMLVTKReader::loadImageData(tinyxml2::XMLHandle datasetFormatHandle)
 {
     SOFA_UNUSED(datasetFormatHandle);
     msg_error() << "ImageData dataset not implemented yet" ;

Sofa/Component/LinearSolver/Direct/CMakeLists.txt

@@ -55,12 +55,19 @@ set(SOURCE_FILES
     ${SOFACOMPONENTLINEARSOLVERDIRECT_SOURCE_DIR}/TypedMatrixLinearSystem[BTDMatrix].cpp
 )
 
-sofa_find_package(metis QUIET) # Unix users can have an installed version of metis
-if(NOT metis_FOUND)
-    message(STATUS "${PROJECT_NAME}: using built-in metis library")
-    option(METIS-GKLIB_GKRAND "enable GKRAND support" ON) #GKRAND support allows the portability of random number generation across different architectures
-    add_subdirectory(extlibs/metis-5.1.0)
+find_package(metis 5.1.0 EXACT QUIET)
+if(NOT metis_FOUND AND SOFA_ALLOW_FETCH_DEPENDENCIES)
+    message("Sofa.Component.LinearSolver.Direct: DEPENDENCY metis NOT FOUND. SOFA_ALLOW_FETCH_DEPENDENCIES is ON, fetching metis...")
+    include(FetchContent)
+    FetchContent_Declare(metis
+            GIT_REPOSITORY https://github.com/sofa-framework/METIS
+            GIT_TAG v5.1.0-ModernInstall
+    )
+    FetchContent_MakeAvailable(metis)
+elseif (NOT metis_FOUND)
+    message(FATAL_ERROR "Sofa.Component.LinearSolver.Direct: DEPENDENCY metis NOT FOUND. SOFA_ALLOW_FETCH_DEPENDENCIES is OFF and thus cannot be fetched. Install metis (version=5.1.0), or enable SOFA_ALLOW_FETCH_DEPENDENCIES to fix this issue.")
 endif()
+
 sofa_set_01(SOFA_COMPONENT_LINEARSOLVER_DIRECT_HAVE_METIS VALUE TRUE)
 
 # make sure you have threads for AsyncSparseLDLSolver
@@ -70,8 +77,9 @@ sofa_find_package(Sofa.Simulation.Core REQUIRED)
 sofa_find_package(Sofa.Component.LinearSolver.Iterative REQUIRED) # Only for MatrixLinearSolver which will move to core
 
 add_library(${PROJECT_NAME} SHARED ${HEADER_FILES} ${SOURCE_FILES} ${WRAPPER_FILES})
+
 target_link_libraries(${PROJECT_NAME} PUBLIC Sofa.Simulation.Core Sofa.Component.LinearSolver.Iterative)
-target_link_libraries(${PROJECT_NAME} PUBLIC metis)
+target_link_libraries(${PROJECT_NAME} PRIVATE metis)
 target_link_libraries(${PROJECT_NAME} PUBLIC Threads::Threads)
 
 sofa_create_package_with_targets(

Sofa/Component/LinearSolver/Direct/Sofa.Component.LinearSolver.DirectConfig.cmake.in

@@ -9,10 +9,6 @@ find_package(Threads QUIET REQUIRED)
 
 set(SOFA_COMPONENT_LINEARSOLVER_DIRECT_HAVE_METIS @SOFA_COMPONENT_LINEARSOLVER_DIRECT_HAVE_METIS@)
 
-if(SOFA_COMPONENT_LINEARSOLVER_DIRECT_HAVE_METIS)
-    find_package(Metis QUIET REQUIRED HINTS "${CMAKE_CURRENT_LIST_DIR}/..")
-endif()
-
 if(NOT TARGET @PROJECT_NAME@)
     include("${CMAKE_CURRENT_LIST_DIR}/@[email protected]")
 endif()