Le lundi 26 mars 2012 à 18:11 +0200, PINO Daniel a écrit : > Hello all, > > I'm just starting to use gmsh and its API. I'm currently trying to > compile one of the examples available in utils/api_demos/ but I'm > getting some troubles... > > > I've already compiled Gmsh without any problem. > > I think the problem comes from the mekafile, I don't know how to compile > those files. > > How should I use cmake to create the corresponding makefile for this > code? > > Does anybody already have the Makefiles to compile those files > (utils/api_demos)? > > Thank you very much for your help.
Here is a quick and dirty hack of CMakeLists.txt in utils/api_demos to make allmost all demos compile except the one for leveset because of a missing header... Hope it helps > > Best, > > Daniel > > > _______________________________________________ > gmsh mailing list > [email protected] > http://www.geuz.org/mailman/listinfo/gmsh
cmake_minimum_required(VERSION 2.6 FATAL_ERROR)
# if CMAKE_BUILD_TYPE is specified use it; otherwise set the default
# build type to "RelWithDebInfo" ("-O2 -g" with gcc) prior to calling
# project()
if(DEFINED CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE ${CMAKE_BUILD_TYPE} CACHE STRING "Choose build type")
else(DEFINED CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "Choose build type")
endif(DEFINED CMAKE_BUILD_TYPE)
project(api_demos CXX C)
# this variable controls the default value of the "ENABLE_XXX" options which are
# normally set to ON (useful if you want to configure a minimal version of Gmsh:
# e.g. "cmake -DDEFAULT=0 -DENABLE_POST=1 -DENABLE_PARSER=1")
set(DEFAULT ON CACHE INTERNAL "Default value for options")
option(ENABLE_GMSH "Enable Gmsh" ${DEFAULT})
option(ENABLE_ANN "Enable ANN to compute Approximate Nearest Neighbors" ${DEFAULT})
option(ENABLE_KBIPACK "Enable Kbipack for homology solver" ${DEFAULT})
option(ENABLE_MATHEX "Enable MathEx expression parser" ${DEFAULT})
option(ENABLE_OCC "Enable Open CASCADE geometrical models" ${DEFAULT})
option(ENABLE_PETSC "Enable PETSc linear algebra solvers" ${DEFAULT})
option(ENABLE_SLEPC "Enable SLEPc eigensolvers" ${DEFAULT})
option(ENABLE_FLTK "Build FLTK GUI" ${DEFAULT})
option(ENABLE_FL_TREE "Enable FLTK tree browser widget" ${DEFAULT})
option(ENABLE_MED "Enable MED mesh and post-processing file formats" ${DEFAULT})
option(ENABLE_MMG3D "Enable 3D Mobile Mesh Generation" ${DEFAULT})
option(ENABLE_TETGEN "Enable Tetgen mesh generator" ${DEFAULT})
option(ENABLE_TETGEN_NEW "Enable experimental version of Tetgen" OFF)
option(ENABLE_GRAPHICS "Compile-in OpenGL graphics even if there is no GUI" OFF)
option(ENABLE_MESH "Build the mesh module" ${DEFAULT})
option(ENABLE_POST "Build the post-processing module" ${DEFAULT})
option(ENABLE_PLUGINS "Build the post-processing plugins" ${DEFAULT})
option(ENABLE_DINTEGRATION "Enable discrete integration and levelsets" ${DEFAULT})
option(ENABLE_BLAS_LAPACK "Use BLAS and Lapack for linear algebra" ON)
include(CheckTypeSize)
include(CheckFunctionExists)
include(CheckIncludeFile)
macro(find_all_libraries VARNAME LISTNAME PATH SUFFIX)
set(${VARNAME})
list(LENGTH ${LISTNAME} NUM_LIST)
foreach(LIB ${${LISTNAME}})
find_library(FOUND_LIB ${LIB} PATHS ${PATH} PATH_SUFFIXES ${SUFFIX})
if(FOUND_LIB)
list(APPEND ${VARNAME} ${FOUND_LIB})
endif(FOUND_LIB)
set(FOUND_LIB FOUND_LIB-NOTFOUND CACHE INTERNAL "")
# unset(FOUND_LIB CACHE) # cleaner, but only available in cmake >= 2.6.4
endforeach(LIB)
list(LENGTH ${VARNAME} NUM_FOUND_LIBRARIES)
if(NUM_FOUND_LIBRARIES LESS NUM_LIST)
set(${VARNAME})
endif(NUM_FOUND_LIBRARIES LESS NUM_LIST)
endmacro(find_all_libraries)
macro(set_config_option VARNAME STRING)
set(${VARNAME} TRUE)
list(APPEND CONFIG_OPTIONS ${STRING})
message(STATUS "Found " ${STRING})
endmacro(set_config_option)
# check if the machine is 64 bits (this is more reliable than using
# CMAKE_SIZEOF_VOID_P, which does not seem to work e.g. on some Suse
# machines)
check_type_size("void*" SIZEOF_VOID_P)
if(SIZEOF_VOID_P EQUAL 8)
set_config_option(HAVE_64BIT_SIZE_T "Have64BitSizeT")
endif(SIZEOF_VOID_P EQUAL 8)
if(ENABLE_BLAS_LAPACK)
if(MSVC)
# on Windows with Visual C++ try really hard to find blas/lapack
# *without* requiring a Fortran compiler: 1) try to find the Intel
# MKL libs using the standard search path; if not found 2) try to
# get the reference blas/lapack libs (useful for users with no
# Fortran compiler and no MKL license, who can just download our
# precompiled "gmsh-dep" package)
if(HAVE_64BIT_SIZE_T)
set(MKL_PATH em64t/lib)
else(HAVE_64BIT_SIZE_T)
set(MKL_PATH ia32/lib)
endif(HAVE_64BIT_SIZE_T)
set(MKL_LIBS_REQUIRED libguide40 mkl_intel_c mkl_intel_thread mkl_core)
find_all_libraries(LAPACK_LIBRARIES MKL_LIBS_REQUIRED "" ${MKL_PATH})
if(LAPACK_LIBRARIES)
set_config_option(HAVE_BLAS "Blas(IntelMKL)")
set_config_option(HAVE_LAPACK "Lapack(IntelMKL)")
else(LAPACK_LIBRARIES)
set(REFLAPACK_LIBS_REQUIRED lapack blas g2c gcc)
find_all_libraries(LAPACK_LIBRARIES REFLAPACK_LIBS_REQUIRED "" "")
if(LAPACK_LIBRARIES)
set_config_option(HAVE_BLAS "Blas(Ref)")
set_config_option(HAVE_LAPACK "Lapack(Ref)")
endif(LAPACK_LIBRARIES)
endif(LAPACK_LIBRARIES)
elseif(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
# on Linux try to find the Intel MKL without a Fortran compiler
if(HAVE_64BIT_SIZE_T)
set(MKL_PATH lib/em64t)
else(HAVE_64BIT_SIZE_T)
set(MKL_PATH lib/32)
endif(HAVE_64BIT_SIZE_T)
set(MKL_LIBS_REQUIRED mkl_gf_lp64 iomp5 mkl_gnu_thread mkl_core guide pthread)
find_all_libraries(LAPACK_LIBRARIES MKL_LIBS_REQUIRED "" ${MKL_PATH})
if(NOT LAPACK_LIBRARIES)
#match lapack 9.0 on 64bit
set(MKL_LIBS_REQUIRED mkl_lapack mkl_em64t guide)
find_all_libraries(LAPACK_LIBRARIES MKL_LIBS_REQUIRED "" ${MKL_PATH})
endif(NOT LAPACK_LIBRARIES)
if(LAPACK_LIBRARIES)
set_config_option(HAVE_BLAS "Blas(IntelMKL)")
set_config_option(HAVE_LAPACK "Lapack(IntelMKL)")
else(LAPACK_LIBRARIES)
# on Linux also try to find ATLAS without a Fortran compiler,
# because cmake ships with a buggy FindBLAS e.g. on Ubuntu Lucid
# Lynx
set(ATLAS_LIBS_REQUIRED lapack f77blas cblas atlas)
find_all_libraries(LAPACK_LIBRARIES ATLAS_LIBS_REQUIRED "" "")
if(LAPACK_LIBRARIES)
set_config_option(HAVE_BLAS "Blas(ATLAS)")
set_config_option(HAVE_LAPACK "Lapack(ATLAS)")
endif(LAPACK_LIBRARIES)
endif(LAPACK_LIBRARIES)
elseif(${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
# on SunOS we know blas and lapack are available in sunperf
set(LAPACK_FLAGS -library=sunperf)
set_config_option(HAVE_BLAS "Blas(SubPerf)")
set_config_option(HAVE_LAPACK "Lapack(SunPerf)")
elseif(APPLE)
# on Mac we also know that blas and lapack are available
set(LAPACK_LIBRARIES "-framework vecLib")
set_config_option(HAVE_BLAS "Blas(VecLib)")
set_config_option(HAVE_LAPACK "Lapack(VecLib)")
endif(MSVC)
if(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
# if we haven't found blas and lapack without using the standard
# cmake tests, do it (this requires a working Fortran compiler)
enable_language(Fortran)
find_package(BLAS)
if(BLAS_FOUND)
set_config_option(HAVE_BLAS "Blas")
find_package(LAPACK)
if(LAPACK_FOUND)
set_config_option(HAVE_LAPACK "Lapack")
else(LAPACK_FOUND)
set(LAPACK_LIBRARIES ${BLAS_LIBRARIES})
endif(LAPACK_FOUND)
if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
if(CMAKE_Fortran_COMPILER MATCHES "gfortran")
list(APPEND LAPACK_LIBRARIES gfortran)
elseif(CMAKE_Fortran_COMPILER MATCHES "f95")
list(APPEND LAPACK_LIBRARIES gfortran)
elseif(CMAKE_Fortran_COMPILER MATCHES "g77")
list(APPEND LAPACK_LIBRARIES g2c)
endif(CMAKE_Fortran_COMPILER MATCHES "gfortran")
endif(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
endif(BLAS_FOUND)
endif(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
if(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
message("WARNING: Could not find Blas or Lapack: most meshing algorithms "
"will not be functional")
endif(NOT HAVE_BLAS OR NOT HAVE_LAPACK)
endif(ENABLE_BLAS_LAPACK)
if(ENABLE_KBIPACK)
find_library(GMP_LIB gmp)
if(GMP_LIB)
find_path(GMP_INC "gmp.h" PATH_SUFFIXES src include)
if(GMP_INC)
set_config_option(HAVE_GMP "GMP")
list(APPEND EXTERNAL_LIBRARIES ${GMP_LIB})
list(APPEND EXTERNAL_INCLUDES ${GMP_INC})
include_directories(../../contrib/kbipack)
set_config_option(HAVE_KBIPACK "Kbipack")
endif(GMP_INC)
endif(GMP_LIB)
endif(ENABLE_KBIPACK)
if(ENABLE_MATHEX)
include_directories(../../contrib/MathEx)
set_config_option(HAVE_MATHEX "MathEx")
endif(ENABLE_MATHEX)
if(ENABLE_PETSC)
set(ENV_PETSC_DIR $ENV{PETSC_DIR})
set(ENV_PETSC_ARCH $ENV{PETSC_ARCH})
if(EXISTS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables)
# old-style PETSc installations (using PETSC_DIR and PETSC_ARCH)
set_config_option(HAVE_PETSC "PETSc")
file(STRINGS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables
PETSC_VARIABLES NEWLINE_CONSUME)
# find include directories
list(APPEND EXTERNAL_INCLUDES ${ENV_PETSC_DIR}/include)
list(APPEND EXTERNAL_INCLUDES ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/include)
string(REGEX MATCH "PACKAGES_INCLUDES = [^\n\r]*" PETSC_PACKAGES_INCLUDES
${PETSC_VARIABLES})
if(PETSC_PACKAGES_INCLUDES)
string(REPLACE "PACKAGES_INCLUDES = " "" PETSC_PACKAGES_INCLUDES
${PETSC_PACKAGES_INCLUDES})
if(PETSC_PACKAGES_INCLUDES)
string(REPLACE "-I" "" PETSC_PACKAGES_INCLUDES ${PETSC_PACKAGES_INCLUDES})
string(REPLACE " " ";" PETSC_PACKAGES_INCLUDES ${PETSC_PACKAGES_INCLUDES})
foreach(VAR ${PETSC_PACKAGES_INCLUDES})
list(APPEND EXTERNAL_INCLUDES ${VAR})
endforeach(VAR)
endif(PETSC_PACKAGES_INCLUDES)
endif(PETSC_PACKAGES_INCLUDES)
# find libraries (<= 3.0)
set(PETSC_LIBS_REQUIRED petscksp petscdm petscmat petscvec petsc)
find_all_libraries(PETSC_LIBS PETSC_LIBS_REQUIRED
${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/lib "")
# petsc 3.1 creates only one library (libpetsc)
if(NOT PETSC_LIBS)
find_library(PETSC_LIBS petsc PATHS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/lib)
endif(NOT PETSC_LIBS)
# find slepc (needs to be linked in before petsc)
if(ENABLE_SLEPC)
set(ENV_SLEPC_DIR $ENV{SLEPC_DIR})
find_library(SLEPC_LIB slepc PATHS ${ENV_SLEPC_DIR}/${ENV_PETSC_ARCH}/lib)
if(SLEPC_LIB)
find_path(SLEPC_INC "slepc.h" PATHS ${ENV_SLEPC_DIR} PATH_SUFFIXES include
${ENV_PETSC_ARCH}/include include/slepc)
if(SLEPC_INC)
set_config_option(HAVE_SLEPC "SLEPc")
list(APPEND EXTERNAL_LIBRARIES ${SLEPC_LIB})
list(APPEND EXTERNAL_INCLUDES ${SLEPC_INC})
find_path(SLEPC_INC2 "slepcconf.h" PATHS ${ENV_SLEPC_DIR}
PATH_SUFFIXES ${ENV_PETSC_ARCH}/include)
if(SLEPC_INC2)
list(APPEND EXTERNAL_INCLUDES ${SLEPC_INC2})
endif(SLEPC_INC2)
endif(SLEPC_INC)
endif(SLEPC_LIB)
if(NOT HAVE_SLEPC AND NOT ENV_SLEPC_DIR)
message("WARNING: Export SLEPC_DIR before calling cmake")
endif(NOT HAVE_SLEPC AND NOT ENV_SLEPC_DIR)
endif(ENABLE_SLEPC)
list(APPEND EXTERNAL_LIBRARIES ${PETSC_LIBS})
# find additional libraries to link with
string(REGEX MATCH "PACKAGES_LIBS = [^\n\r]*" PLIBS ${PETSC_VARIABLES})
if(PLIBS)
string(REPLACE "PACKAGES_LIBS = " "" PLIBS ${PLIBS})
string(STRIP ${PLIBS} PLIBS)
list(APPEND EXTERNAL_LIBRARIES "${PLIBS}")
endif(PLIBS)
string(REGEX MATCH "PETSC_EXTERNAL_LIB_BASIC = [^\n\r]*" PLIBS_BASIC ${PETSC_VARIABLES})
if(PLIBS_BASIC)
string(REPLACE "PETSC_EXTERNAL_LIB_BASIC = " "" PLIBS_BASIC ${PLIBS_BASIC})
string(STRIP ${PLIBS_BASIC} PLIBS_BASIC)
list(APPEND EXTERNAL_LIBRARIES "${PLIBS_BASIC}")
endif(PLIBS_BASIC)
string(REGEX MATCH "PCC_LINKER_LIBS = [^\n\r]*" LLIBS ${PETSC_VARIABLES})
if(LLIBS)
string(REPLACE "PCC_LINKER_LIBS = " "" LLIBS ${LLIBS})
string(STRIP ${LLIBS} LLIBS)
list(APPEND EXTERNAL_LIBRARIES "${LLIBS}")
endif(LLIBS)
else(EXISTS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables)
# new-style PETSc installations (in standard system directories)
find_library(PETSC_LIBS petsc)
find_path(PETSC_INC "petsc.h" PATH_SUFFIXES include/petsc)
if(PETSC_LIBS AND PETSC_INC)
set_config_option(HAVE_PETSC "PETSc")
if(ENABLE_SLEPC)
find_library(SLEPC_LIB slepc)
find_path(SLEPC_INC "slepc.h" PATH_SUFFIXES include/slepc)
if(SLEPC_LIB AND SLEPC_INC)
set_config_option(HAVE_SLEPC "SLEPc")
list(APPEND EXTERNAL_LIBRARIES ${SLEPC_LIB})
list(APPEND EXTERNAL_INCLUDES ${SLEPC_INC})
endif(SLEPC_LIB AND SLEPC_INC)
endif(ENABLE_SLEPC)
list(APPEND EXTERNAL_LIBRARIES ${PETSC_LIBS})
list(APPEND EXTERNAL_INCLUDES ${PETSC_INC})
endif(PETSC_LIBS AND PETSC_INC)
endif(EXISTS ${ENV_PETSC_DIR}/${ENV_PETSC_ARCH}/conf/petscvariables)
if(NOT HAVE_PETSC AND NOT ENV_PETSC_DIR)
message("WARNING: Export PETSC_DIR before calling cmake")
endif(NOT HAVE_PETSC AND NOT ENV_PETSC_DIR)
if(NOT HAVE_PETSC AND NOT ENV_PETSC_ARCH)
message("WARNING: Export PETSC_ARCH before calling cmake")
endif(NOT HAVE_PETSC AND NOT ENV_PETSC_ARCH)
endif(ENABLE_PETSC)
if(ENABLE_OCC)
if(WIN32 OR CYGWIN)
if(HAVE_64BIT_SIZE_T)
set(OCC_SYS_NAME win64)
else(HAVE_64BIT_SIZE_T)
set(OCC_SYS_NAME win32)
endif(HAVE_64BIT_SIZE_T)
else(WIN32 OR CYGWIN)
set(OCC_SYS_NAME ${CMAKE_SYSTEM_NAME})
endif(WIN32 OR CYGWIN)
set(OCC_LIBS_REQUIRED
# subset of DataExchange
TKSTEP TKSTEP209 TKSTEPAttr TKSTEPBase TKIGES TKXSBase
# ModelingAlgorithms
TKOffset TKFeat TKFillet TKBool TKShHealing TKMesh TKHLR TKBO TKPrim
TKTopAlgo TKGeomAlgo
# ModelingData
TKBRep TKGeomBase TKG3d TKG2d
# FoundationClasses
TKAdvTools TKMath TKernel)
list(LENGTH OCC_LIBS_REQUIRED NUM_OCC_LIBS_REQUIRED)
set(OCC_LIBS)
foreach(OCC ${OCC_LIBS_REQUIRED})
find_library(OCC_LIB ${OCC} HINTS ENV CASROOT PATH_SUFFIXES lib
${OCC_SYS_NAME}/lib ${OCC_SYS_NAME}/vc8/lib)
if(OCC_LIB)
list(APPEND OCC_LIBS ${OCC_LIB})
else(OCC_LIB)
message(STATUS "OCC lib " ${OCC} " not Found")
endif(OCC_LIB)
set(OCC_LIB OCC_LIB-NOTFOUND CACHE INTERNAL "")
# unset(OCC_LIB CACHE) # cleaner, but only available in cmake >= 2.6.4
endforeach(OCC)
list(LENGTH OCC_LIBS NUM_OCC_LIBS)
if(NUM_OCC_LIBS EQUAL NUM_OCC_LIBS_REQUIRED)
find_path(OCC_INC "BRep_Tool.hxx" PATHS ENV CASROOT PATH_SUFFIXES inc
include include/oce opencascade)
if(OCC_INC)
set_config_option(HAVE_OCC "OpenCascade")
list(APPEND EXTERNAL_LIBRARIES ${OCC_LIBS})
list(APPEND EXTERNAL_INCLUDES ${OCC_INC})
if(HAVE_64BIT_SIZE_T)
add_definitions(-D_OCC64)
endif(HAVE_64BIT_SIZE_T)
if(CYGWIN)
list(APPEND EXTERNAL_LIBRARIES "winspool")
elseif(MSVC)
add_definitions(-DWNT)
endif(CYGWIN)
find_path(OCC_CONFIG_H "config.h" PATHS ${OCC_INC} ${OCC_CONFIG_H_PATH}
NO_DEFAULT_PATH)
if(NOT OCC_CONFIG_H)
add_definitions(-DHAVE_NO_OCC_CONFIG_H)
endif(NOT OCC_CONFIG_H)
endif(OCC_INC)
endif(NUM_OCC_LIBS EQUAL NUM_OCC_LIBS_REQUIRED)
endif(ENABLE_OCC)
if(ENABLE_ANN)
find_library(ANN_LIB ann PATH_SUFFIXES lib)
find_path(ANN_INC "ANN.h" PATH_SUFFIXES src include ANN)
if(ANN_LIB AND ANN_INC)
list(APPEND EXTERNAL_LIBRARIES ${ANN_LIB})
list(APPEND EXTERNAL_INCLUDES ${ANN_INC})
set_config_option(HAVE_ANN "Ann")
else(ANN_LIB AND ANN_INC)
message(STATUS "System ANN not found - using contrib/ANN instead")
add_subdirectory(../contrib/ANN)
include_directories(../contrib/ANN/include)
endif(ANN_LIB AND ANN_INC)
endif(ENABLE_ANN)
find_library(GMSH_LIB gmsh PATH_SUFFIXES lib)
find_path(GMSH_INC "Gmsh.h" PATH_SUFFIXES src include gmsh)
if(GMSH_LIB AND GMSH_INC)
list(APPEND EXTERNAL_LIBRARIES ${GMSH_LIB})
list(APPEND EXTERNAL_INCLUDES ${GMSH_INC})
set_config_option(HAVE_GMSH "Gmsh")
else(GMSH_LIB AND GMSH_INC)
message(STATUS "Gmsh.h not found")
endif(GMSH_LIB AND GMSH_INC)
find_library(ANTTWEAKBAR_LIB AntTweakBar PATH_SUFFIXES lib)
find_path(ANTTWEAKBAR_INC "AntTweakBar.h" PATH_SUFFIXES src include AntTweakBar)
if(ANTTWEAKBAR_LIB AND ANTTWEAKBAR_INC)
list(APPEND EXTERNAL_LIBRARIES ${ANTTWEAKBAR_LIB})
list(APPEND EXTERNAL_INCLUDES ${ANTTWEAKBAR_INC})
set_config_option(HAVE_ANTTWEAKBAR "AntTweakBar")
else(ANTTWEAKBAR_LIB AND ANTTWEAKBAR_INC)
message(STATUS "ANTTWEAKBAR not found")
endif(ANTTWEAKBAR_LIB AND ANTTWEAKBAR_INC)
if(ENABLE_FLTK)
# first, try to use fltk-config for fltk >= 1.3 (FindFLTK is buggy
# on Unix, where e.g. xft and xinerama options are not dealt with)
find_program(FLTK_CONFIG_SCRIPT fltk-config)
if(FLTK_CONFIG_SCRIPT)
execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --api-version
OUTPUT_VARIABLE FLTK_VERSION)
string(STRIP ${FLTK_VERSION} FLTK_VERSION)
if(FLTK_VERSION GREATER 1.1)
set_config_option(HAVE_FLTK "Fltk")
message(STATUS "Using fltk-config script for Fltk " ${FLTK_VERSION})
execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --use-gl --use-images --includedir
OUTPUT_VARIABLE FLTK_INCLUDE_DIR)
string(STRIP ${FLTK_INCLUDE_DIR} FLTK_INCLUDE_DIR)
list(APPEND EXTERNAL_INCLUDES ${FLTK_INCLUDE_DIR} ${FLTK_INCLUDE_DIR}/FL/images
${FLTK_INCLUDE_DIR}/jpeg ${FLTK_INCLUDE_DIR}/zlib ${FLTK_INCLUDE_DIR}/png)
execute_process(COMMAND ${FLTK_CONFIG_SCRIPT} --use-gl --use-images --ldflags
OUTPUT_VARIABLE FLTK_LIBRARIES)
string(STRIP ${FLTK_LIBRARIES} FLTK_LIBRARIES)
string(REGEX MATCH "fltk[_ ]jpeg" FLTK_JPEG ${FLTK_LIBRARIES})
string(REGEX MATCH "fltk[_ ]z" FLTK_Z ${FLTK_LIBRARIES})
string(REGEX MATCH "fltk[_ ]png" FLTK_PNG ${FLTK_LIBRARIES})
endif(FLTK_VERSION GREATER 1.1)
endif(FLTK_CONFIG_SCRIPT)
# then try the built-in FindFLTK module
if(NOT HAVE_FLTK)
set(FLTK_SKIP_FORMS TRUE)
set(FLTK_SKIP_FLUID TRUE)
find_package(FLTK)
if(FLTK_FOUND)
add_subdirectory(Fltk)
set_config_option(HAVE_FLTK "Fltk")
list(APPEND EXTERNAL_INCLUDES ${FLTK_INCLUDE_DIR})
# find fltk jpeg
find_library(FLTK_JPEG NAMES fltk_jpeg fltkjpeg)
if(FLTK_JPEG)
list(APPEND EXTERNAL_LIBRARIES ${FLTK_JPEG})
foreach(DIR ${FLTK_INCLUDE_DIR})
list(APPEND EXTERNAL_INCLUDES ${DIR}/FL/images ${DIR}/jpeg)
endforeach(DIR)
endif(FLTK_JPEG)
# find fltk zlib
find_library(FLTK_Z NAMES fltk_z fltkz)
if(FLTK_Z)
list(APPEND EXTERNAL_LIBRARIES ${FLTK_Z})
foreach(DIR ${FLTK_INCLUDE_DIR})
list(APPEND EXTERNAL_INCLUDES ${DIR}/FL/images ${DIR}/zlib)
endforeach(DIR)
endif(FLTK_Z)
# find fltk png
find_library(FLTK_PNG NAMES fltk_png fltkpng)
if(FLTK_PNG)
list(APPEND EXTERNAL_LIBRARIES ${FLTK_PNG})
foreach(DIR ${FLTK_INCLUDE_DIR})
list(APPEND EXTERNAL_INCLUDES ${DIR}/FL/images ${DIR}/png)
endforeach(DIR)
endif(FLTK_PNG)
endif(FLTK_FOUND)
endif(NOT HAVE_FLTK)
if(HAVE_FLTK)
if(ENABLE_NATIVE_FILE_CHOOSER)
if(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
add_subdirectory(contrib/NativeFileChooser)
include_directories(contrib/NativeFileChooser)
add_definitions(-DFLTK1)
endif(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
set_config_option(HAVE_NATIVE_FILE_CHOOSER "NativeFileChooser")
endif(ENABLE_NATIVE_FILE_CHOOSER)
if(ENABLE_FL_TREE)
if(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
add_subdirectory(contrib/Fl_Tree)
include_directories(contrib/Fl_Tree)
endif(NOT FLTK_VERSION OR FLTK_VERSION EQUAL 1.1)
set_config_option(HAVE_FL_TREE "FlTree")
endif(ENABLE_FL_TREE)
endif(HAVE_FLTK)
elseif(ENABLE_QT)
find_package(Qt4)
set(QT_USE_QTOPENGL TRUE)
include(${QT_USE_FILE})
if(QT_FOUND)
add_subdirectory(Qt)
set_config_option(HAVE_QT "Qt")
list(APPEND EXTERNAL_INCLUDES ${QT_INCLUDE_DIR})
endif(QT_FOUND)
endif(ENABLE_FLTK)
if(APPLE)
set(glut "-framework GLUT")
else(APPLE)
list(APPEND EXTERNAL_LIBRARIES "glut")
endif(APPLE)
if(ENABLE_MMG3D)
find_library(MMG3D_LIB mmg3dlib4.0 PATH_SUFFIXES lib)
find_path(MMG3D_INC "libmmg3d.h" PATH_SUFFIXES src include)
if(MMG3D_LIB AND MMG3D_INC)
list(APPEND EXTERNAL_LIBRARIES ${MMG3D_LIB})
list(APPEND EXTERNAL_INCLUDES ${MMG3D_INC})
else(MMG3D_LIB AND MMG3D_INC)
message(STATUS "System MMG3D not found - using contrib/mmg3d instead")
add_subdirectory(contrib/mmg3d)
include_directories(contrib/mmg3d/build/sources)
endif(MMG3D_LIB AND MMG3D_INC)
set_config_option(HAVE_MMG3D "Mmg3d")
endif(ENABLE_MMG3D)
if(ENABLE_TETGEN_NEW AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/contrib/TetgenNew/tetgen.h)
add_subdirectory(contrib/TetgenNew)
include_directories(contrib/TetgenNew)
set_config_option(HAVE_TETGEN "Tetgen(New)")
add_definitions(-DTETLIBRARY)
message("WARNING: You are including an experimental version of Tetgen "
"that is KNOWN TO BE BUGGY on 64 bits archs and on WIN32/MSVC.")
elseif(ENABLE_TETGEN AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/contrib/Tetgen/tetgen.h)
add_subdirectory(contrib/Tetgen)
include_directories(contrib/Tetgen)
set_config_option(HAVE_TETGEN "Tetgen")
add_definitions(-DTETLIBRARY)
elseif(ENABLE_TETGEN)
find_library(TETGEN_LIB tet PATH_SUFFIXES lib)
find_path(TETGEN_INC "tetgen.h" PATH_SUFFIXES src include tetgen)
if(TETGEN_LIB AND TETGEN_INC)
list(APPEND EXTERNAL_LIBRARIES ${TETGEN_LIB})
list(APPEND EXTERNAL_INCLUDES ${TETGEN_INC})
set_config_option(HAVE_TETGEN "Tetgen")
endif(TETGEN_LIB AND TETGEN_INC)
endif(ENABLE_TETGEN_NEW AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/contrib/TetgenNew/tetgen.h)
if(HAVE_TETGEN)
message("WARNING: By including Tetgen you have to comply with Tetgen's "
"special licensing requirements stated in contrib/Tetgen/LICENSE.")
endif(HAVE_TETGEN)
if(ENABLE_MED OR ENABLE_CGNS)
find_library(HDF5_LIB hdf5)
if(HDF5_LIB)
if(ENABLE_MED)
find_library(MED_LIB med)
if(MED_LIB)
set_config_option(HAVE_MED "Med")
list(APPEND EXTERNAL_LIBRARIES ${MED_LIB})
endif(MED_LIB)
endif(ENABLE_MED)
if(ENABLE_CGNS)
find_library(CGNS_LIB cgns PATHS ENV CGNS_ROOT PATH_SUFFIXES lib)
find_path(CGNS_INC "cgnslib.h" PATHS ENV CGNS_ROOT PATH_SUFFIXES include)
if(CGNS_LIB)
set_config_option(HAVE_LIBCGNS "Cgns")
list(APPEND EXTERNAL_LIBRARIES ${CGNS_LIB})
list(APPEND EXTERNAL_INCLUDES ${CGNS_INC})
endif(CGNS_LIB)
endif(ENABLE_CGNS)
if(MED_LIB OR CGNS_LIB)
list(APPEND EXTERNAL_LIBRARIES ${HDF5_LIB})
find_library(SZ_LIB NAMES szlib sz)
if(SZ_LIB)
list(APPEND EXTERNAL_LIBRARIES ${SZ_LIB})
endif(SZ_LIB)
if(NOT HAVE_LIBZ) # necessary for non-GUI builds
find_package(ZLIB)
if(ZLIB_FOUND)
set_config_option(HAVE_LIBZ "Zlib")
list(APPEND EXTERNAL_LIBRARIES ${ZLIB_LIBRARIES})
endif(ZLIB_FOUND)
endif(NOT HAVE_LIBZ)
endif(MED_LIB OR CGNS_LIB)
endif(HDF5_LIB)
endif(ENABLE_MED OR ENABLE_CGNS)
if(ENABLE_MESH)
set_config_option(HAVE_MESH "Mesh")
endif(ENABLE_MESH)
if(ENABLE_POST)
set_config_option(HAVE_POST "Post")
if(ENABLE_PLUGINS)
set_config_option(HAVE_PLUGINS "Plugins")
endif(ENABLE_PLUGINS)
endif(ENABLE_POST)
if(HAVE_FLTK OR HAVE_QT OR ENABLE_GRAPHICS)
if(NOT HAVE_MESH OR NOT HAVE_POST OR NOT HAVE_PLUGINS)
message(SEND_ERROR "Cannot compile GUI without Mesh, Post or Plugin modules")
endif(NOT HAVE_MESH OR NOT HAVE_POST OR NOT HAVE_PLUGINS)
if(FLTK_JPEG)
set_config_option(HAVE_LIBJPEG "Jpeg(Fltk)")
else(FLTK_JPEG)
find_package(JPEG)
if(JPEG_FOUND)
set_config_option(HAVE_LIBJPEG "Jpeg")
list(APPEND EXTERNAL_LIBRARIES ${JPEG_LIBRARIES})
list(APPEND EXTERNAL_INCLUDES ${JPEG_INCLUDE_DIR})
endif(JPEG_FOUND)
endif(FLTK_JPEG)
if(FLTK_Z)
set_config_option(HAVE_LIBZ "Zlib(Fltk)")
else(FLTK_Z)
find_package(ZLIB)
if(ZLIB_FOUND)
set_config_option(HAVE_LIBZ "Zlib")
list(APPEND EXTERNAL_LIBRARIES ${ZLIB_LIBRARIES})
list(APPEND EXTERNAL_INCLUDES ${ZLIB_INCLUDE_DIR})
endif(ZLIB_FOUND)
endif(FLTK_Z)
if(HAVE_LIBZ)
if(FLTK_PNG)
set_config_option(HAVE_LIBPNG "Png(Fltk)")
else(FLTK_PNG)
find_package(PNG)
if(PNG_FOUND)
set_config_option(HAVE_LIBPNG "Png")
list(APPEND EXTERNAL_LIBRARIES ${PNG_LIBRARIES})
list(APPEND EXTERNAL_INCLUDES ${PNG_INCLUDE_DIR})
endif(PNG_FOUND)
endif(FLTK_PNG)
endif(HAVE_LIBZ)
if(ENABLE_MPEG_ENCODE)
add_subdirectory(contrib/mpeg_encode)
include_directories(contrib/mpeg_encode/headers)
set_config_option(HAVE_MPEG_ENCODE "Mpeg")
endif(ENABLE_MPEG_ENCODE)
if(ENABLE_OSMESA)
find_library(OSMESA_LIB OSMesa)
if(OSMESA_LIB)
set_config_option(HAVE_OSMESA "OSMesa")
list(APPEND EXTERNAL_LIBRARIES ${OSMESA_LIB})
endif(OSMESA_LIB)
endif(ENABLE_OSMESA)
find_package(OpenGL REQUIRED)
if(OPENGL_GLU_FOUND)
set_config_option(HAVE_OPENGL "OpenGL")
else(OPENGL_GLU_FOUND)
message(SEND_ERROR "Could not find GLU: disabling OpenGL support")
endif(OPENGL_GLU_FOUND)
endif(HAVE_FLTK OR HAVE_QT OR ENABLE_GRAPHICS)
if(ENABLE_DINTEGRATION)
include_directories(../contrib/DiscreteIntegration)
set_config_option(HAVE_DINTEGRATION "DIntegration")
endif(ENABLE_DINTEGRATION)
# process cmake environment variables so we can append them to the -I
# include commands. This is not recommended (we should only use the
# cache variables) but it is very convenient: otherwise we have to
# remember providing the -D... options to cmake for each new build.
set(ENV_CMAKE_PREFIX_PATH $ENV{CMAKE_PREFIX_PATH})
set(ENV_CMAKE_INCLUDE_PATH $ENV{CMAKE_INCLUDE_PATH})
if(UNIX)
if(ENV_CMAKE_PREFIX_PATH)
string(REPLACE ":" ";" ENV_CMAKE_PREFIX_PATH ${ENV_CMAKE_PREFIX_PATH})
endif(ENV_CMAKE_PREFIX_PATH)
if(ENV_CMAKE_INCLUDE_PATH)
string(REPLACE ":" ";" ENV_CMAKE_INCLUDE_PATH ${ENV_CMAKE_INCLUDE_PATH})
endif(ENV_CMAKE_INCLUDE_PATH)
endif(UNIX)
list(APPEND EXTERNAL_INCLUDES ${CMAKE_INCLUDE_PATH} ${ENV_CMAKE_INCLUDE_PATH})
list(APPEND EXTERNAL_INCLUDES ${CMAKE_PREFIX_PATH} ${ENV_CMAKE_PREFIX_PATH})
foreach(DIR ${CMAKE_PREFIX_PATH} ${ENV_CMAKE_PREFIX_PATH})
list(APPEND EXTERNAL_INCLUDES ${DIR}/include)
endforeach(DIR)
if(EXTERNAL_INCLUDES)
list(REMOVE_DUPLICATES EXTERNAL_INCLUDES)
endif(EXTERNAL_INCLUDES)
if(HAVE_FLTK)
set(LINK_LIBRARIES ${FLTK_LIBRARIES} ${EXTERNAL_LIBRARIES}
${OPENGL_LIBRARIES} ${LAPACK_LIBRARIES})
elseif(HAVE_QT)
set(LINK_LIBRARIES ${QT_LIBRARIES} ${EXTERNAL_LIBRARIES}
${OPENGL_LIBRARIES} ${LAPACK_LIBRARIES})
elseif(HAVE_OPENGL)
set(LINK_LIBRARIES ${EXTERNAL_LIBRARIES} ${OPENGL_LIBRARIES}
${LAPACK_LIBRARIES})
else(HAVE_FLTK)
set(LINK_LIBRARIES ${EXTERNAL_LIBRARIES} ${LAPACK_LIBRARIES})
endif(HAVE_FLTK)
# set this for external codes that might include this CMakeList file
set(GMSH_EXTERNAL_INCLUDE_DIRS ${EXTERNAL_INCLUDES} CACHE
STRING "External include directories" FORCE)
set(GMSH_EXTERNAL_LIBRARIES ${EXTERNAL_LIBRARIES} CACHE
STRING "External libraries" FORCE)
include_directories(${GMSH_EXTERNAL_INCLUDE_DIRS})
add_executable(mainAntTweakBar mainAntTweakBar.cpp)
target_link_libraries(mainAntTweakBar ${LINK_LIBRARIES})
add_executable(mainCartesian mainCartesian.cpp)
target_link_libraries(mainCartesian ${LINK_LIBRARIES})
add_executable(mainElasticity mainElasticity.cpp)
target_link_libraries(mainElasticity ${LINK_LIBRARIES})
add_executable(mainGlut mainGlut.cpp)
target_link_libraries(mainGlut ${glut} ${LINK_LIBRARIES})
add_executable(mainHomology mainHomology.cpp)
target_link_libraries(mainHomology ${LINK_LIBRARIES})
add_executable(mainLevelset mainLevelset.cpp)
target_link_libraries(mainLevelset ${LINK_LIBRARIES})
add_executable(mainOcc mainOcc.cpp)
target_link_libraries(mainOcc ${LINK_LIBRARIES})
add_executable(mainPost mainPost.cpp)
target_link_libraries(mainPost ${LINK_LIBRARIES})
add_executable(mainSimple mainSimple.cpp)
target_link_libraries(mainSimple ${LINK_LIBRARIES})
signature.asc
Description: This is a digitally signed message part
_______________________________________________ gmsh mailing list [email protected] http://www.geuz.org/mailman/listinfo/gmsh
