diff options
Diffstat (limited to 'dev/MinGfx/CMakeLists.txt')
| -rw-r--r-- | dev/MinGfx/CMakeLists.txt | 395 |
1 files changed, 395 insertions, 0 deletions
diff --git a/dev/MinGfx/CMakeLists.txt b/dev/MinGfx/CMakeLists.txt new file mode 100644 index 0000000..e3da874 --- /dev/null +++ b/dev/MinGfx/CMakeLists.txt @@ -0,0 +1,395 @@ +# Copyright (c) 2017,2018 Regents of the University of Minnesota. +# All rights reserved. +# +# Original Author(s) of this File: +# Daniel Keefe, Jan 2018, University of Minnesota -- This build system is inspired by +# the AUTOBUILD_DEPENDENCY approach I developed for the MinVR Open Source project. +# Tom Sgouros (Brown Univ.) and Dan Orban (Univ. of Minn.) also contributed to earlier +# versions of MinVR's build system and the use of cmake in other research software used +# in the IV/LAB. So, this is also at least loosly inspired by their contributions. +# See minvr.org for a full list of contributors to that project. +# +# Author(s) of Significant Updates/Modifications to the File: +# ... + + + + +#### BASIC PROJECT SETUP #### + +# Depends on cmake 3.9+ for its more advanced FindOpenGL.cmake module +cmake_minimum_required (VERSION 3.9) + +# Search path for cmake support scripts +list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/") + +# Version is <major>.<minor>.<patch> +cmake_policy(SET CMP0048 NEW) # Required for setting version number as part of the project() command +project(MinGfx_Toolkit VERSION 1.0.0) + +# This will be appended to the install destinations so that multiple versions of MinGfx +# can be safely installed on the same system. This intentionally does not include a +# patch number because patches should be small changes that do not change the API. +set(MINGFX_VERSION_STR -${MinGfx_Toolkit_VERSION_MAJOR}.${MinGfx_Toolkit_VERSION_MINOR}) + +# Organize folder structure for Xcode, Visual Studio, etc. +set_property(GLOBAL PROPERTY USE_FOLDERS ON) + +# For better formatting of output while configuring with cmake +include(MessageMacros) + +# If you "autobuild" external dependencies as part of the cmake configure process, then they will be +# downloaded to this directory. +set(AUTOBUILD_DOWNLOAD_DIR "${CMAKE_CURRENT_SOURCE_DIR}/external" CACHE STRING "Location for external project sources downloaded by AutoBuild.") + + +set(CMAKE_INSTALL_MESSAGE ALWAYS) + +include(AutoBuild) +AutoBuild_init() + + +#### ADJUST NAMES OF OUTPUT FILES BASED ON BUILD TYPE #### + +h1("CONFIGURING BUILD TYPES") + +# To distinguish between debugging, release, and other builds, we'll +# add a postfix to the name of the lib or exe that we generate. + +set(CMAKE_DEBUG_POSTFIX "d") +set(CMAKE_RELEASE_POSTFIX "") +set(CMAKE_RELWITHDEBINFO_POSTFIX "rd") +set(CMAKE_MINSIZEREL_POSTFIX "s") + +if (CMAKE_BUILD_TYPE MATCHES "Release") + set(CMAKE_BUILD_POSTFIX "${CMAKE_RELEASE_POSTFIX}") +elseif (CMAKE_BUILD_TYPE MATCHES "MinSizeRel") + set(CMAKE_BUILD_POSTFIX "${CMAKE_MINSIZEREL_POSTFIX}") +elseif (CMAKE_BUILD_TYPE MATCHES "RelWithDebInfo") + set(CMAKE_BUILD_POSTFIX "${CMAKE_RELWITHDEBINFO_POSTFIX}") +elseif (CMAKE_BUILD_TYPE MATCHES "Debug") + set(CMAKE_BUILD_POSTFIX "${CMAKE_DEBUG_POSTFIX}") +else() + set(CMAKE_BUILD_POSTFIX "") +endif() + + + + +#### SETUP DIRECTORIES FOR BUILDING AND INSTALLING #### + +h1("CONFIGURING BUILD/INSTALL LOCATIONS") + +h2("Configuring build directories.") + +message(STATUS "Tests, other binaries: ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}") +message(STATUS "Libraries: ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}") + + +h2("Configuring installation directories.") +if (CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set (CMAKE_INSTALL_PREFIX "${CMAKE_BINARY_DIR}/install" CACHE PATH "default install path" FORCE ) +endif() + +# When we autobuild dependencies, we install them in CMAKE_INSTALL_PREFIX, and then look for them +# there using find_package(). So, this makes sure the install prefix is in the path that +# find_package() searches. +list(APPEND CMAKE_MODULE_PATH ${CMAKE_INSTALL_PREFIX}) +list(APPEND CMAKE_PREFIX_PATH ${CMAKE_INSTALL_PREFIX}) + +# These are relative to ${CMAKE_INSTALL_PREFIX} +set(INSTALL_BIN_DEST bin) +set(INSTALL_LIB_DEST lib/MinGfx${MINGFX_VERSION_STR}) +set(INSTALL_INCLUDE_DEST include/MinGfx${MINGFX_VERSION_STR}) +set(INSTALL_SHADERS_DEST share/MinGfx${MINGFX_VERSION_STR}/shaders) +set(INSTALL_DATA_DEST share/MinGfx${MINGFX_VERSION_STR}/data) +set(INSTALL_DOC_DEST share/MinGfx${MINGFX_VERSION_STR}/docs) +set(INSTALL_CMAKECONFIG_DEST lib/cmake/MinGfx${MINGFX_VERSION_STR}) + +message(STATUS "Tests, other binaries: ${CMAKE_INSTALL_PREFIX}/${INSTALL_BIN_DEST}") +message(STATUS "MinGfx library: ${CMAKE_INSTALL_PREFIX}/${INSTALL_LIB_DEST}") +message(STATUS "MinGfx header files: ${CMAKE_INSTALL_PREFIX}/${INSTALL_INCLUDE_DEST}") +message(STATUS "MinGfx shader programs: ${CMAKE_INSTALL_PREFIX}/${INSTALL_SHADERS_DEST}") +message(STATUS "MinGfx data files: ${CMAKE_INSTALL_PREFIX}/${INSTALL_DATA_DEST}") +message(STATUS "MinGfx documentation files: ${CMAKE_INSTALL_PREFIX}/${INSTALL_DOC_DEST}") +message(STATUS "CMake Config Package for including MinGfx in other projects: ${CMAKE_INSTALL_PREFIX}/${INSTALL_CMAKECONFIG_DEST}") + +# Configure a header file to pass some of the CMake settings to the source code +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/src/mingfx_config.h.in + ${CMAKE_CURRENT_SOURCE_DIR}/src/mingfx_config.h +) + + +#### SET ANY COMPILER FLAGS #### + +h1("CONFIGURING COMPLIER FLAGS") + + + +message(STATUS "Building for " ${CMAKE_SYSTEM_NAME} ".") +message(STATUS "Compiler supported features = ${CMAKE_CXX_COMPILE_FEATURES}") + + +# Linux specific +if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") + add_definitions(-DLINUX) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14") +endif() + + +# Apple specific +if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") + add_definitions(-DOSX) + + # Since for some stupid reason Apple has now deprecated OpenGL + #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated") + add_definitions(-DGL_SILENCE_DEPRECATION) + + # RPATH settings, see https://cmake.org/Wiki/CMake_RPATH_handling + set(CMAKE_MACOSX_RPATH ON) + + # use, i.e. don't skip the full RPATH for the build tree + SET(CMAKE_SKIP_BUILD_RPATH FALSE) + + # when building, don't use the install RPATH already + # (but later on when installing) + SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE) + + SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") + + # add the automatically determined parts of the RPATH + # which point to directories outside the build tree to the install RPATH + SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) + + # the RPATH to be used when installing, but only if it's not a system directory + LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${CMAKE_INSTALL_PREFIX}/lib" isSystemDir) + IF("${isSystemDir}" STREQUAL "-1") + SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") + ENDIF("${isSystemDir}" STREQUAL "-1") + + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14") +endif() + + +# Windows specific +if (WIN32) + add_definitions(-DWIN32) + set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7") +endif() + + + + +#### DEFINE THE LIBRARY WE WANT TO BUILD #### + +h1("CONFIGURING LIBMINGFX") + +h2("Configuring core library source.") +message(STATUS "Adding src to the build.") + +# Intentionally using include() rather than add_subdirectory() so that the MinGfx target +# is defined in the scope of this CMakeLists.txt file. That way, sudirs that depend +# upon it can list it as a dependency. +include(src/CMakeLists.txt) + + + + +#### DEFINE ADDITIONAL BUILD TARGETS, LIKE TEST PROGRAMS, ETC. #### + +h1("CONFIGURING PROGRAMS AND DATA") + +h2("Cofiguring test programs.") +message(STATUS "Adding all subirectories of tests to the build.") +add_subdirectory(tests/blank_window) +add_subdirectory(tests/gui_plus_opengl) + + +h2("Cofiguring data.") +message(STATUS "Identifying data to install.") +install( + DIRECTORY data/ + DESTINATION ${INSTALL_DATA_DEST} +) + + + +#### OPTIONALLY, BUILD DOXYGEN-STYLE DOCUMENTATION #### + +h1("CONFIGURING DOCUMENTATION") + +h2("Configuring Web-Based Documentation.") +option(WITH_DOCUMENTATION "Builds web-based documentation for the library. (Requires doxygen)") +if (WITH_DOCUMENTATION) + message(STATUS "ON: Will build and install MinGfx Web-Based Documentation.") +else() + message(STATUS "OFF: NOT building MinGfx Web-Based Documentation.") +endif() + +if (WITH_DOCUMENTATION) + find_package(Doxygen) + if(NOT DOXYGEN_FOUND) + message(FATAL_ERROR "Doxygen is needed to build the documentation.") + endif() + + set(DOXY_FILES + doc/Doxyfile.in + doc/api.md + doc/installation.md + doc/mainpage.md + doc/header.html + doc/index.html + doc/footer.html + doc/customdoxygen.css + ) + + set(OTHER_DOCS + README.md + LICENSE.txt + ) + + # Process the config file and put it in the build directory. + set(DOXYFILE_IN ${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile.in) + set(DOXYFILE ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile) + configure_file(${DOXYFILE_IN} ${DOXYFILE} @ONLY) + + add_custom_target(doc ALL + ${DOXYGEN_EXECUTABLE} ${DOXYFILE} + DEPENDS ${DOXY_FILES} ${OTHER_DOCS} + SOURCES ${DOXY_FILES} ${OTHER_DOCS} + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Generating documentation with Doxygen" + VERBATIM + ) + + set_source_files_properties(${DOXY_FILES} PROPERTIES HEADER_FILE_ONLY TRUE) + source_group("Doxygen Files" FILES ${DOXY_FILES}) + + set_source_files_properties(${OTHER_DOCS} PROPERTIES HEADER_FILE_ONLY TRUE) + source_group("Other Docs" FILES ${OTHER_DOCS}) + + install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html + DESTINATION ${INSTALL_DOC_DEST} + COMPONENT Docs + OPTIONAL + ) + + install(FILES doc/index.html + DESTINATION ${INSTALL_DOC_DEST} + COMPONENT Docs + OPTIONAL + ) +endif() + + + + + +#### CREATE/INSTALL A CMAKE CONFIG PACKAGE TO HELP OTHERS LINK TO THE LIBRARY #### + +h1("WRITING CMAKE CONFIG PACKAGE") + +# The documentation for setting this up is so bad. These pages all helped. My current +# understanding (dfk) is summarized below to help others. +# https://cmake.org/cmake/help/git-master/manual/cmake-packages.7.html#creating-packages +# https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#target-usage-requirements +# http://foonathan.net/blog/2016/03/03/cmake-install.html +# https://archive.fosdem.org/2013/schedule/event/moderncmake/attachments/slides/258/export/events/attachments/moderncmake/slides/258/cmake_fosdem_2013.pdf + +# CMake Package Config in a Nutshell: + +# CMake config packages are the newer, recommended way of distributing projects built with CMake. +# They replace the older FindModule.cmake approach for including dependencies in a cmake project, +# but not everyone has yet switched over to the new approach. Both styles can work together, and +# this seems to often be required because many libraries are not yet distributing a *Config.cmake +# file with their install tree. + + +# 1. The Difference Between "Find Modules" (Find*.cmake) and "Config Packages" (*Config.cmake) + +# Whereas, Find*.cmake files are either installed on the system or written by downstream projects. +# *Config.cmake files are created and installed by the upstream projects (e.g., we want generate +# MinVRConfig.cmake and install it whenever the MinVR project in installed). + +# When you use a Find Module, it defines several variables (e.g., OPENGL_INCLUDE_DIR, OPENGL_LIBRARIES) +# that you must then be sure to add to the include dirs and libs to link with your project. +# Config Packages are different. Instead, they "export" the targets defined in the original project +# (e.g., the target MinGfx is used in this file to build libMinGfx.a) so that the client project +# may refer to these targets directly. This is pretty cool because we can define the MinGfx target +# in such a way that cmake even knows which header files are associated with it, and will add the +# required include flags whenever the MinGfx target is used. + + +# 2. How to use Config Packages in a client CMakeLists.txt + +# With the config package appraoch, client projects only need to include two lines to use our library: + +# find_package(MinGfx REQUIRED) +# ... then, after add_executable(${PROJECT_NAME}) or add_library(${PROJECT_NAME}) +# target_link_libraries(${PROJECT_NAME} PUBLIC MinGfx) + + +# 3. Finding *Config.cmake files + +# Config packages are files of the form MyProjNameConfig.cmake (or *-config.cmake). Each library +# provides and installs its own config package. So, here we will create one to install with MinGfx. +# If created correctly, these packages can be relocatable, i.e., not specific to the install path +# used on a particular machine. When you call find_package(...) cmake looks for packages in a +# variety of locations (e.g., /usr/local/lib/cmake/*). + +# Since config packages are supposed to be written by and installed by the upstream dependencies, +# my understanding is that you should not attempt to write you own version of a config package if +# you encounter a project that is not (yet) using the config package appraoch. Instead, use the +# older Find Module appraoch. If CMake ships with a Find*.cmake file for that project, then use +# it. If not, then you can write your own. Since making this switch, many of the newer +# Find*.cmake scripts that ship with CMake have been updated to support imported targets. They +# are still called something like FindOpenGL.cmake, but in addition to just setting vars like +# OPENGL_INCLUDE_DIR, they also define targets, such as OpenGL::GL. We use these when we can +# because they are more robust. When you do target_link_libraries(myproj PULBIC OpenGL::GL) +# cmake knows to not only link with the the opengl library but also to include its headers and +# link with all dependencies. + + +# This tells cmake to generate a MinGfxTargets.cmake file that works for importing all targets +# associated with the MinGfx export group from the install tree. This file is where all the +# important cmake magic happens. It is auto-generated. This call also installs the file to +# the appropriate location. +install(EXPORT MinGfxTargets + NAMESPACE MinGfx:: + FILE MinGfxTargets.cmake + DESTINATION ${INSTALL_CMAKECONFIG_DEST} +) + +# This is a very small wrapper around the MinGfxTargets.cmake file. It's possible to use this +# configure_file() command to replace variables (e.g., special defines, install paths) in the +# file, but we do not currently need that functionality. +configure_file( + cmake/MinGfxConfig.cmake.in + "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfig.cmake" + COPYONLY +) + +# This auto-generates a standard CMake config version file. Using this, client projects can +# check to see if a specific version of MinGfx is installed on the system. +include(CMakePackageConfigHelpers) +set_property(TARGET MinGfx PROPERTY VERSION ${MinGfx_Toolkit_VERSION}) +write_basic_package_version_file( + "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfigVersion.cmake" + VERSION ${MinGfx_Toolkit_VERSION} + COMPATIBILITY AnyNewerVersion +) + +# The two Config files also get installed +install( + FILES + "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfig.cmake" + "${CMAKE_CURRENT_BINARY_DIR}/cmake/MinGfxConfigVersion.cmake" + DESTINATION + "${INSTALL_CMAKECONFIG_DEST}" +) + + +AutoBuild_check_status() + |