Skip to content
Snippets Groups Projects
Commit 8b9c78b1 authored by Ben Boeckel's avatar Ben Boeckel
Browse files

cmake: use the new module system

parent aca94453
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
CMake/vtk-config.cmake.in 0 → 100644
+ 158
− 0
View file @ 8b9c78b1
#[==[.md
# vtk-config.cmake
This file is used by CMake when finding VTK. It provides the [VTK module
API][] as well as some VTK-specific APIs.
The following variables are provided by this module:
* `VTK_VERSION`: The version of VTK found.
* `VTK_LEGACY_REMOVE`: Whether VTK's deprecated APIs are
compiled out or not.
* `VTK_HAS_VTKm`: If VTK provides VTK-m.
* `VTK_WRAP_PYTHON`: If VTK itself provides Python wrapping. If so, the
Python parts of the module API are available.
* `VTK_WRAP_JAVA`: If VTK itself provides Java wrapping. If so, the
Java parts of the module API are available.
* `VTK_LIBRARIES`: The list of modules specified by `COMPONENTS` and
`OPTIONAL_COMPONENTS`. This may be used in `MODULES` arguments in the API
(e.g., `vtk_module_autoinit`). All modules are also targets and may be
linked to using `target_link_libraries`.
[VTK module API]: TODO: Link to hosted documentation.
#]==]
set(CMAKE_MODULE_PATH_save "${CMAKE_MODULE_PATH}")
list(APPEND CMAKE_MODULE_PATH
"${CMAKE_CURRENT_LIST_DIR}")
set("${CMAKE_FIND_PACKAGE_NAME}_VERSION" "@VTK_MAJOR_VERSION@.@VTK_MINOR_VERSION@.@VTK_BUILD_VERSION@")
set("${CMAKE_FIND_PACKAGE_NAME}_LEGACY_REMOVE" "@VTK_LEGACY_REMOVE@")
set("${CMAKE_FIND_PACKAGE_NAME}_HAS_VTKm" "@vtk_has_vtkm@")
if (${CMAKE_FIND_PACKAGE_NAME}_HAS_VTKm)
find_package(VTKm
PATHS "${CMAKE_CURRENT_LIST_DIR}/vtkm"
NO_DEFAULT_PATH)
if (NOT VTKm_FOUND)
set("${CMAKE_FIND_PACKAGE_NAME}_FOUND" 0)
endif ()
endif ()
unset("${CMAKE_FIND_PACKAGE_NAME}_FOUND")
include("${CMAKE_CURRENT_LIST_DIR}/vtkCMakeBackports.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/${CMAKE_FIND_PACKAGE_NAME}-targets.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/${CMAKE_FIND_PACKAGE_NAME}-vtk-module-properties.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/${CMAKE_FIND_PACKAGE_NAME}-vtk-module-find-packages.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtkExternalData.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtkModule.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtkEncodeString.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtkHashSource.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtkObjectFactory.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtkModuleJson.cmake")
set("${CMAKE_FIND_PACKAGE_NAME}_WRAP_PYTHON" "@VTK_WRAP_PYTHON@")
if (${CMAKE_FIND_PACKAGE_NAME}_WRAP_PYTHON)
include("${CMAKE_CURRENT_LIST_DIR}/vtkmodules-vtk-python-module-properties.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtkModuleWrapPython.cmake")
include("${CMAKE_CURRENT_LIST_DIR}/vtk-python.cmake")
else ()
set("${CMAKE_FIND_PACKAGE_NAME}_PYTHONPATH")
endif ()
set("${CMAKE_FIND_PACKAGE_NAME}_WRAP_JAVA" "@VTK_WRAP_JAVA@")
if (${CMAKE_FIND_PACKAGE_NAME}_WRAP_JAVA)
include("${CMAKE_CURRENT_LIST_DIR}/vtkModuleWrapJava.cmake")
endif ()
set(_vtk_components_to_check)
foreach (_vtk_component IN LISTS "${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS")
if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND")
# It was already not-found (likely due to `find-package` failures).
elseif (TARGET "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}")
list(APPEND _vtk_components_to_check
"${_vtk_component}")
else ()
set("${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND" 0)
list(APPEND "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_NOT_FOUND_MESSAGE"
"The ${_vtk_component} component is not available.")
endif ()
endforeach ()
unset(_vtk_component)
while (_vtk_components_to_check)
list(GET _vtk_components_to_check 0 _vtk_component)
list(REMOVE_AT _vtk_components_to_check 0)
if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND")
# We've already made a determiniation.
continue ()
endif ()
get_property(_vtk_dependencies
TARGET "${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}"
PROPERTY "INTERFACE_vtk_module_depends")
string(REPLACE "${CMAKE_FIND_PACKAGE_NAME}::" "" _vtk_dependencies "${_vtk_dependencies}")
set(_vtk_all_dependencies_checked TRUE)
foreach (_vtk_dependency IN LISTS _vtk_dependencies)
if (DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_dependency}_FOUND")
if (NOT ${CMAKE_FIND_PACKAGE_NAME}_${_vtk_dependency}_FOUND)
set("${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND" 0)
list(APPEND "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_NOT_FOUND_MESSAGE"
"Failed to find the ${_vtk_dependency} component.")
endif ()
else ()
# Check its dependencies.
list(APPEND _vtk_components_to_check
"${_vtk_dependency}")
set(_vtk_all_found FALSE)
endif ()
endforeach ()
if (NOT DEFINED "${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND")
if (_vtk_all_dependencies_checked)
set("${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND" 1)
else ()
list(APPEND _vtk_components_to_check
"${_vtk_component}")
endif ()
endif ()
unset(_vtk_all_dependencies_checked)
unset(_vtk_dependency)
unset(_vtk_dependencies)
endwhile ()
unset(_vtk_component)
unset(_vtk_components_to_check)
set(_vtk_missing_components)
foreach (_vtk_component IN LISTS "${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS")
if (NOT ${CMAKE_FIND_PACKAGE_NAME}_${_vtk_component}_FOUND AND ${CMAKE_FIND_PACKAGE_NAME}_FIND_REQUIRED_${_vtk_component})
list(APPEND _vtk_missing_components
"${_vtk_component}")
endif ()
endforeach ()
if (_vtk_missing_components)
list(REMOVE_DUPLICATES _vtk_missing_components)
list(SORT _vtk_missing_components)
string(REPLACE ";" ", " _vtk_missing_components "${_vtk_missing_components}")
set("${CMAKE_FIND_PACKAGE_NAME}_FOUND" 0)
set("${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE"
"Could not find the ${CMAKE_FIND_PACKAGE_NAME} package with the following required components: ${_vtk_missing_components}.")
endif ()
unset(_vtk_missing_components)
set("${CMAKE_FIND_PACKAGE_NAME}_LIBRARIES")
if (NOT DEFINED "${CMAKE_FIND_PACKAGE_NAME}_FOUND")
# If nothing went wrong, we've successfully found the package.
set("${CMAKE_FIND_PACKAGE_NAME}_FOUND" 1)
# Build the `_LIBRARIES` variable.
foreach (_vtk_component IN LISTS "${CMAKE_FIND_PACKAGE_NAME}_FIND_COMPONENTS")
list(APPEND "${CMAKE_FIND_PACKAGE_NAME}_LIBRARIES"
"${CMAKE_FIND_PACKAGE_NAME}::${_vtk_component}")
endforeach ()
unset(_vtk_component)
endif ()
set(CMAKE_MODULE_PATH "${CMAKE_MODULE_PATH_save}")
unset(CMAKE_MODULE_PATH_save)
CMake/vtkWrapSettings.cmake
+ 13
− 9
View file @ 8b9c78b1
......@@ -16,28 +16,32 @@ endif()
if(BUILD_TESTING OR VTK_WRAP_PYTHON)
# Need PYTHON_EXECUTABLE for HeaderTesting or python wrapping
find_package(PythonInterp ${VTK_PYTHON_VERSION} QUIET)
find_package(PythonInterp "${VTK_PYTHON_VERSION}" QUIET)
mark_as_advanced(PYTHON_EXECUTABLE)
endif()
if(VTK_WRAP_PYTHON)
set(VTK_WRAP_PYTHON_EXE vtkWrapPython)
set(VTK_WRAP_PYTHON_INIT_EXE vtkWrapPythonInit)
set(VTK_WRAP_PYTHON_EXE VTK::WrapPython)
set(VTK_WRAP_PYTHON_INIT_EXE VTK::WrapPythonInit)
endif()
include(CMakeDependentOption)
cmake_dependent_option(VTK_USE_TK "Build VTK with Tk support" OFF
"VTK_WRAP_PYTHON" OFF)
option(VTK_WRAP_JAVA "Should VTK Java wrapping be built?" OFF)
if(VTK_WRAP_JAVA)
set(VTK_WRAP_JAVA3_INIT_DIR "${VTK_SOURCE_DIR}/Wrapping/Java")
# Wrapping executables.
set(VTK_WRAP_JAVA_EXE vtkWrapJava)
set(VTK_PARSE_JAVA_EXE vtkParseJava)
set(VTK_WRAP_JAVA_EXE VTK::WrapJava)
set(VTK_PARSE_JAVA_EXE VTK::ParseJava)
# Java package location.
set(VTK_JAVA_JAR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/vtk.jar)
set(VTK_JAVA_HOME ${VTK_BINARY_DIR}/java/vtk)
file(MAKE_DIRECTORY ${VTK_JAVA_HOME})
set(VTK_JAVA_JAR "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/vtk.jar")
set(VTK_JAVA_HOME "${VTK_BINARY_DIR}/java/vtk")
file(MAKE_DIRECTORY "${VTK_JAVA_HOME}")
endif()
if(VTK_WRAP_PYTHON OR VTK_WRAP_JAVA OR VTK_WRAP_HIERARCHY)
set(VTK_WRAP_HIERARCHY_EXE vtkWrapHierarchy)
set(VTK_WRAP_HIERARCHY_EXE VTK::WrapHierarchy)
endif()
CMakeLists.txt
+ 269
− 56
View file @ 8b9c78b1
cmake_minimum_required(VERSION 3.3...3.12 FATAL_ERROR)
cmake_minimum_required(VERSION 3.8...3.12 FATAL_ERROR)
foreach(policy
CMP0083 # CMake 3.14
)
......@@ -11,6 +11,13 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Android" AND CMAKE_VERSION VERSION_LESS 3.7)
message(FATAL_ERROR "CMake 3.7 or above is required to build for Android")
endif()
if (POLICY CMP0063)
cmake_policy(SET CMP0063 NEW)
endif ()
if (POLICY CMP0065)
cmake_policy(SET CMP0065 NEW)
endif ()
project(VTK)
set(vtk_cmake_dir "${VTK_SOURCE_DIR}/CMake")
......@@ -51,13 +58,12 @@ include(vtkMobileDevices)
include(vtkCrossCompiling)
include(vtkWrapSettings)
include(vtkObjectFactory)
include(vtkCMakeBackports)
# Setup compiler flags for dynamic analysis
# Should be included after vtkTesting
include(vtkCompilerDynamicAnalysisFlags)
#include(vtkModuleMacros)
#-----------------------------------------------------------------------------
# Do we want examples built?
option(BUILD_EXAMPLES "Build VTK examples." OFF)
......@@ -93,18 +99,267 @@ include(CheckTypeSize)
option(VTK_ENABLE_KITS "Build VTK using kits instead of modules." OFF)
mark_as_advanced(VTK_ENABLE_KITS)
option(VTK_USE_MPI "Support MPI" OFF)
set(VTK_BUILD_TESTING "DEFAULT"
CACHE STRING "Build all modules by default")
set_property(CACHE VTK_BUILD_TESTING
PROPERTY
STRINGS "ON;OFF;DEFAULT")
include(vtkEncodeString)
if (FALSE)
set(vtk_requested_modules)
set(vtk_rejected_modules)
if (VTK_WRAP_PYTHON)
list(APPEND vtk_requested_modules
VTK::WrappingPythonCore
VTK::WrappingTools
VTK::PythonInterpreter)
else ()
list(APPEND vtk_rejected_modules
VTK::Python)
endif ()
if (VTK_WRAP_JAVA)
list(APPEND vtk_requested_modules
VTK::Java
VTK::WrappingTools)
else ()
list(APPEND vtk_rejected_modules
VTK::Java)
endif ()
if (VTK_USE_MPI)
set(VTK_GROUP_ENABLE_MPI ON)
else ()
# Reject `VTK::mpi`, but allow those which happen to be part of the group to
# be built.
set(VTK_GROUP_ENABLE_MPI DONT_WANT)
list(APPEND vtk_rejected_modules
VTK::mpi)
endif ()
if (VTK_BUILD_TESTING)
list(APPEND vtk_requested_modules
# Required for just about all VTK tests.
VTK::TestingCore)
endif ()
list(APPEND vtk_requested_modules
# Required for just about everything.
VTK::CommonCore
VTK::CommonDataModel
# Required for wrapping with hierarchy files.
VTK::WrappingTools)
if (vtk_requested_modules)
list(REMOVE_DUPLICATES vtk_requested_modules)
endif ()
if (vtk_rejected_modules)
list(REMOVE_DUPLICATES vtk_rejected_modules)
endif ()
set_property(GLOBAL
PROPERTY
"_vtk_module_autoinit_include" "\"vtkAutoInit.h\"")
option(VTK_BUILD_ALL_MODULES "Build all modules by default" OFF)
mark_as_advanced(VTK_BUILD_ALL_MODULES)
# Turn on these groups by default.
set(_vtk_module_group_default_StandAlone "WANT")
set(_vtk_module_group_default_Rendering "WANT")
include(vtkModule)
vtk_module_find_modules(vtk_common_module_files
"${CMAKE_CURRENT_SOURCE_DIR}/Accelerators"
"${CMAKE_CURRENT_SOURCE_DIR}/Charts"
"${CMAKE_CURRENT_SOURCE_DIR}/Common"
"${CMAKE_CURRENT_SOURCE_DIR}/Domains"
"${CMAKE_CURRENT_SOURCE_DIR}/Filters"
"${CMAKE_CURRENT_SOURCE_DIR}/Geovis"
"${CMAKE_CURRENT_SOURCE_DIR}/GUISupport"
"${CMAKE_CURRENT_SOURCE_DIR}/Imaging"
"${CMAKE_CURRENT_SOURCE_DIR}/Infovis"
"${CMAKE_CURRENT_SOURCE_DIR}/Interaction"
"${CMAKE_CURRENT_SOURCE_DIR}/IO"
"${CMAKE_CURRENT_SOURCE_DIR}/Parallel"
"${CMAKE_CURRENT_SOURCE_DIR}/Rendering"
"${CMAKE_CURRENT_SOURCE_DIR}/Testing"
"${CMAKE_CURRENT_SOURCE_DIR}/ThirdParty"
"${CMAKE_CURRENT_SOURCE_DIR}/Utilities"
"${CMAKE_CURRENT_SOURCE_DIR}/Views"
"${CMAKE_CURRENT_SOURCE_DIR}/Web"
"${CMAKE_CURRENT_SOURCE_DIR}/Wrapping")
vtk_module_scan(
MODULE_FILES ${vtk_module_files}
KIT_FILES ${vtk_kit_files}
REQUEST_MODULES ${vtk_requested_modules}
REJECT_MODULES ${vtk_rejected_modules}
PROVIDES_MODULES vtk_modules
PROVIDES_KITS vtk_kits
REQUIRES_MODULES vtk_required_modules
UNRECOGNIZED_MODULES vtk_unrecognized_modules
WANT_BY_DEFAULT "${VTK_BUILD_ALL_MODULES}"
ENABLE_TESTS "${VTK_BUILD_TESTING}")
if (vtk_required_modules OR vtk_unrecognized_modules)
message(FATAL_ERROR
"The following modules were requested or required, but not found: "
"${vtk_required_modules};${vtk_unrecognized_modules}.")
endif ()
option(VTK_ENABLE_KITS "Enable kits compilation" OFF)
mark_as_advanced(VTK_ENABLE_KITS)
#----------------------------------------------------------------------
# Load the module DAG, assess all modules etc.
include(vtkModuleTop)
option(VTK_USE_EXTERNAL "Use external copies of third party libraries by default" OFF)
mark_as_advanced(VTK_USE_EXTERNAL)
vtk_module_build(
MODULES ${vtk_modules}
KITS ${vtk_kits}
INSTALL_EXPORT VTK
HEADERS_DESTINATION "include/vtk-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}"
CMAKE_DESTINATION "lib/cmake/vtk-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}"
LIBRARY_NAME_SUFFIX "${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}"
VERSION "${VTK_VERSION}"
SOVERSION "1"
TEST_DATA_TARGET VTKData
BUILD_WITH_KITS "${VTK_ENABLE_KITS}"
USE_EXTERNAL "${VTK_USE_EXTERNAL}"
TEST_INPUT_DATA_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Testing"
TEST_OUTPUT_DATA_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/ExternalData/Testing")
include(vtkModuleJson)
vtk_module_json(
MODULES ${vtk_modules}
OUTPUT "modules.json")
include(vtkModuleGraphviz)
vtk_module_graphviz(
MODULES ${vtk_modules}
KIT_CLUSTERS ON
PRIVATE_DEPENDENCIES OFF
OUTPUT "modules.dot")
ExternalData_Add_Target(VTKData)
if (VTK_WRAP_PYTHON)
include(vtkModuleWrapPython)
vtk_module_wrap_python(
MODULES ${vtk_modules}
INSTALL_EXPORT VTK
PYTHON_PACKAGE "vtkmodules"
MODULE_DESTINATION "${VTK_PYTHON_SITE_PACKAGES_SUFFIX}"
CMAKE_DESTINATION "lib/cmake/vtk-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}"
WRAPPED_MODULES vtk_python_wrapped_modules
TARGET VTK::vtkpythonmodules)
# Now build the Python wrapping if necessary.
if(VTK_WRAP_PYTHON)
add_subdirectory(Wrapping/Python)
endif()
endif ()
set(vtk_cmake_build_dir
"${CMAKE_CURRENT_BINARY_DIR}/lib/cmake/vtk-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}")
configure_file(
"${vtk_cmake_dir}/vtk-config.cmake.in"
"${vtk_cmake_build_dir}/vtk-config.cmake"
@ONLY)
include(CMakePackageConfigHelpers)
write_basic_package_version_file("${vtk_cmake_build_dir}/vtk-config-version.cmake"
VERSION "${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}.${VTK_BUILD_VERSION}"
COMPATIBILITY SameMinorVersion)
set(vtk_cmake_module_files
FindADIOS1.cmake
Finddouble-conversion.cmake
FindEigen3.cmake
FindEXPAT.cmake
FindFFMPEG.cmake
FindFontConfig.cmake
FindFreetype.cmake
FindGL2PS.cmake
FindGLEW.cmake
FindJsonCpp.cmake
FindLibHaru.cmake
FindLibPROJ.cmake
FindLibXml2.cmake
FindLZ4.cmake
FindLZMA.cmake
Findmpi4py.cmake
FindMySQL.cmake
FindNetCDF.cmake
FindODBC.cmake
FindOGG.cmake
FindOpenMP.cmake
FindOpenSlide.cmake
FindOpenVR.cmake
FindOptiX.cmake
FindOSMesa.cmake
FindPostgreSQL.cmake
FindPythonModules.cmake
FindTBB.cmake
FindTHEORA.cmake
vtkCMakeBackports.cmake
vtkEncodeString.cmake
vtkExternalData.cmake
vtkHashSource.cmake
vtkModule.cmake
vtkModuleGraphviz.cmake
vtkModuleJson.cmake
vtkModuleTesting.cmake
vtkModuleWrapJava.cmake
vtkModuleWrapPython.cmake
vtkObjectFactory.cmake
vtkObjectFactory.cxx.in
vtkObjectFactory.h.in
vtkTestingRenderingDriver.cmake
vtkTopologicalSort.cmake)
set(vtk_cmake_patch_files
patches/3.7/FindPNG.cmake
patches/3.7/FindTIFF.cmake
patches/3.7/exportheader.cmake.in
patches/3.7/GenerateExportHeader.cmake
patches/3.10/FindMPI/fortranparam_mpi.f90.in
patches/3.10/FindMPI/libver_mpi.c
patches/3.10/FindMPI/libver_mpi.f90.in
patches/3.10/FindMPI/mpiver.f90.in
patches/3.10/FindMPI/test_mpi.c
patches/3.10/FindMPI/test_mpi.f90.in
patches/3.10/FindMPI.cmake
patches/3.13/FindZLIB.cmake
patches/3.14/FindGDAL.cmake
patches/3.14/FindJPEG.cmake
patches/3.14/FindOpenGL.cmake
patches/3.14/FindSQLite3.cmake
patches/3.14/FindX11.cmake)
set(vtk_cmake_files_to_install)
foreach (vtk_cmake_module_file IN LISTS vtk_cmake_module_files vtk_cmake_patch_files)
configure_file(
"${vtk_cmake_dir}/${vtk_cmake_module_file}"
"${vtk_cmake_build_dir}/${vtk_cmake_module_file}"
COPYONLY)
list(APPEND vtk_cmake_files_to_install
"${vtk_cmake_module_file}")
endforeach ()
foreach (vtk_cmake_file IN LISTS vtk_cmake_files_to_install)
get_filename_component(subdir "${vtk_cmake_file}" DIRECTORY)
install(
FILES "${vtk_cmake_dir}/${vtk_cmake_file}"
DESTINATION "lib/cmake/vtk-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}/${subdir}"
COMPONENT "development")
endforeach ()
install(
FILES "${vtk_cmake_build_dir}/vtk-config.cmake"
"${vtk_cmake_build_dir}/vtk-config-version.cmake"
DESTINATION "lib/cmake/vtk-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}"
COMPONENT "development")
vtk_module_export_find_packages(
CMAKE_DESTINATION "lib/cmake/vtk-${VTK_MAJOR_VERSION}.${VTK_MINOR_VERSION}"
FILE_NAME "VTK-vtk-module-find-packages.cmake"
MODULES ${vtk_modules})
if(BUILD_TESTING)
add_subdirectory(Testing/Install)
......@@ -115,8 +370,8 @@ if(BUILD_EXAMPLES)
endif()
# The doxygen documentation needs to be aware of all modules.
option(BUILD_DOCUMENTATION "Build the VTK documentation" OFF)
if(BUILD_DOCUMENTATION)
option(VTK_BUILD_DOCUMENTATION "Build the VTK documentation" OFF)
if(VTK_BUILD_DOCUMENTATION)
add_subdirectory(Utilities/Doxygen)
endif()
......@@ -127,50 +382,8 @@ if(BUILD_TESTING AND VTK_WRAP_PYTHON)
add_subdirectory(Utilities/vtkTclTest2Py)
endif()
# Configure the CTestCustom.cmake file now that everything is done.
set(memcheck_excluded_tests " # These tests do not run any VTK code\n")
foreach(vtk-module ${VTK_MODULES_ALL})
set(memcheck_excluded_tests
"${memcheck_excluded_tests} ${vtk-module}-HeaderTest\n")
endforeach()
configure_file("${vtk_cmake_dir}/CTestCustom.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/CTestCustom.cmake" @ONLY)
#-----------------------------------------------------------------------------
# Export all targets at once from the build tree in their final configuration.
get_property(_vtk_targets GLOBAL PROPERTY VTK_TARGETS)
get_property(_vtk_compiletools_targets GLOBAL PROPERTY VTK_COMPILETOOLS_TARGETS)
set (_vtk_all_targets ${_vtk_targets} ${_vtk_compiletools_targets})
if (_vtk_all_targets)
list(REMOVE_DUPLICATES _vtk_all_targets)
export(TARGETS ${_vtk_all_targets} FILE ${VTK_BINARY_DIR}/VTKTargets.cmake)
endif()
# Add a virtual target that can be used to build all compile tools.
add_custom_target(vtkCompileTools)
if (_vtk_compiletools_targets)
list(REMOVE_DUPLICATES _vtk_compiletools_targets)
add_dependencies(vtkCompileTools ${_vtk_compiletools_targets})
endif()
export(TARGETS ${_vtk_compiletools_targets}
FILE ${VTK_BINARY_DIR}/VTKCompileToolsConfig.cmake)
unset(_vtk_targets)
unset(_vtk_compiletools_targets)
unset(_vtk_all_targets)
# Create target to download data from the VTKData group. This must come after
# all tests have been added that reference the group, so we put it last.
ExternalData_Add_Target(VTKData)
if(VTK_DATA_EXCLUDE_FROM_ALL)
set_property(TARGET VTKData PROPERTY EXCLUDE_FROM_ALL 1)
if(BUILD_TESTING AND NOT VTK_DATA_EXCLUDE_FROM_ALL_NO_WARNING)
message(WARNING "VTK_DATA_EXCLUDE_FROM_ALL is ON so test data "
"(needed because BUILD_TESTING is ON) may not be available "
"without manually building the 'VTKData' target.")
endif()
endif()
endif ()
# TODO: The VTKCompileTools package.
# TODO: HeaderTest exclusions for memcheck.
#-----------------------------------------------------------------------------
# Install the license file
......
Documentation/maint/release.md
+ 1
− 1
View file @ 8b9c78b1
......@@ -197,7 +197,7 @@ endings.
### Documentation
On a machine with `doxygen` installed, configure a build with
`BUILD_DOCUMENTATION=ON` and run the `DoxygenDoc` target. To create the
`VTK_BUILD_DOCUMENTATION=ON` and run the `DoxygenDoc` target. To create the
documentation tarball, run:
```sh
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment