zcy
/
solvespace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
solvespace/CMakeLists.txt

343 lines
12 KiB
CMake
Raw Normal View History

Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
# cmake configuration
CMake: reject in-tree builds. We do not support clobbering the source tree with build products, nor recommend this in any documentation, and this already leads to weird bugs with the resource system. Show an explicit error in this case to avoid confusion.
2016-11-03 07:24:12 +00:00
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
message(FATAL_ERROR
"In-tree builds are not supported; please perform an out-of-tree build:\n"
" rm -rf CMakeCache.txt CMakeFiles/\n"
" mkdir build && cd build && cmake ..")
endif()
CMake: update required version to 3.2. We use continue(), which was introduced in 3.2.
2017-11-06 05:40:49 +00:00
cmake_minimum_required(VERSION 3.2.0 FATAL_ERROR)
cmake_policy(VERSION 3.2.0)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
"${CMAKE_SOURCE_DIR}/cmake/")
Require cmake 3.1.0 and C++11. We plan to use C++11 features in the future. Moreover, recent gtkmm has a hard requirement on C++11.
2015-12-25 15:10:01 +00:00
set(CMAKE_CXX_STANDARD 11)
set(CMAKE_CXX_STANDARD_REQUIRED YES)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
# for /MT on MSVC
set(CMAKE_USER_MAKE_RULES_OVERRIDE
"${CMAKE_SOURCE_DIR}/cmake/c_flag_overrides.cmake")
set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX
"${CMAKE_SOURCE_DIR}/cmake/cxx_flag_overrides.cmake")
# project
Revert "CMake: replace GetGitCommitHash with .gitattributes and $Id$." This reverts commit c962357b359b412089778fa27b03fc0967666811. $Id$ inserts the SHA1 of the *blob*, not the *commit*, and is therefore completely worthless.
2019-05-01 08:32:30 +00:00
# NOTE TO PACKAGERS: The embedded git commit hash is critical for rapid bug triage when the builds
# can come from a variety of sources. If you are mirroring the sources or otherwise build when
# the .git directory is not present, please comment the following line:
include(GetGitCommitHash)
# and instead uncomment the following, adding the complete git hash of the checkout you are using:
# set(GIT_COMMIT_HASH 0000000000000000000000000000000000000000)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
project(solvespace)
Bump version to 3.0.
2016-05-20 14:50:00 +00:00
set(solvespace_VERSION_MAJOR 3)
set(solvespace_VERSION_MINOR 0)
Revert "CMake: replace GetGitCommitHash with .gitattributes and $Id$." This reverts commit c962357b359b412089778fa27b03fc0967666811. $Id$ inserts the SHA1 of the *blob*, not the *commit*, and is therefore completely worthless.
2019-05-01 08:32:30 +00:00
string(SUBSTRING "${GIT_COMMIT_HASH}" 0 8 solvespace_GIT_HASH)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
set(ENABLE_GUI ON CACHE BOOL
CMake: add an ENABLE_CLI flag.
2018-07-18 11:49:06 +00:00
"Whether the graphical interface is enabled")
set(ENABLE_CLI ON CACHE BOOL
"Whether the command line interface is enabled")
CMake: finish Clang sanitizer support. This makes ENABLE_SANITIZERS a proper cached variable, removes some spurious failures and configures asan/ubsan to die on an error.
2016-08-01 05:19:21 +00:00
set(ENABLE_TESTS ON CACHE BOOL
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
"Whether the test suite will be built and run")
CMake: finish Clang sanitizer support. This makes ENABLE_SANITIZERS a proper cached variable, removes some spurious failures and configures asan/ubsan to die on an error.
2016-08-01 05:19:21 +00:00
set(ENABLE_COVERAGE OFF CACHE BOOL
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
"Whether code coverage information will be collected")
CMake: finish Clang sanitizer support. This makes ENABLE_SANITIZERS a proper cached variable, removes some spurious failures and configures asan/ubsan to die on an error.
2016-08-01 05:19:21 +00:00
set(ENABLE_SANITIZERS OFF CACHE BOOL
"Whether to enable Clang's AddressSanitizer and UndefinedBehaviorSanitizer")
Add a simple harness for automated, headless testing. This commit alters the build system substantially; it adds another platform, `headless`, that provides stubs in place of all GUI functions, and provides a library `solvespace_headless` alongside the main executable. To cut down build times, only the few files that have #if defined(HEADLESS) are built twice for the executable and the library; the rest is grouped into a new `solvespace_cad` library. It is not usable on its own and just serves for grouping. This commit also gates the tests behind a -DENABLE_TESTS=ON CMake option, ON by default (but suggested as OFF in the README so that people don't ever have to install cairo to build the executable.) The tests introduced in this commit are (so far) rudimentary, although functional, and they serve as a stepping point towards introducing coverage analysis.
2016-07-25 19:37:48 +00:00
Change mentions of OpenGL 2 to OpenGL 3. We ended up in a confusing state where OpenGL 2 (like in "gl2") actually refers to OpenGL ES 2, which roughly corresponds to OpenGL 3. Rectify that.
2017-04-06 07:11:23 +00:00
set(OPENGL 3 CACHE STRING "OpenGL version to use (one of: 1 3)")
Add OpenGL 2 support on Windows using ANGLE. This commit performs two main changes: * Alters the shaders to use only strictly conformant GLSL 2.0. * Alters the Windows UI to use ANGLE via GL ES 2.0 and EGL 1.4. This commit also drops official support for Windows XP, since ANGLE requires a non-XP toolset to build. It is still possible to build SolveSpace for Windows XP using: cmake -T v120_xp -DOPENGL=1
2016-11-16 02:22:10 +00:00
Use the same code for loading resources in all executables. All of our executables need resources; e.g. the vector font is a resource and it is necessary for generation. Before this commit, the GUI executable loaded the resources in a nice way, and everything else did it in a very ad-hoc, fragile way. After this commit, all executables are placed in <build>/bin and follow the same algorithm: * On Windows, resources are compiled and linked into every executable. * On Linux, resources are copied into <build>/res (which is tried first) and <prefix>/share/solvespace (which is tried second). * On macOS, resources are copied into <build>/res (which is tried first) and <build>/bin/solvespace.app/Contents/Resources (which is tried second). In practice this means that we can add as many executables as we want without duplicating lots of code. In addition, on macOS, we can place supplementary executables into the bundle, and they can use resources from the bundle transparently.
2016-11-28 04:16:18 +00:00
set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin)
macOS: fix CMake Xcode generator. This is done by setting `CMAKE_RUNTIME_OUTPUT_DIRECTORY` to `$<1:${CMAKE_BINARY_DIR}/bin>`
2019-11-23 13:20:45 +00:00
if("${CMAKE_GENERATOR}" STREQUAL "Xcode")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY $<1:${CMAKE_BINARY_DIR}/bin>)
endif()
Use the same code for loading resources in all executables. All of our executables need resources; e.g. the vector font is a resource and it is necessary for generation. Before this commit, the GUI executable loaded the resources in a nice way, and everything else did it in a very ad-hoc, fragile way. After this commit, all executables are placed in <build>/bin and follow the same algorithm: * On Windows, resources are compiled and linked into every executable. * On Linux, resources are copied into <build>/res (which is tried first) and <prefix>/share/solvespace (which is tried second). * On macOS, resources are copied into <build>/res (which is tried first) and <build>/bin/solvespace.app/Contents/Resources (which is tried second). In practice this means that we can add as many executables as we want without duplicating lots of code. In addition, on macOS, we can place supplementary executables into the bundle, and they can use resources from the bundle transparently.
2016-11-28 04:16:18 +00:00
CMake: make code coverage work with Clang. Clang uses a slightly different .gcno/.gcda format than GCC, and it is necessary to point lcov to `llvm-cov gcov` instead of `gcov`.
2016-08-01 05:33:09 +00:00
if(NOT CMAKE_C_COMPILER_ID STREQUAL CMAKE_CXX_COMPILER_ID)
message(FATAL_ERROR "C and C++ compilers should be supplied by the same vendor")
endif()
CMake: correctly use if(STREQUAL). If an operand is a string, it should be quoted to prevent expansion. This doesn't matter with "GNU", but does with "MSVC" (which expands to "YES").
2016-07-31 22:51:50 +00:00
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
CMake: require GCC 5.0+.
2016-05-18 16:44:03 +00:00
if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
# GCC 4.8/4.9 ship with broken but present <regex>. meh.
message(FATAL_ERROR "GCC 5.0+ is required")
endif()
endif()
CMake: do not leak solvespace-specific compiler flags. Before this commit, our warning flags and definitions were leaking into the vendored dependencies.
2016-07-24 20:21:53 +00:00
# common compiler flags
Enable and mollify -Wunused-variable. In my (whitequark's) experience this warning tends to expose copy-paste errors with a high SNR, so making a few fragments slightly less symmetric is worth it. Also mollify -Wlogical-op-parentheses while we're at it.
2016-02-14 00:36:54 +00:00
On GNU-compatible compilers, avoid embedding paths into binaries. This is helpful for reproducible builds, and also makes it easier to debug binaries built on another system.
2019-11-23 16:33:47 +00:00
if((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND NOT (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.0)) OR
CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(DEBUG_FLAGS "-fdebug-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=.")
set(DEBUG_FLAGS "${DEBUG_FLAGS} -ffile-prefix-map=${CMAKE_CURRENT_SOURCE_DIR}=.")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${DEBUG_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${DEBUG_FLAGS}")
endif()
Add support for cross-compiling from Linux. As a side effect, zlib and libpng are now git submodules, based on their respective official git repositories. This is necessary, because MinGW has a different ABI and it cannot use the prebuilt binaries built by MSVC. The submodules are also used for Windows, for several reasons: * to allow 64-bit builds; * to allow using newer MSVC, which doesn't like the prebuilt libraries; * to keep the libraries updated.
2015-07-05 05:45:39 +00:00
if(MINGW)
Always build in C++11 mode on GCC and Clang. This will weed out compilers that are too old to build our code (among others, recent gtkmm and glibmm have a hard dependency on C++11, not even C++0x) and also properly communicate our wish to GCC (Clang defaults to C++11 these days).
2016-02-15 19:58:03 +00:00
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -static-libgcc")
Add support for cross-compiling from Linux. As a side effect, zlib and libpng are now git submodules, based on their respective official git repositories. This is necessary, because MinGW has a different ABI and it cannot use the prebuilt binaries built by MSVC. The submodules are also used for Windows, for several reasons: * to allow 64-bit builds; * to allow using newer MSVC, which doesn't like the prebuilt libraries; * to keep the libraries updated.
2015-07-05 05:45:39 +00:00
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libgcc -static-libstdc++")
Add OpenGL 2 support on Windows using ANGLE. This commit performs two main changes: * Alters the shaders to use only strictly conformant GLSL 2.0. * Alters the Windows UI to use ANGLE via GL ES 2.0 and EGL 1.4. This commit also drops official support for Windows XP, since ANGLE requires a non-XP toolset to build. It is still possible to build SolveSpace for Windows XP using: cmake -T v120_xp -DOPENGL=1
2016-11-16 02:22:10 +00:00
if(TRIPLE STREQUAL "i686-w64-mingw32")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse2")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse2")
endif()
Add support for cross-compiling from Linux. As a side effect, zlib and libpng are now git submodules, based on their respective official git repositories. This is necessary, because MinGW has a different ABI and it cannot use the prebuilt binaries built by MSVC. The submodules are also used for Windows, for several reasons: * to allow 64-bit builds; * to allow using newer MSVC, which doesn't like the prebuilt libraries; * to keep the libraries updated.
2015-07-05 05:45:39 +00:00
endif()
CMake: do not leak solvespace-specific compiler flags. Before this commit, our warning flags and definitions were leaking into the vendored dependencies.
2016-07-24 20:21:53 +00:00
if(APPLE OR CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
Require cmake 3.1.0 and C++11. We plan to use C++11 features in the future. Moreover, recent gtkmm has a hard requirement on C++11.
2015-12-25 15:10:01 +00:00
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
endif()
CMake: do not leak solvespace-specific compiler flags. Before this commit, our warning flags and definitions were leaking into the vendored dependencies.
2016-07-24 20:21:53 +00:00
if(CMAKE_SYSTEM_NAME STREQUAL "Linux" OR CMAKE_SYSTEM_NAME STREQUAL "FreeBSD")
Allow building on FreeBSD.
2015-12-25 16:06:59 +00:00
set(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed ${CMAKE_EXE_LINKER_FLAGS}")
endif()
CMake: fix typo.
2016-08-06 12:16:03 +00:00
if(ENABLE_SANITIZERS)
CMake: support sanitizers on gcc builds, too. This also fixes Travis Linux builds.
2018-07-11 03:19:08 +00:00
list(APPEND SANITIZERS address alignment bounds)
list(APPEND SANITIZERS shift signed-integer-overflow integer-divide-by-zero)
list(APPEND SANITIZERS null bool enum)
list(APPEND SANITIZERS return)
string(REPLACE ";" "," SANITIZERS "${SANITIZERS}")
set(SANITIZE_FLAGS "-O1 -fsanitize=${SANITIZERS} -fno-sanitize-recover=address,undefined")
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
set(SANITIZE_FLAGS "${SANITIZE_FLAGS} -fno-omit-frame-pointer -fno-optimize-sibling-calls")
elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
set(SANITIZE_FLAGS "${SANITIZE_FLAGS} -fuse-ld=gold")
else()
message(FATAL_ERROR "Sanitizers are only available when using GCC or Clang")
CMake: build with sanitizers if -DSANITIZE=TRUE passed.
2016-04-23 23:48:34 +00:00
endif()
CMake: finish Clang sanitizer support. This makes ENABLE_SANITIZERS a proper cached variable, removes some spurious failures and configures asan/ubsan to die on an error.
2016-08-01 05:19:21 +00:00
CMake: build with sanitizers if -DSANITIZE=TRUE passed.
2016-04-23 23:48:34 +00:00
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZE_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZE_FLAGS}")
endif()
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
# common dependencies
if(APPLE)
set(CMAKE_FIND_FRAMEWORK LAST)
endif()
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
DXF: initial libdxfrw import. We had to fork libdxfrw since the upstream doesn't have a git repository, a CMake buildsystem, and is quite buggy. libdxfrw is also used in LibreCAD, but they just vendored their version.
2015-11-03 19:05:20 +00:00
message(STATUS "Using in-tree libdxfrw")
add_subdirectory(extlib/libdxfrw)
Implement Q3DO export. We plan to use flatbuffers in the future for the next generation of the .slvs file format, so flatbuffers are built unconditionally; and the Q3DO exporter itself is tiny.
2019-02-25 00:46:57 +00:00
message(STATUS "Using in-tree flatbuffers")
set(FLATBUFFERS_BUILD_FLATLIB ON CACHE BOOL "")
set(FLATBUFFERS_BUILD_FLATC ON CACHE BOOL "")
set(FLATBUFFERS_BUILD_FLATHASH OFF CACHE BOOL "")
set(FLATBUFFERS_BUILD_TESTS OFF CACHE BOOL "")
add_subdirectory(extlib/flatbuffers EXCLUDE_FROM_ALL)
message(STATUS "Using in-tree q3d")
add_subdirectory(extlib/q3d)
set(Q3D_INCLUDE_DIR ${CMAKE_BINARY_DIR}/extlib/q3d)
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
if(WIN32 OR APPLE)
# On Win32 and macOS we use vendored packages, since there is little to no benefit
# to trying to find system versions. In particular, trying to link to libraries from
# Homebrew or macOS system libraries into the .app file is highly likely to result
# in incompatibilities after upgrades.
CMake: refactor inclusion of external libraries. This commit makes common external packages always be included through find_package to eliminate differences in variables set, wraps find_package for vendored libraries on Windows to factor out common code, and removes miscellaneous useless code elsewhere in dependency handling. This also fixes a problem where pkg-config would pick up `build` libraries instead of `host` when cross-compiling.
2016-07-24 13:55:33 +00:00
include(FindVendoredPackage)
Add Cairo (and, transitively, Pixman) dependencies.
2016-07-24 16:37:36 +00:00
include(AddVendoredSubdirectory)
CMake: refactor inclusion of external libraries. This commit makes common external packages always be included through find_package to eliminate differences in variables set, wraps find_package for vendored libraries on Windows to factor out common code, and removes miscellaneous useless code elsewhere in dependency handling. This also fixes a problem where pkg-config would pick up `build` libraries instead of `host` when cross-compiling.
2016-07-24 13:55:33 +00:00
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
if(APPLE)
set(FORCE_VENDORED_ZLIB ON)
set(FORCE_VENDORED_PNG ON)
set(FORCE_VENDORED_Freetype ON)
endif()
CMake: refactor inclusion of external libraries. This commit makes common external packages always be included through find_package to eliminate differences in variables set, wraps find_package for vendored libraries on Windows to factor out common code, and removes miscellaneous useless code elsewhere in dependency handling. This also fixes a problem where pkg-config would pick up `build` libraries instead of `host` when cross-compiling.
2016-07-24 13:55:33 +00:00
find_vendored_package(ZLIB zlib
ZLIB_LIBRARY zlibstatic
ZLIB_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/extlib/zlib)
list(APPEND ZLIB_INCLUDE_DIR ${CMAKE_BINARY_DIR}/extlib/zlib)
find_vendored_package(PNG libpng
SKIP_INSTALL_ALL ON
Update zlib, libpng and Freetype submodules to latest versions. In particular this fixes an issue with the Freetype build system where re-running CMake would rebuild it from scratch every time.
2017-01-03 01:25:46 +00:00
PNG_LIBRARY png_static
CMake: refactor inclusion of external libraries. This commit makes common external packages always be included through find_package to eliminate differences in variables set, wraps find_package for vendored libraries on Windows to factor out common code, and removes miscellaneous useless code elsewhere in dependency handling. This also fixes a problem where pkg-config would pick up `build` libraries instead of `host` when cross-compiling.
2016-07-24 13:55:33 +00:00
PNG_PNG_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/extlib/libpng)
list(APPEND PNG_PNG_INCLUDE_DIR ${CMAKE_BINARY_DIR}/extlib/libpng)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
find_vendored_package(Freetype freetype
WITH_ZLIB OFF
WITH_BZip2 OFF
WITH_PNG OFF
WITH_HarfBuzz OFF
FREETYPE_LIBRARY freetype
FREETYPE_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/extlib/freetype/include)
CMake: Cairo is required for CLI, not just tests.
2016-12-04 19:05:51 +00:00
message(STATUS "Using in-tree pixman")
add_vendored_subdirectory(extlib/pixman)
set(PIXMAN_FOUND YES)
set(PIXMAN_LIBRARY pixman)
set(PIXMAN_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/extlib/pixman/pixman)
list(APPEND PIXMAN_INCLUDE_DIRS ${CMAKE_BINARY_DIR}/extlib/pixman/pixman)
message(STATUS "Using in-tree cairo")
add_vendored_subdirectory(extlib/cairo)
set(CAIRO_FOUND YES)
set(CAIRO_LIBRARIES cairo)
set(CAIRO_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/extlib/cairo/src)
list(APPEND CAIRO_INCLUDE_DIRS ${CMAKE_BINARY_DIR}/extlib/cairo/src)
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
else()
# On Linux and BSDs we're a good citizen and link to system libraries.
find_package(Backtrace)
Add a platform abstraction for 6-DOF input devices. This commit mostly just moves code around.
2018-07-18 00:48:49 +00:00
find_package(PkgConfig REQUIRED)
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
find_package(ZLIB REQUIRED)
find_package(PNG REQUIRED)
find_package(Freetype REQUIRED)
pkg_check_modules(CAIRO REQUIRED cairo)
endif()
# GUI dependencies
Add Cairo (and, transitively, Pixman) dependencies.
2016-07-24 16:37:36 +00:00
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
if(ENABLE_GUI)
if(WIN32)
Change mentions of OpenGL 2 to OpenGL 3. We ended up in a confusing state where OpenGL 2 (like in "gl2") actually refers to OpenGL ES 2, which roughly corresponds to OpenGL 3. Rectify that.
2017-04-06 07:11:23 +00:00
if(OPENGL STREQUAL "3")
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
message(STATUS "Using in-tree ANGLE")
set(ANGLE_STATIC ON CACHE INTERNAL "")
set(ANGLE_ENABLE_D3D9 ON CACHE INTERNAL "")
set(ANGLE_ENABLE_D3D11 ON CACHE INTERNAL "")
Win32: use native OpenGL drivers, if available. After this commit, if the target system does have modern OpenGL drivers installed, ANGLE is configured to use them, bypassing most translation (shaders still have to be translated from ESSL to GLSL). If there are no OpenGL drivers, such as if the graphics drivers were installed via Windows Update, DirectX translation is still used. This results in a very noticeable startup delay and minor performance degradation. In addition it is no longer necessary to build with -DOPENGL=1 to be able to run the binary in wine; everything works out of the box. Before, wine's incomplete HLSL translator would crash. This change required renaming the variable `texture` in shaders, since it shadows the Core GLSL function with the same name, and ANGLE translates texture2D() calls to texture() calls.
2019-05-23 10:58:31 +00:00
set(ANGLE_ENABLE_OPENGL ON CACHE INTERNAL "")
set(ANGLE_ENABLE_ESSL ON CACHE INTERNAL "")
set(ANGLE_ENABLE_GLSL ON CACHE INTERNAL "")
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
set(ANGLE_ENABLE_HLSL ON CACHE INTERNAL "")
add_vendored_subdirectory(extlib/angle)
set(OPENGL_LIBRARIES EGL GLESv2)
set(OPENGL_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/extlib/angle/include)
else()
find_package(OpenGL REQUIRED)
endif()
Win32: fix compatibility with MSVC x64 builds.
2017-01-03 00:52:24 +00:00
if(MSVC AND ${CMAKE_SIZEOF_VOID_P} EQUAL 4)
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
message(STATUS "Using prebuilt SpaceWare")
set(SPACEWARE_FOUND TRUE)
set(SPACEWARE_INCLUDE_DIR
"${CMAKE_SOURCE_DIR}/extlib/si")
set(SPACEWARE_LIBRARIES
"${CMAKE_SOURCE_DIR}/extlib/si/siapp.lib")
endif()
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
elseif(APPLE)
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
find_package(OpenGL REQUIRED)
find_library(APPKIT_LIBRARY AppKit REQUIRED)
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
else()
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
find_package(OpenGL REQUIRED)
Add a platform abstraction for 6-DOF input devices. This commit mostly just moves code around.
2018-07-18 00:48:49 +00:00
find_package(SpaceWare)
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
pkg_check_modules(FONTCONFIG REQUIRED fontconfig)
pkg_check_modules(JSONC REQUIRED json-c)
CMake: use correct gtkmm version constraint. Many GL APIs appeared in GTK in version 3.16, but in gtkmm only in version 3.18.
2018-07-12 12:19:59 +00:00
pkg_check_modules(GTKMM REQUIRED gtkmm-3.0>=3.18 pangomm-1.4 x11)
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
endif()
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
endif()
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
# code coverage
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
if(ENABLE_COVERAGE)
CMake: make code coverage work with Clang. Clang uses a slightly different .gcno/.gcda format than GCC, and it is necessary to point lcov to `llvm-cov gcov` instead of `gcov`.
2016-08-01 05:33:09 +00:00
if(CMAKE_CXX_COMPILER_ID STREQUAL GNU)
find_program(GCOV gcov)
elseif(CMAKE_CXX_COMPILER_ID MATCHES Clang)
find_program(LLVM_COV llvm-cov)
if(LLVM_COV)
set(GCOV ${CMAKE_CURRENT_BINARY_DIR}/llvm-gcov.sh)
file(WRITE ${GCOV} "#!/bin/sh -e\n${LLVM_COV} gcov $*")
execute_process(COMMAND chmod +x ${GCOV})
endif()
endif()
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
find_program(LCOV lcov)
find_program(GENHTML genhtml)
CMake: make code coverage work with Clang. Clang uses a slightly different .gcno/.gcda format than GCC, and it is necessary to point lcov to `llvm-cov gcov` instead of `gcov`.
2016-08-01 05:33:09 +00:00
if(NOT GCOV OR NOT LCOV OR NOT GENHTML)
message(FATAL_ERROR "gcov/llvm-cov and lcov are required for producing coverage reports")
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
endif()
endif()
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
# translations
Implement a gettext .po file parser.
2017-01-04 15:39:27 +00:00
find_program(XGETTEXT xgettext)
find_program(MSGINIT msginit)
find_program(MSGMERGE msgmerge)
if(XGETTEXT AND MSGINIT AND MSGMERGE)
set(HAVE_GETTEXT TRUE)
else()
message(WARNING "Gettext not found, translations will not be updated")
set(HAVE_GETTEXT FALSE)
endif()
CMake: do not leak solvespace-specific compiler flags. Before this commit, our warning flags and definitions were leaking into the vendored dependencies.
2016-07-24 20:21:53 +00:00
# solvespace-only compiler flags
if(WIN32)
add_definitions(
-D_CRT_SECURE_NO_DEPRECATE
-D_CRT_SECURE_NO_WARNINGS
-D_SCL_SECURE_NO_WARNINGS
Win32: Restore Windows XP Compatibility By setting WINVER=0x0501 (Windows XP) in CMakeLists.txt and adding a few missing defines in guiwin.cpp and configuring OPENGL=1 in CMake Solvespace (3.0~25b6eba1) compiles and works perfectly on Windows XP. Tested with MinGW GCC-6.3.0-1
2019-05-23 08:01:26 +00:00
-DWINVER=0x0501
-D_WIN32_WINNT=0x0501
CMake: do not leak solvespace-specific compiler flags. Before this commit, our warning flags and definitions were leaking into the vendored dependencies.
2016-07-24 20:21:53 +00:00
-D_WIN32_IE=_WIN32_WINNT
-DISOLATION_AWARE_ENABLED
-DWIN32
-DWIN32_LEAN_AND_MEAN
-DUNICODE
-D_UNICODE
-DNOMINMAX
-D_USE_MATH_DEFINES)
endif()
if(MSVC)
# Many versions of MSVC do not have the (C99) inline keyword, instead
# they have their own __inline; this breaks `static inline` functions.
# We do not want to care and so we fix this with a definition.
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /Dinline=__inline")
# Same for the (C99) __func__ special variable; we use it only in C++ code.
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D__func__=__FUNCTION__")
# We rely on these /we flags. They correspond to the GNU-style flags below as
# follows: /w4062=-Wswitch
set(WARNING_FLAGS "${WARNING_FLAGS} /we4062")
endif()
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
Win32: Restore Windows XP Compatibility By setting WINVER=0x0501 (Windows XP) in CMakeLists.txt and adding a few missing defines in guiwin.cpp and configuring OPENGL=1 in CMake Solvespace (3.0~25b6eba1) compiles and works perfectly on Windows XP. Tested with MinGW GCC-6.3.0-1
2019-05-23 08:01:26 +00:00
set(WARNING_FLAGS "-Wall -Wextra -Wno-unused-parameter -Wno-missing-field-initializers")
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
CMake: do not leak solvespace-specific compiler flags. Before this commit, our warning flags and definitions were leaking into the vendored dependencies.
2016-07-24 20:21:53 +00:00
set(WARNING_FLAGS "${WARNING_FLAGS} -Wfloat-conversion")
endif()
# We rely on these -Werror flags.
set(WARNING_FLAGS "${WARNING_FLAGS} -Werror=switch")
endif()
Add a simple harness for automated, headless testing. This commit alters the build system substantially; it adds another platform, `headless`, that provides stubs in place of all GUI functions, and provides a library `solvespace_headless` alongside the main executable. To cut down build times, only the few files that have #if defined(HEADLESS) are built twice for the executable and the library; the rest is grouped into a new `solvespace_cad` library. It is not usable on its own and just serves for grouping. This commit also gates the tests behind a -DENABLE_TESTS=ON CMake option, ON by default (but suggested as OFF in the README so that people don't ever have to install cairo to build the executable.) The tests introduced in this commit are (so far) rudimentary, although functional, and they serve as a stepping point towards introducing coverage analysis.
2016-07-25 19:37:48 +00:00
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${WARNING_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${WARNING_FLAGS}")
CMake: do not leak solvespace-specific compiler flags. Before this commit, our warning flags and definitions were leaking into the vendored dependencies.
2016-07-24 20:21:53 +00:00
if(WIN32)
set(CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS} -l0")
endif()
Add statement/condition coverage measurement for the test suite. We're using gcov+lcov, since these tools appear to be the only usable ones that use the SC/CC metric; and measuring just the line coverage would be practically criminal negligence. gcov only works with GCC and Clang, and MSVC's own coverage measurement tools are not up to the task; so MSVC is out of luck.
2016-07-25 22:09:58 +00:00
if(ENABLE_COVERAGE)
if(NOT (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR
CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
message(FATAL_ERROR "Code coverage is only available on GCC and Clang")
endif()
if(NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
message(FATAL_ERROR "Code coverage produces reliable results only on Debug builds")
endif()
# With -fexceptions, every call becomes a branch. While technically accurate,
# this is not useful for us.
set(COVERAGE_FLAGS -fno-exceptions --coverage)
set(COVERAGE_LIBRARY --coverage)
endif()
macOS: bundle and statically link external dependencies. This fixes numerous linking issues where updated system libraries on macOS cause errors on startup in newer OS versions.
2018-07-12 11:10:25 +00:00
# application components
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
Implement a resource system. Currently, icons, fonts, etc are converted to C structures at compile time and are hardcoded to the binary. This presents several problems: * Cross-compilation is complicated. Right now, it is necessary to be able to run executables for the target platform; this happens to work with wine-binfmt installed, but is rather ugly. * Icons can only have one resolution. On OS X, modern software is expected to take advantage of high-DPI ("Retina") screens and use so-called @2x assets when ran in high-DPI mode. * Localization is complicated. Win32 and OS X provide built-in support for loading the resource appropriate for the user's locale. * Embedding strings can only be done as raw strings, using C++'s R"(...)" literals. This precludes embedding sizable strings, e.g. JavaScript libraries as used in Three.js export, and makes git history less useful. Not embedding the libraries means we have to rely on external CDNs, which requires an Internet connection and adds a glaring point of failure. * Linux distribution guidelines are violated. All architecture- independent data, especially large data such as fonts, is expected to be in /usr/share, not in the binary. * Customization is impossible without recompilation. Minor modifications like adding a few missing vector font characters or adjusting localization require a complete development environment, which is unreasonable to expect from users of a mechanical CAD. As such, this commit adds a resource system that bundles (and sometimes builds) resources with the executable. Where they go is platform-dependent: * on Win32: into resources of the executable, which allows us to keep distributing one file; * on OS X: into the app bundle; * on other *nix: into /usr/share/solvespace/ or ../res/ (relative to the executable path), the latter allowing us to run freshly built executables without installation. It also subsides the platform-specific resources that are in src/. The resource system is not yet used for anything; this will be added in later commits.
2016-04-21 15:54:18 +00:00
add_subdirectory(res)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
add_subdirectory(src)
add_subdirectory(exposed)
Add a simple harness for automated, headless testing. This commit alters the build system substantially; it adds another platform, `headless`, that provides stubs in place of all GUI functions, and provides a library `solvespace_headless` alongside the main executable. To cut down build times, only the few files that have #if defined(HEADLESS) are built twice for the executable and the library; the rest is grouped into a new `solvespace_cad` library. It is not usable on its own and just serves for grouping. This commit also gates the tests behind a -DENABLE_TESTS=ON CMake option, ON by default (but suggested as OFF in the README so that people don't ever have to install cairo to build the executable.) The tests introduced in this commit are (so far) rudimentary, although functional, and they serve as a stepping point towards introducing coverage analysis.
2016-07-25 19:37:48 +00:00
if(ENABLE_TESTS)
add_subdirectory(test)
endif()
Add a simple benchmarking harness.
2016-11-18 13:55:24 +00:00
if(CMAKE_BUILD_TYPE STREQUAL "Release" OR CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo")
add_subdirectory(bench)
else()
message(STATUS "Benchmarking disabled in debug builds.")
endif()