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

305 lines
11 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
CMake: add a note to packagers about GIT_COMMIT_HASH.
2016-06-28 09:49:37 +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:
Embed git commit hash in the "About" dialog. Also, remove usage of __DATE__ and __TIME__ to make the build fully deterministic. They are redundant once we have the commit hash, anyway.
2016-04-23 22:53:21 +00:00
include(GetGitCommitHash)
CMake: add a note to packagers about GIT_COMMIT_HASH.
2016-06-28 09:49:37 +00:00
# and instead uncomment the following, adding the complete git hash of the checkout you are using:
# set(GIT_COMMIT_HASH 0000000000000000000000000000000000000000)
Embed git commit hash in the "About" dialog. Also, remove usage of __DATE__ and __TIME__ to make the build fully deterministic. They are redundant once we have the commit hash, anyway.
2016-04-23 22:53:21 +00:00
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)
Embed git commit hash in the "About" dialog. Also, remove usage of __DATE__ and __TIME__ to make the build fully deterministic. They are redundant once we have the commit hash, anyway.
2016-04-23 22:53:21 +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
"Whether the graphical interface is enabled (command line interface always is)")
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)
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
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: 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_CXX_COMPILER_ID MATCHES "Clang")
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
message(FATAL_ERROR "Sanitizers are only available when using Clang/Clang++")
CMake: build with sanitizers if -DSANITIZE=TRUE passed.
2016-04-23 23:48:34 +00:00
endif()
set(SANITIZE_FLAGS "-O1 -fno-omit-frame-pointer -fno-optimize-sibling-calls")
CMake: disable unsigned overflow sanitizer check. This seems too aggressive for us; it breaks the hash function and I would prefer to not add tool-specific exclusions in the code.
2016-08-07 19:27:58 +00:00
set(SANITIZE_FLAGS "${SANITIZE_FLAGS} -fsanitize=address,integer")
set(SANITIZE_FLAGS "${SANITIZE_FLAGS} -fno-sanitize-recover=integer")
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
# We assume IEEE floats, which means DIV/0 is defined; but ubsan doesn't do so by default.
set(SANITIZE_FLAGS "${SANITIZE_FLAGS} -fno-sanitize=float-divide-by-zero")
CMake: disable unsigned overflow sanitizer check. This seems too aggressive for us; it breaks the hash function and I would prefer to not add tool-specific exclusions in the code.
2016-08-07 19:27:58 +00:00
set(SANITIZE_FLAGS "${SANITIZE_FLAGS} -fno-sanitize=unsigned-integer-overflow")
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()
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
# dependencies
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)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
if(WIN32)
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
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)
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
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)
Add Cairo (and, transitively, Pixman) dependencies.
2016-07-24 16:37:36 +00:00
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
if(ENABLE_GUI)
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 "")
set(ANGLE_ENABLE_OPENGL OFF CACHE INTERNAL "")
set(ANGLE_ENABLE_ESSL OFF CACHE INTERNAL "")
set(ANGLE_ENABLE_GLSL OFF CACHE INTERNAL "")
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()
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()
Implement OS X port.
2015-03-24 06:45:53 +00:00
elseif(APPLE)
OS X: fix typo in build system.
2016-06-19 19:46:51 +00:00
set(CMAKE_FIND_FRAMEWORK LAST)
OS X: find frameworks last. Before this commit, any available libpng or libfreetype would be picked, e.g. from Mono.framework. After, homebrew and MacPorts are prioritized.
2016-06-13 04:15:13 +00:00
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_package(ZLIB REQUIRED)
Implement OS X port.
2015-03-24 06:45:53 +00:00
find_package(PNG REQUIRED)
Add freetype dependency. We are going to use freetype instead of the old custom TTF parser, since the old parser has many annoying bugs when handling non-Latin fonts and fixing it is not really worth the time. On Windows, Freetype is built from a submodule. On Linux and OS X, Freetype is provided together with the desktop, though development files have to be installed separately.
2016-02-09 15:57:30 +00:00
find_package(Freetype REQUIRED)
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
CMake: Cairo is required for CLI, not just tests.
2016-12-04 19:05:51 +00:00
find_library(CAIRO_LIBRARIES cairo REQUIRED)
find_path(CAIRO_INCLUDE_DIRS cairo.h PATH_SUFFIXES cairo)
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
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
if(ENABLE_GUI)
find_package(OpenGL REQUIRED)
find_library(APPKIT_LIBRARY AppKit REQUIRED)
endif()
Implement OS X port.
2015-03-24 06:45:53 +00:00
else() # Linux and compatible systems
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
find_package(PkgConfig REQUIRED)
Unix: compatibility with platforms where backtrace() is not in libc. Also, don't depend on backtrace() when built as libslvs; it is not the responsbility of the library to use it.
2016-07-19 15:40:52 +00:00
find_package(Backtrace)
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
find_package(SpaceWare)
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_package(ZLIB REQUIRED)
find_package(PNG REQUIRED)
find_package(Freetype REQUIRED)
CMake: Cairo is required for CLI, not just tests.
2016-12-04 19:05:51 +00:00
pkg_check_modules(CAIRO REQUIRED cairo)
CMake: allow building the CLI without the GUI.
2017-01-02 22:02:37 +00:00
if(ENABLE_GUI)
find_package(OpenGL REQUIRED)
pkg_check_modules(FONTCONFIG REQUIRED fontconfig)
pkg_check_modules(JSONC REQUIRED json-c)
Except when using OpenGL ES 2, use OpenGL 3.2+ Core profile. This is primarily done to lower the GTK version dependency below GTK 3.22, since GTK 3.22 is unlikely to be widely availale any time soon.
2017-01-13 23:00:38 +00:00
pkg_check_modules(GTKMM REQUIRED gtkmm-3.0>=3.16 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()
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()
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: fix inclusion of manifest, to get back visual styles. This commit fixes four issues: * Instead of WRITE,APPEND, resource.rc was generated using WRITE,WRITE, which erased #include <windows.h> and prevented any symbolic definitions (like RT_MANIFEST) from working. This silently included them using a string type instead, which did nothing. * WINVER is bumped to Win7, since that's what we target now. * Index of RT_MANIFEST is changed to 2, since that's what it has to be when ISOLATION_AWARE_ENABLED is defined. * Platform is not restricted to X86 in manifest, since there is no point in doing so.
2016-12-04 20:16:05 +00:00
-DWINVER=0x0601
-D_WIN32_WINNT=0x0601
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")
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 "-Wall -Wextra -Wno-unused-parameter")
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()
Add a CMake buildsystem. Additionally, update build tools so that no stdio redirection is necessary.
2015-03-29 00:33:46 +00:00
# components
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()