mirror/glfw
1
0
Fork 0
mirror of https://github.com/glfw/glfw.git synced 2024-11-26 06:14:35 +00:00
Code Issues Packages Projects Releases Wiki Activity
b55a517ae0
glfw/src/CMakeLists.txt

398 lines
15 KiB
CMake
Raw Normal View History

Fixed various VC++ warnings.
2012-09-12 22:05:54 +00:00
Add override variable for CMake library type This adds the GLFW_LIBRARY_TYPE CMake cache variable, which allows users and higher-level projects to set what type of library GLFW is built as. When not empty, this value overrides the standard BUILD_SHARED_LIBS option for GLFW while still allowing it to control the type of other libraries in a larger project. This also allows building GLFW as an object library without adding dummy source files (as required by Xcode) or producing unused library binaries. Projects using CMake 3.12 or later can link the resulting GLFW object library normally using target_link_libraries. Fixes #279. Related to #1307. Closes #1497. Closes #1574. Closes #1928.
2021-07-06 21:12:05 +00:00
add_library(glfw ${GLFW_LIBRARY_TYPE}
"${GLFW_SOURCE_DIR}/include/GLFW/glfw3.h"
Replace CMake list variables with target_sources
2019-12-15 06:37:26 +00:00
"${GLFW_SOURCE_DIR}/include/GLFW/glfw3native.h"
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
internal.h platform.h mappings.h
context.c init.c input.c monitor.c platform.c vulkan.c window.c
egl_context.c osmesa_context.c null_platform.h null_joystick.h
null_init.c null_monitor.c null_window.c null_joystick.c)
# The time, thread and module code is shared between all backends on a given OS,
# including the null backend, which still needs those bits to be functional
if (APPLE)
target_sources(glfw PRIVATE cocoa_time.h cocoa_time.c posix_thread.h
posix_module.c posix_thread.c)
elseif (WIN32)
target_sources(glfw PRIVATE win32_time.h win32_thread.h win32_module.c
win32_time.c win32_thread.c)
else()
target_sources(glfw PRIVATE posix_time.h posix_thread.h posix_module.c
posix_time.c posix_thread.c)
endif()
Flattened source tree.
2011-07-26 13:16:34 +00:00
Add custom target for updating gamepad mappings
2021-06-28 21:52:07 +00:00
add_custom_target(update_mappings
COMMAND "${CMAKE_COMMAND}" -P "${GLFW_SOURCE_DIR}/CMake/GenerateMappings.cmake" mappings.h.in mappings.h
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
COMMENT "Updating gamepad mappings from upstream repository"
SOURCES mappings.h.in "${GLFW_SOURCE_DIR}/CMake/GenerateMappings.cmake"
VERBATIM)
set_target_properties(update_mappings PROPERTIES FOLDER "GLFW3")
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_COCOA)
Remove configuration header
2021-04-15 13:33:19 +00:00
target_compile_definitions(glfw PRIVATE _GLFW_COCOA)
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
target_sources(glfw PRIVATE cocoa_platform.h cocoa_joystick.h cocoa_init.m
cocoa_joystick.m cocoa_monitor.m cocoa_window.m
nsgl_context.m)
endif()
if (GLFW_BUILD_WIN32)
Remove configuration header
2021-04-15 13:33:19 +00:00
target_compile_definitions(glfw PRIVATE _GLFW_WIN32)
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
target_sources(glfw PRIVATE win32_platform.h win32_joystick.h win32_init.c
win32_joystick.c win32_monitor.c win32_window.c
wgl_context.c)
endif()
if (GLFW_BUILD_X11)
Remove configuration header
2021-04-15 13:33:19 +00:00
target_compile_definitions(glfw PRIVATE _GLFW_X11)
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
target_sources(glfw PRIVATE x11_platform.h xkb_unicode.h x11_init.c
x11_monitor.c x11_window.c xkb_unicode.c
glx_context.c)
Replace CMake list variables with target_sources
2019-12-15 06:37:26 +00:00
endif()
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_WAYLAND)
target_compile_definitions(glfw PRIVATE _GLFW_WAYLAND)
target_sources(glfw PRIVATE wl_platform.h xkb_unicode.h wl_init.c
wl_monitor.c wl_window.c xkb_unicode.c)
Make dynamic module loading part of platform API This is part of the preparations for runtime platform selection.
2021-07-16 12:57:22 +00:00
endif()
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_X11 OR GLFW_BUILD_WAYLAND)
Simplify references in CMake if-statements
2021-01-18 15:04:51 +00:00
if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
Replace CMake list variables with target_sources
2019-12-15 06:37:26 +00:00
target_sources(glfw PRIVATE linux_joystick.h linux_joystick.c)
endif()
endif()
wayland: Implement 'DISABLED' cursor mode This implements support for the 'DISABLED' cursor mode, which effectively means locking the pointer to the surface. The cursor is also explicitly hidden. This adds two new build dependencies: wayland-scanner and wayland-protocols. Closes #708.
2015-12-09 07:29:37 +00:00
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_WAYLAND)
Remove configuration header
2021-04-15 13:33:19 +00:00
include(CheckIncludeFiles)
include(CheckFunctionExists)
check_include_files(xkbcommon/xkbcommon-compose.h HAVE_XKBCOMMON_COMPOSE_H)
if (HAVE_XKBCOMMON_COMPOSE_H)
target_compile_definitions(glfw PRIVATE HAVE_XKBCOMMON_COMPOSE_H)
endif()
check_function_exists(memfd_create HAVE_MEMFD_CREATE)
if (HAVE_MEMFD_CREATE)
target_compile_definitions(glfw PRIVATE HAVE_MEMFD_CREATE)
endif()
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
find_program(WAYLAND_SCANNER_EXECUTABLE NAMES wayland-scanner)
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
include(FindPkgConfig)
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
pkg_check_modules(WAYLAND_PROTOCOLS REQUIRED wayland-protocols>=1.15)
pkg_get_variable(WAYLAND_PROTOCOLS_BASE wayland-protocols pkgdatadir)
Wayland: Make libwayland-client dynamically loaded The insight to use wayland.xml to resolve the difficult-to-redirect interface symbols was gleaned from SDL. Instead of compiling the code output of wayland-scanner separately it is made part of the wl_init compilation unit. This lets us do things like transparently rename our copies of Wayland globals. The OS version of wayland-client-protocol.h is no longer used by GLFW, but it is presumably ABI compatible with the output of wayland-scanner. Closes #1174. Closes #1338. Related to #1655. Closes #1943.
2021-07-13 16:12:43 +00:00
pkg_get_variable(WAYLAND_CLIENT_PKGDATADIR wayland-client pkgdatadir)
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
macro(wayland_generate protocol_file output_file)
Wayland: Fix indentation
2020-10-12 16:32:50 +00:00
add_custom_command(OUTPUT "${output_file}.h"
COMMAND "${WAYLAND_SCANNER_EXECUTABLE}" client-header "${protocol_file}" "${output_file}.h"
DEPENDS "${protocol_file}"
VERBATIM)
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
Wayland: Make libwayland-client dynamically loaded The insight to use wayland.xml to resolve the difficult-to-redirect interface symbols was gleaned from SDL. Instead of compiling the code output of wayland-scanner separately it is made part of the wl_init compilation unit. This lets us do things like transparently rename our copies of Wayland globals. The OS version of wayland-client-protocol.h is no longer used by GLFW, but it is presumably ABI compatible with the output of wayland-scanner. Closes #1174. Closes #1338. Related to #1655. Closes #1943.
2021-07-13 16:12:43 +00:00
add_custom_command(OUTPUT "${output_file}-code.h"
COMMAND "${WAYLAND_SCANNER_EXECUTABLE}" private-code "${protocol_file}" "${output_file}-code.h"
Wayland: Fix indentation
2020-10-12 16:32:50 +00:00
DEPENDS "${protocol_file}"
VERBATIM)
Wayland: Ensure paths are passed on in quoted form
2020-10-12 16:20:53 +00:00
Wayland: Make libwayland-client dynamically loaded The insight to use wayland.xml to resolve the difficult-to-redirect interface symbols was gleaned from SDL. Instead of compiling the code output of wayland-scanner separately it is made part of the wl_init compilation unit. This lets us do things like transparently rename our copies of Wayland globals. The OS version of wayland-client-protocol.h is no longer used by GLFW, but it is presumably ABI compatible with the output of wayland-scanner. Closes #1174. Closes #1338. Related to #1655. Closes #1943.
2021-07-13 16:12:43 +00:00
target_sources(glfw PRIVATE "${output_file}.h" "${output_file}-code.h")
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
endmacro()
Wayland: Make libwayland-client dynamically loaded The insight to use wayland.xml to resolve the difficult-to-redirect interface symbols was gleaned from SDL. Instead of compiling the code output of wayland-scanner separately it is made part of the wl_init compilation unit. This lets us do things like transparently rename our copies of Wayland globals. The OS version of wayland-client-protocol.h is no longer used by GLFW, but it is presumably ABI compatible with the output of wayland-scanner. Closes #1174. Closes #1338. Related to #1655. Closes #1943.
2021-07-13 16:12:43 +00:00
wayland_generate(
"${WAYLAND_CLIENT_PKGDATADIR}/wayland.xml"
"${GLFW_BINARY_DIR}/src/wayland-client-protocol")
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
wayland_generate(
Fix unquoted paths with variable references Whitespace is a field separator in CMake.
2020-10-12 15:34:46 +00:00
"${WAYLAND_PROTOCOLS_BASE}/stable/xdg-shell/xdg-shell.xml"
"${GLFW_BINARY_DIR}/src/wayland-xdg-shell-client-protocol")
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
wayland_generate(
Fix unquoted paths with variable references Whitespace is a field separator in CMake.
2020-10-12 15:34:46 +00:00
"${WAYLAND_PROTOCOLS_BASE}/unstable/xdg-decoration/xdg-decoration-unstable-v1.xml"
"${GLFW_BINARY_DIR}/src/wayland-xdg-decoration-client-protocol")
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
wayland_generate(
Fix unquoted paths with variable references Whitespace is a field separator in CMake.
2020-10-12 15:34:46 +00:00
"${WAYLAND_PROTOCOLS_BASE}/stable/viewporter/viewporter.xml"
"${GLFW_BINARY_DIR}/src/wayland-viewporter-client-protocol")
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
wayland_generate(
Fix unquoted paths with variable references Whitespace is a field separator in CMake.
2020-10-12 15:34:46 +00:00
"${WAYLAND_PROTOCOLS_BASE}/unstable/relative-pointer/relative-pointer-unstable-v1.xml"
"${GLFW_BINARY_DIR}/src/wayland-relative-pointer-unstable-v1-client-protocol")
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
wayland_generate(
Fix unquoted paths with variable references Whitespace is a field separator in CMake.
2020-10-12 15:34:46 +00:00
"${WAYLAND_PROTOCOLS_BASE}/unstable/pointer-constraints/pointer-constraints-unstable-v1.xml"
"${GLFW_BINARY_DIR}/src/wayland-pointer-constraints-unstable-v1-client-protocol")
Wayland: Remove extra-cmake-modules dependency Fixes #1774.
2020-09-29 05:23:02 +00:00
wayland_generate(
Fix unquoted paths with variable references Whitespace is a field separator in CMake.
2020-10-12 15:34:46 +00:00
"${WAYLAND_PROTOCOLS_BASE}/unstable/idle-inhibit/idle-inhibit-unstable-v1.xml"
"${GLFW_BINARY_DIR}/src/wayland-idle-inhibit-unstable-v1-client-protocol")
Add support for Wayland on FreeBSD and other OSes
2018-03-19 19:08:22 +00:00
endif()
Add override variable for CMake library type This adds the GLFW_LIBRARY_TYPE CMake cache variable, which allows users and higher-level projects to set what type of library GLFW is built as. When not empty, this value overrides the standard BUILD_SHARED_LIBS option for GLFW while still allowing it to control the type of other libraries in a larger project. This also allows building GLFW as an object library without adding dummy source files (as required by Xcode) or producing unused library binaries. Projects using CMake 3.12 or later can link the resulting GLFW object library normally using target_link_libraries. Fixes #279. Related to #1307. Closes #1497. Closes #1574. Closes #1928.
2021-07-06 21:12:05 +00:00
if (WIN32 AND GLFW_BUILD_SHARED_LIBRARY)
Win32: Add VERSIONINFO resource to GLFW DLL This will let people see the API version in the Explorer property box.
2019-12-11 18:09:59 +00:00
configure_file(glfw.rc.in glfw.rc @ONLY)
Replace CMake list variables with target_sources
2019-12-15 06:37:26 +00:00
target_sources(glfw PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/glfw.rc")
Win32: Add VERSIONINFO resource to GLFW DLL This will let people see the API version in the Explorer property box.
2019-12-11 18:09:59 +00:00
endif()
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
if (UNIX AND GLFW_BUILD_SHARED_LIBRARY)
# On Unix-like systems, shared libraries can use the soname system.
set(GLFW_LIB_NAME glfw)
else()
set(GLFW_LIB_NAME glfw3)
endif()
Added IDE folders to CMake files. Fixes #328.
2015-01-04 22:23:16 +00:00
set_target_properties(glfw PROPERTIES
Fix pkg-config file generation regression Fixes regression cased by 37c93ba031e18527f8ca70b8c6e733c63a5e4a30. Fixes #664. Closes #679.
2015-12-30 20:05:27 +00:00
OUTPUT_NAME ${GLFW_LIB_NAME}
Move to the modern CMake project version option This replaces the manual ad-hoc version variables we have used since CMake 2.x (and GLFW 2.x lite).
2019-05-08 13:28:18 +00:00
VERSION ${GLFW_VERSION_MAJOR}.${GLFW_VERSION_MINOR}
Added IDE folders to CMake files. Fixes #328.
2015-01-04 22:23:16 +00:00
SOVERSION ${GLFW_VERSION_MAJOR}
POSITION_INDEPENDENT_CODE ON
Update minimum required CMake version to 3.1
2019-11-26 17:09:22 +00:00
C_STANDARD 99
Enable strict C99 for non-VS compilers
2019-12-15 16:37:42 +00:00
C_EXTENSIONS OFF
Replace ad-hoc CMake code with DEFINE_SYMBOL This target property does what we were doing manually.
2019-12-15 08:21:58 +00:00
DEFINE_SYMBOL _GLFW_BUILD_DLL
Added IDE folders to CMake files. Fixes #328.
2015-01-04 22:23:16 +00:00
FOLDER "GLFW3")
Flattened source tree.
2011-07-26 13:16:34 +00:00
Add public header path to target interface Closes #697.
2016-02-01 23:54:57 +00:00
target_include_directories(glfw PUBLIC
Fix missing CMake file path quoting
2017-08-20 12:47:44 +00:00
"$<BUILD_INTERFACE:${GLFW_SOURCE_DIR}/include>"
Fix use of absolute path in INSTALL_INTERFACE Closes #1470.
2019-04-18 16:50:48 +00:00
"$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>")
Compiler flag cleanup
2015-12-13 19:01:01 +00:00
target_include_directories(glfw PRIVATE
"${GLFW_SOURCE_DIR}/src"
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
"${GLFW_BINARY_DIR}/src")
target_link_libraries(glfw PRIVATE Threads::Threads)
Compiler flag cleanup
2015-12-13 19:01:01 +00:00
Make compiler specific workarounds more consistent
2020-05-25 14:49:36 +00:00
# Workaround for CMake not knowing about .m files before version 3.16
Remove unneccessary quotes in CMake conditions
2021-04-21 13:03:42 +00:00
if (CMAKE_VERSION VERSION_LESS "3.16" AND APPLE)
Replace CMake list variables with target_sources
2019-12-15 06:37:26 +00:00
set_source_files_properties(cocoa_init.m cocoa_joystick.m cocoa_monitor.m
cocoa_window.m nsgl_context.m PROPERTIES
LANGUAGE C)
endif()
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_WIN32)
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
list(APPEND glfw_PKG_LIBS "-lgdi32")
endif()
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_COCOA)
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
target_link_libraries(glfw PRIVATE "-framework Cocoa"
"-framework IOKit"
"-framework CoreFoundation")
set(glfw_PKG_DEPS "")
set(glfw_PKG_LIBS "-framework Cocoa -framework IOKit -framework CoreFoundation")
endif()
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_WAYLAND)
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
pkg_check_modules(Wayland REQUIRED
wayland-client>=0.2.7
wayland-cursor>=0.2.7
wayland-egl>=0.2.7
xkbcommon)
target_include_directories(glfw PRIVATE ${Wayland_INCLUDE_DIRS})
if (NOT CMAKE_SYSTEM_NAME STREQUAL "Linux")
find_package(EpollShim)
if (EPOLLSHIM_FOUND)
target_include_directories(glfw PRIVATE ${EPOLLSHIM_INCLUDE_DIRS})
target_link_libraries(glfw PRIVATE ${EPOLLSHIM_LIBRARIES})
endif()
endif()
endif()
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_X11)
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
find_package(X11 REQUIRED)
target_include_directories(glfw PRIVATE "${X11_X11_INCLUDE_PATH}")
# Check for XRandR (modern resolution switching and gamma control)
if (NOT X11_Xrandr_INCLUDE_PATH)
message(FATAL_ERROR "RandR headers not found; install libxrandr development package")
endif()
# Check for Xinerama (legacy multi-monitor support)
if (NOT X11_Xinerama_INCLUDE_PATH)
message(FATAL_ERROR "Xinerama headers not found; install libxinerama development package")
endif()
# Check for Xkb (X keyboard extension)
if (NOT X11_Xkb_INCLUDE_PATH)
message(FATAL_ERROR "XKB headers not found; install X11 development package")
endif()
# Check for Xcursor (cursor creation from RGBA images)
if (NOT X11_Xcursor_INCLUDE_PATH)
message(FATAL_ERROR "Xcursor headers not found; install libxcursor development package")
endif()
# Check for XInput (modern HID input)
if (NOT X11_Xi_INCLUDE_PATH)
message(FATAL_ERROR "XInput headers not found; install libxi development package")
endif()
# Check for X Shape (custom window input shape)
if (NOT X11_Xshape_INCLUDE_PATH)
message(FATAL_ERROR "X Shape headers not found; install libxext development package")
endif()
endif()
if (UNIX AND NOT APPLE)
find_library(RT_LIBRARY rt)
mark_as_advanced(RT_LIBRARY)
if (RT_LIBRARY)
target_link_libraries(glfw PRIVATE "${RT_LIBRARY}")
list(APPEND glfw_PKG_LIBS "-lrt")
endif()
find_library(MATH_LIBRARY m)
mark_as_advanced(MATH_LIBRARY)
if (MATH_LIBRARY)
target_link_libraries(glfw PRIVATE "${MATH_LIBRARY}")
list(APPEND glfw_PKG_LIBS "-lm")
endif()
if (CMAKE_DL_LIBS)
target_link_libraries(glfw PRIVATE "${CMAKE_DL_LIBS}")
list(APPEND glfw_PKG_LIBS "-l${CMAKE_DL_LIBS}")
endif()
Remove configuration header
2021-04-15 13:33:19 +00:00
endif()
Remove ignored Clang compiler flag Clang ignores this when C99 is enabled, while GCC does not. Removing the checks for Clang to hopefully avoid a false sense of security.
2020-10-07 19:40:16 +00:00
# Make GCC warn about declarations that VS 2010 and 2012 won't accept for all
# source files that VS will build (Clang ignores this because we set -std=c99)
Simplify references in CMake if-statements
2021-01-18 15:04:51 +00:00
if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
set_source_files_properties(context.c init.c input.c monitor.c platform.c vulkan.c
window.c null_init.c null_joystick.c null_monitor.c
null_window.c win32_init.c win32_joystick.c win32_module.c
win32_monitor.c win32_time.c win32_thread.c win32_window.c
wgl_context.c egl_context.c osmesa_context.c PROPERTIES
Merge GCC/Clang specific CMake blocks
2019-12-07 20:03:14 +00:00
COMPILE_FLAGS -Wdeclaration-after-statement)
Remove ignored Clang compiler flag Clang ignores this when C99 is enabled, while GCC does not. Removing the checks for Clang to hopefully avoid a false sense of security.
2020-10-07 19:40:16 +00:00
endif()
Remove configuration header
2021-04-15 13:33:19 +00:00
if (WIN32)
if (GLFW_USE_HYBRID_HPG)
target_compile_definitions(glfw PRIVATE _GLFW_USE_HYBRID_HPG)
endif()
endif()
Win32: Enable /W3 on VS for library sources /W3 is the default for new VS projects and the library builds cleanly with it on VS 2010-2019 so let's try to keep it that way.
2020-10-07 20:50:54 +00:00
# Enable a reasonable set of warnings
Win32: Fix compilation with standalone LLVM The /clang: suffix passed to Clang-CL was accidentally also passed to the regular standalone Clang, which caused compilation to fail. We now pass /W3 to Clang-CL, which it interprets as -Wall. The _CRT_SECURE_NO_WARNINGS macro is now defined for both Clang and Clang-CL. The /entry: flag passed to link.exe is now also passed to lld-link, letting the windows subsystem tests and examples link. Fixes #1807. Closes #1824. Closes #1874.
2021-04-12 18:56:53 +00:00
# NOTE: The order matters here, Clang-CL matches both MSVC and Clang
if (MSVC)
Win32: Enable /W3 on VS for library sources /W3 is the default for new VS projects and the library builds cleanly with it on VS 2010-2019 so let's try to keep it that way.
2020-10-07 20:50:54 +00:00
target_compile_options(glfw PRIVATE "/W3")
Win32: Fix compilation with standalone LLVM The /clang: suffix passed to Clang-CL was accidentally also passed to the regular standalone Clang, which caused compilation to fail. We now pass /W3 to Clang-CL, which it interprets as -Wall. The _CRT_SECURE_NO_WARNINGS macro is now defined for both Clang and Clang-CL. The /entry: flag passed to link.exe is now also passed to lld-link, letting the windows subsystem tests and examples link. Fixes #1807. Closes #1824. Closes #1874.
2021-04-12 18:56:53 +00:00
elseif (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR
CMAKE_C_COMPILER_ID STREQUAL "Clang" OR
CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
target_compile_options(glfw PRIVATE "-Wall")
Merge GCC/Clang specific CMake blocks
2019-12-07 20:03:14 +00:00
endif()
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_WIN32)
Win32: Always define UNICODE and _UNICODE
2021-04-20 13:37:48 +00:00
target_compile_definitions(glfw PRIVATE UNICODE _UNICODE)
Win32: Enable Unicode mode for all compilers
2019-12-15 15:33:18 +00:00
endif()
Compiler flag cleanup
2015-12-13 19:01:01 +00:00
# HACK: When building on MinGW, WINVER and UNICODE need to be defined before
# the inclusion of stddef.h (by glfw3.h), which is itself included before
# win32_platform.h. We define them here until a saner solution can be found
# NOTE: MinGW-w64 and Visual C++ do /not/ need this hack.
Replace CMake generator expression with variable Generator expressions are amazing but best used in moderation.
2019-12-07 20:05:56 +00:00
if (MINGW)
Win32: Always define UNICODE and _UNICODE
2021-04-20 13:37:48 +00:00
target_compile_definitions(glfw PRIVATE WINVER=0x0501)
Replace CMake generator expression with variable Generator expressions are amazing but best used in moderation.
2019-12-07 20:05:56 +00:00
endif()
Compiler flag cleanup
2015-12-13 19:01:01 +00:00
Move more compiler workarounds to library setup These are details of the glfw CMake target and belong in the creation of that target.
2020-05-25 14:33:44 +00:00
# Workaround for legacy MinGW not providing XInput and DirectInput
if (MINGW)
include(CheckIncludeFile)
check_include_file(dinput.h DINPUT_H_FOUND)
check_include_file(xinput.h XINPUT_H_FOUND)
if (NOT DINPUT_H_FOUND OR NOT XINPUT_H_FOUND)
target_include_directories(glfw PRIVATE "${GLFW_SOURCE_DIR}/deps/mingw")
endif()
endif()
Win32: Fix compilation with standalone LLVM The /clang: suffix passed to Clang-CL was accidentally also passed to the regular standalone Clang, which caused compilation to fail. We now pass /W3 to Clang-CL, which it interprets as -Wall. The _CRT_SECURE_NO_WARNINGS macro is now defined for both Clang and Clang-CL. The /entry: flag passed to link.exe is now also passed to lld-link, letting the windows subsystem tests and examples link. Fixes #1807. Closes #1824. Closes #1874.
2021-04-12 18:56:53 +00:00
# Workaround for the MS CRT deprecating parts of the standard library
if (MSVC OR CMAKE_C_SIMULATE_ID STREQUAL "MSVC")
Make compiler specific workarounds more consistent
2020-05-25 14:49:36 +00:00
target_compile_definitions(glfw PRIVATE _CRT_SECURE_NO_WARNINGS)
endif()
# Workaround for VS 2008 not shipping with stdint.h
if (MSVC90)
target_include_directories(glfw PUBLIC "${GLFW_SOURCE_DIR}/deps/vs2008")
endif()
# Check for the DirectX 9 SDK as it is not included with VS 2008
Move more compiler workarounds to library setup These are details of the glfw CMake target and belong in the creation of that target.
2020-05-25 14:33:44 +00:00
if (MSVC90)
include(CheckIncludeFile)
check_include_file(dinput.h DINPUT_H_FOUND)
if (NOT DINPUT_H_FOUND)
message(FATAL_ERROR "DirectX 9 headers not found; install DirectX 9 SDK")
endif()
endif()
POSIX: Remove use of deprecated gettimeofday POSIX.1-2008 deprecated gettimeofday, which we used as a fallback if the monotonic clock was unavailable. This replaces that fallback with the non-monotonic real-time clock. Because of the Gordian knot of feature test macros across Unices, this also includes the shift from some platform source files defining _POSIX_C_SOURCE to various values to _DEFAULT_SOURCE being defined for all source files on Linux. This is because -std=c99 on Linux disables _DEFAULT_SOURCE (POSIX 2008 and extensions). Once runtime platform selection comes in, this kind of platform-specific preprocessor logic can be moved into the platform glue files and won't need to be replicated by third-party build setups, but for now, sorry.
2021-06-21 20:14:40 +00:00
# Workaround for -std=c99 on Linux disabling _DEFAULT_SOURCE (POSIX 2008 and more)
Add runtime platform selection This adds compile-time support for multiple platforms and runtime detection of them. Window system related platform functions are now called from shared code via the function pointer struct _GLFWplatform. The timer, thread and module loading platform functions are still called directly by name and the implementation chosen at link-time. These functions are the same for any backend on a given OS, including the Null backend. The platforms are now enabled via CMake dependent options following the GLFW_BUILD_<platform> pattern instead of a mix of automagic and ad-hoc option names. There is no longer any option for the Null backend as it is now always enabled. Much of the struct stitching work in platform.h was based on an earlier experimental branch for runtime platform selection by @ronchaine. Every platform function related to windows, contexts, monitors, input, event processing and Vulkan have been renamed so that multiple sets of them can exist without colliding. Calls to these are now routed through the _glfw.platform struct member. These changes makes up most of this commit. For Wayland and X11 the client library loading and display creation is used to detect a running compositor/server. The XDG_SESSION_TYPE environment variable is ignored for now, as X11 is still by far the more complete implementation. Closes #1655 Closes #1958
2021-07-13 19:50:09 +00:00
if (GLFW_BUILD_X11 OR GLFW_BUILD_WAYLAND)
POSIX: Remove use of deprecated gettimeofday POSIX.1-2008 deprecated gettimeofday, which we used as a fallback if the monotonic clock was unavailable. This replaces that fallback with the non-monotonic real-time clock. Because of the Gordian knot of feature test macros across Unices, this also includes the shift from some platform source files defining _POSIX_C_SOURCE to various values to _DEFAULT_SOURCE being defined for all source files on Linux. This is because -std=c99 on Linux disables _DEFAULT_SOURCE (POSIX 2008 and extensions). Once runtime platform selection comes in, this kind of platform-specific preprocessor logic can be moved into the platform glue files and won't need to be replicated by third-party build setups, but for now, sorry.
2021-06-21 20:14:40 +00:00
if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
target_compile_definitions(glfw PRIVATE _DEFAULT_SOURCE)
endif()
endif()
Add override variable for CMake library type This adds the GLFW_LIBRARY_TYPE CMake cache variable, which allows users and higher-level projects to set what type of library GLFW is built as. When not empty, this value overrides the standard BUILD_SHARED_LIBS option for GLFW while still allowing it to control the type of other libraries in a larger project. This also allows building GLFW as an object library without adding dummy source files (as required by Xcode) or producing unused library binaries. Projects using CMake 3.12 or later can link the resulting GLFW object library normally using target_link_libraries. Fixes #279. Related to #1307. Closes #1497. Closes #1574. Closes #1928.
2021-07-06 21:12:05 +00:00
if (GLFW_BUILD_SHARED_LIBRARY)
Cleanup of configuration variable use.
2012-12-02 18:13:01 +00:00
if (WIN32)
Gave MinGW link library a .a suffix.
2012-08-16 17:23:54 +00:00
if (MINGW)
Win32: Disable dynamic libgcc for MinGW DLL
2019-10-03 17:49:25 +00:00
# Remove the dependency on the shared version of libgcc
# NOTE: MinGW-w64 has the correct default but MinGW needs this
Fix use of CMake 3.13 command target_link_options
2019-12-15 08:03:22 +00:00
target_link_libraries(glfw PRIVATE "-static-libgcc")
Win32: Disable dynamic libgcc for MinGW DLL
2019-10-03 17:49:25 +00:00
Use GNUInstallDirs for install destinations This has the advantage that the user may override e.g. the include location, and the correct libdir (lib, lib64, lib/something) is automatically determined. Closes #1367.
2018-10-30 12:30:44 +00:00
# Remove the lib prefix on the DLL (but not the import library)
Compiler flag cleanup
2015-12-13 19:01:01 +00:00
set_target_properties(glfw PROPERTIES PREFIX "")
# Add a suffix to the import library to avoid naming conflicts
Gave MinGW link library a .a suffix.
2012-08-16 17:23:54 +00:00
set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.a")
else()
Compiler flag cleanup
2015-12-13 19:01:01 +00:00
# Add a suffix to the import library to avoid naming conflicts
Gave MinGW link library a .a suffix.
2012-08-16 17:23:54 +00:00
set_target_properties(glfw PROPERTIES IMPORT_SUFFIX "dll.lib")
endif()
CMake: remove -DGLFW_DLL on non-Windows targets When using GLFW with CMake and installed GLFW binaries, `-DGLFW_DLL` is passed on Linux, which should not happen. Closes #1530.
2019-07-08 12:54:08 +00:00
Remove tab character
2019-11-26 17:18:40 +00:00
target_compile_definitions(glfw INTERFACE GLFW_DLL)
Cocoa: Fix internal symbol hiding for dylib The default symbol visibility was not set to hidden on macOS.
2019-07-16 21:14:16 +00:00
endif()
Move more compiler workarounds to library setup These are details of the glfw CMake target and belong in the creation of that target.
2020-05-25 14:33:44 +00:00
if (MINGW)
# Enable link-time exploit mitigation features enabled by default on MSVC
include(CheckCCompilerFlag)
# Compatibility with data execution prevention (DEP)
set(CMAKE_REQUIRED_FLAGS "-Wl,--nxcompat")
check_c_compiler_flag("" _GLFW_HAS_DEP)
if (_GLFW_HAS_DEP)
target_link_libraries(glfw PRIVATE "-Wl,--nxcompat")
endif()
# Compatibility with address space layout randomization (ASLR)
set(CMAKE_REQUIRED_FLAGS "-Wl,--dynamicbase")
check_c_compiler_flag("" _GLFW_HAS_ASLR)
if (_GLFW_HAS_ASLR)
target_link_libraries(glfw PRIVATE "-Wl,--dynamicbase")
endif()
# Compatibility with 64-bit address space layout randomization (ASLR)
set(CMAKE_REQUIRED_FLAGS "-Wl,--high-entropy-va")
check_c_compiler_flag("" _GLFW_HAS_64ASLR)
if (_GLFW_HAS_64ASLR)
target_link_libraries(glfw PRIVATE "-Wl,--high-entropy-va")
endif()
# Clear flags again to avoid breaking later tests
set(CMAKE_REQUIRED_FLAGS)
endif()
Cocoa: Fix internal symbol hiding for dylib The default symbol visibility was not set to hidden on macOS.
2019-07-16 21:14:16 +00:00
if (UNIX)
Compiler flag cleanup
2015-12-13 19:01:01 +00:00
# Hide symbols not explicitly tagged for export from the shared library
target_compile_options(glfw PRIVATE "-fvisibility=hidden")
CMake file formatting.
2012-02-29 19:15:39 +00:00
endif()
endif()
Flattened source tree.
2011-07-26 13:16:34 +00:00
Move library dependency logic to src directory This finally eliminates the glfw_INCLUDE_DIRS and glfw_LIBRARIES CMake variables entirely.
2021-08-18 17:36:36 +00:00
foreach(arg ${glfw_PKG_DEPS})
string(APPEND deps " ${arg}")
endforeach()
foreach(arg ${glfw_PKG_LIBS})
string(APPEND libs " ${arg}")
endforeach()
set(GLFW_PKG_CONFIG_REQUIRES_PRIVATE "${deps}" CACHE INTERNAL
"GLFW pkg-config Requires.private")
set(GLFW_PKG_CONFIG_LIBS_PRIVATE "${libs}" CACHE INTERNAL
"GLFW pkg-config Libs.private")
configure_file("${GLFW_SOURCE_DIR}/CMake/glfw3.pc.in" glfw3.pc @ONLY)
Added option for disabling install.
2013-06-16 11:31:39 +00:00
if (GLFW_INSTALL)
Fix library destination for DLL platforms Fixes #1035.
2017-06-28 09:30:11 +00:00
install(TARGETS glfw
EXPORT glfwTargets
Fix hardcoded runtime destination in CMake install Closes #1883. Closes #1884.
2021-04-15 15:54:45 +00:00
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
Use GNUInstallDirs for install destinations This has the advantage that the user may override e.g. the include location, and the correct libdir (lib, lib64, lib/something) is automatically determined. Closes #1367.
2018-10-30 12:30:44 +00:00
ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}"
LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}")
Added option for disabling install.
2013-06-16 11:31:39 +00:00
endif()
Flattened source tree.
2011-07-26 13:16:34 +00:00
Reference in New Issue Copy Permalink