Export CMake Config file and "modernize" CMake scripts (#87)

* CMake modifications and Config file generation

* CMake minor style changes

* Get rid of commented lines, fix indentation

* Respect Windows conventions for CMake config directory, Fix error with Config Version file, Export CMake package

* Add CMake option for use of ENTT_COMPILE_OPTIONS, Add CMake option for using libc++, Remove  from EnTT target and move it to test targets

* Fix indentation

* Fix indentation (again)

* Fix Windows problems with compile option -Wall in not using it on Windows

* Improved generator expression
The problem with -Wall is not due to the platform but due to the compiler MSVC

* Set compatibility for ConfigVersion file to AnyNewerVersion, Add PATH_VARS CMAKE_INSTALL_INCLUDE_DIR of configure_package_config_file, Remove redundant options, correct target_include_directory for INSTALL_INTERFACE, set the Version in EnTTConfig file and check CMake version

* Add missing closing brace, Add a special config file for the build tree

CMakeLists.txt

@@ -4,6 +4,8 @@
 
 cmake_minimum_required(VERSION 3.2)
 
+include(GNUInstallDirs)
+
 #
 # Building in-tree is not allowed (we take care of your craziness).
 #
@@ -32,48 +34,117 @@ message("* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
 message("* Copyright (c) 2018 ${PROJECT_AUTHOR} <${PROJECT_AUTHOR_EMAIL}>")
 message("*")
 
+option(ENTT_COMPILE_OPTIONS "Use compile options from EnTT." ON)
+option(USE_LIBCPP "Use libc++ by adding -stdlib=libc++ flag if availbale." ON)
+
 #
 # Compiler stuff
 #
 
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-if(NOT MSVC)
+if(NOT MSVC AND USE_LIBCPP)
     include(CheckCXXSourceCompiles)
+    include(CMakePushCheckState)
+    
+    cmake_push_check_state()
 
-    set(OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -stdlib=libc++")
+    
     check_cxx_source_compiles("
         #include<type_traits>
         int main() { return std::is_same<int, int>::value ? 0 : 1; }
     " HAS_LIBCPP)
 
-    if(NOT HAS_LIBCPP)
-        set(CMAKE_CXX_FLAGS "${OLD_CMAKE_CXX_FLAGS}")
+    if(USE_LIBCPP AND NOT HAS_LIBCPP)
+        message(WARNING "The option USE_LIBCPP is set (by default) but libc++ is not available. The flag will not be added to the target")
     endif()
 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DRELEASE")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -DDEBUG")
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
-
-    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        # it seems that -O3 ruins the performance when using clang ...
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
-    else()
-        # ... on the other side, GCC is incredibly comfortable with it.
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-    endif()
+    cmake_pop_check_state()
 endif()
 
 #
-# Include EnTT
+# Add EnTT target
+#
+
+add_library(EnTT INTERFACE)
+
+target_include_directories(EnTT INTERFACE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+target_compile_definitions(EnTT
+    INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:DEBUG>
+    INTERFACE $<$<AND:$<CONFIG:Release>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:RELEASE>
+)
+
+if(ENTT_COMPILE_OPTIONS)
+    target_compile_options(EnTT
+        INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-O0 -g>
+        INTERFACE $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:Clang>>:-O2>
+        INTERFACE $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU>>:-O3>
+    )
+endif()
+
+if(USE_LIBCPP AND HAS_LIBCPP)
+    target_compile_options(EnTT BEFORE
+        INTERFACE -stdlib=libc++
+    )
+endif()
+
+target_compile_features(EnTT
+    INTERFACE cxx_std_14
+)
+
+#
+# Install EnTT
 #
 
-include_directories(${entt_SOURCE_DIR}/src)
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+    set(ENTT_INSTALL_CONFIGDIR cmake)
+else()
+    set(ENTT_INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/entt)
+endif()
+
+install(DIRECTORY src/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} 
+)
+
+install(TARGETS EnTT EXPORT EnTTTargets)
+
+export(EXPORT EnTTTargets
+  FILE ${CMAKE_CURRENT_BINARY_DIR}/EnTTTargets.cmake
+)
+
+install(EXPORT EnTTTargets
+    FILE EnTTTargets.cmake
+    DESTINATION ${ENTT_INSTALL_CONFIGDIR} 
+)
+
+# build tree package config file
+configure_file(cmake/in/EnTTBuildConfig.cmake.in EnTTConfig.cmake @ONLY)
+
+include(CMakePackageConfigHelpers)
+
+# install tree package config file
+configure_package_config_file(cmake/in/EnTTConfig.cmake.in
+    ${ENTT_INSTALL_CONFIGDIR}/EnTTConfig.cmake
+    INSTALL_DESTINATION ${ENTT_INSTALL_CONFIGDIR} 
+    PATH_VARS CMAKE_INSTALL_INCLUDEDIR
+    NO_CHECK_REQUIRED_COMPONENTS_MACRO
+)
+
+write_basic_package_version_file(
+    ${CMAKE_CURRENT_BINARY_DIR}/EnTTConfigVersion.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY AnyNewerVersion
+)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${ENTT_INSTALL_CONFIGDIR}/EnTTConfig.cmake
+    ${CMAKE_CURRENT_BINARY_DIR}/EnTTConfigVersion.cmake
+    DESTINATION ${ENTT_INSTALL_CONFIGDIR}
+)
+
+export(PACKAGE EnTT)
 
 #
 # Tests
@@ -105,10 +176,14 @@ endif()
 # Documentation
 #
 
-find_package(Doxygen 1.8)
+option(BUILD_DOCS "Enable building with documentation." OFF)
 
-if(DOXYGEN_FOUND)
-    add_subdirectory(docs)
+if(BUILD_DOCS)
+    find_package(Doxygen 1.8)
+
+    if(DOXYGEN_FOUND)
+        add_subdirectory(docs)
+    endif()
 endif()
 
 #

README.md

@@ -292,8 +292,8 @@ The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
 To build it:
 
     $ cd build
-    $ cmake ..
-    $ make docs
+    $ cmake .. -DBUILD_DOCS=ON
+    $ make
 
 The API reference will be created in HTML format within the directory
 `build/docs/html`. To navigate it with your favorite browser:
@@ -307,7 +307,8 @@ for the latest version.
 ## Tests
 
 To compile and run the tests, `EnTT` requires *googletest*.<br/>
-`cmake` will download and compile the library before to compile anything else.
+`cmake` will download and compile the library before compiling anything else.
+In order to build without tests set CMake option `BUILD_TESTING=OFF`.
 
 To build the most basic set of tests:
 

cmake/in/EnTTBuildConfig.cmake.in

@@ -0,0 +1,6 @@
+set(ENTT_VERSION "@PROJECT_VERSION@")
+set(ENTT_INCLUDE_DIRS "@CMAKE_CURRENT_SOURCE_DIR@/src")
+
+if(NOT CMAKE_VERSION VERSION_LESS "3.0")
+    include("${CMAKE_CURRENT_LIST_DIR}/EnTTTargets.cmake")
+endif()

cmake/in/EnTTConfig.cmake.in

@@ -0,0 +1,11 @@
+set(ENTT_VERSION "@PROJECT_VERSION@")
+
+@PACKAGE_INIT@
+
+set_and_check(ENTT_INCLUDE_DIRS "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@")
+
+if(NOT CMAKE_VERSION VERSION_LESS "3.0")
+    include("${CMAKE_CURRENT_LIST_DIR}/EnTTTargets.cmake")
+endif()
+
+check_required_components("@PROJECT_NAME@")

docs/CMakeLists.txt

@@ -2,8 +2,6 @@
 # Doxygen configuration (documentation)
 #
 
-set(TARGET_DOCS docs)
-
 set(DOXY_SOURCE_DIRECTORY ${entt_SOURCE_DIR}/src)
 set(DOXY_DOCS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 set(DOXY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
@@ -11,7 +9,7 @@ set(DOXY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 configure_file(doxy.in doxy.cfg @ONLY)
 
 add_custom_target(
-    ${TARGET_DOCS}
+    docs ALL
     COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxy.cfg
     WORKING_DIRECTORY ${entt_SOURCE_DIR}
     VERBATIM

test/CMakeLists.txt

@@ -4,9 +4,30 @@
 
 add_library(odr OBJECT odr.cpp)
 
+set_target_properties(odr PROPERTIES CXX_EXTENSIONS OFF)
+
+target_include_directories(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_INCLUDE_DIRECTORIES>
+)
+
+target_compile_definitions(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_DEFINITIONS>
+)
+
+target_compile_options(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_OPTIONS>
+    PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>
+)
+
+target_compile_features(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>
+)
+
 macro(ADD_ENTT_TEST TEST_NAME TEST_SOURCE)
     add_executable(${TEST_NAME} $<TARGET_OBJECTS:odr> ${TEST_SOURCE})
-    target_link_libraries(${TEST_NAME} PRIVATE gtest_main Threads::Threads)
+    target_link_libraries(${TEST_NAME} PRIVATE EnTT gtest_main Threads::Threads)
+    set_target_properties(${TEST_NAME} PROPERTIES CXX_EXTENSIONS OFF)
+    target_compile_options(${TEST_NAME} PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>)
     add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
 endmacro()