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

300 lines
10 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()
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
cmake_minimum_required(VERSION 3.1.0 FATAL_ERROR)
cmake_policy(VERSION 3.1.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: 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
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
set(OPENGL 2 CACHE STRING "OpenGL version to use (one of: 1 2)")
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
if(NOT WIN32 AND NOT APPLE)
Remove FLTK port. It provides no value over the native GTK and Cocoa ports.
2015-03-24 23:38:06 +00:00
set(GUI gtk2 CACHE STRING "GUI toolkit to use (one of: gtk2 gtk3)")
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
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
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
PNG_LIBRARY png16_static
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
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(OPENGL STREQUAL "2")
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)
Fix Windows build with -DOPENGL=1. This is mostly useful when testing the Windows functionality on Linux, as wine is currently unable to compile the shaders that ANGLE outputs.
2016-11-19 04:27:25 +00:00
else()
find_package(OpenGL REQUIRED)
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
endif()
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
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(NOT MINGW)
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()
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)
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
find_package(OpenGL 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
Implement OS X port.
2015-03-24 06:45:53 +00:00
find_library(APPKIT_LIBRARY AppKit REQUIRED)
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)
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
find_package(OpenGL 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
pkg_check_modules(CAIRO REQUIRED 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
Remove FLTK port. It provides no value over the native GTK and Cocoa ports.
2015-03-24 23:38:06 +00:00
pkg_check_modules(FONTCONFIG REQUIRED fontconfig)
pkg_check_modules(JSONC REQUIRED json-c)
if(GUI STREQUAL "gtk3")
set(HAVE_GTK3 TRUE)
pkg_check_modules(GTKMM REQUIRED gtkmm-3.0 pangomm-1.4 x11)
elseif(GUI STREQUAL "gtk2")
set(HAVE_GTK2 TRUE)
pkg_check_modules(GTKMM REQUIRED gtkmm-2.4 pangomm-1.4 x11)
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
else()
message(FATAL_ERROR "GUI unrecognized: ${GUI}")
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()
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
-D_WIN32_WINNT=0x500
-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()