From 3fd85a4a304aa2d0ac69c7863ab7dceb58f1f76a Mon Sep 17 00:00:00 2001 From: slinky55 Date: Thu, 1 Jan 2026 19:21:46 -0600 Subject: [PATCH] initial commit --- .gitignore | 7 + .gitmodules | 6 + CMakeLists.txt | 14 + corrade | 1 + magnum | 1 + modules/FindCorrade.cmake | 755 ++++++++++++++++++++ modules/FindMagnum.cmake | 1404 +++++++++++++++++++++++++++++++++++++ src/CMakeLists.txt | 12 + src/Chocolate.cpp | 26 + 9 files changed, 2226 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 CMakeLists.txt create mode 160000 corrade create mode 160000 magnum create mode 100644 modules/FindCorrade.cmake create mode 100644 modules/FindMagnum.cmake create mode 100644 src/CMakeLists.txt create mode 100644 src/Chocolate.cpp diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0e1f1f1 --- /dev/null +++ b/.gitignore @@ -0,0 +1,7 @@ +build*/ +*.kdev4 +*~ +cmake-build-debug +.idea + +SDL2-* \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..79f4a6f --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "corrade"] + path = corrade + url = https://github.com/mosra/corrade.git +[submodule "magnum"] + path = magnum + url = https://github.com/mosra/magnum.git diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..552fa55 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,14 @@ +cmake_minimum_required(VERSION 3.5...3.20) +project(chocolate) + +set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/modules/" ${CMAKE_MODULE_PATH}) + +# Add Corrade as a subproject +add_subdirectory(corrade EXCLUDE_FROM_ALL) + +# Add Magnum as a subproject, enable Sdl2Application +set(CMAKE_PREFIX_PATH ${PROJECT_SOURCE_DIR}/SDL2-2.32.6 ${CMAKE_PREFIX_PATH}) +set(MAGNUM_WITH_SDL2APPLICATION ON CACHE BOOL "" FORCE) +add_subdirectory(magnum EXCLUDE_FROM_ALL) + +add_subdirectory(src) diff --git a/corrade b/corrade new file mode 160000 index 0000000..98e2a94 --- /dev/null +++ b/corrade @@ -0,0 +1 @@ +Subproject commit 98e2a94b559c45e092c6a585c14182f90151b192 diff --git a/magnum b/magnum new file mode 160000 index 0000000..ea060cd --- /dev/null +++ b/magnum @@ -0,0 +1 @@ +Subproject commit ea060cd9d6a88ec9b41a4e18f6748988b5b58568 diff --git a/modules/FindCorrade.cmake b/modules/FindCorrade.cmake new file mode 100644 index 0000000..e9c3de2 --- /dev/null +++ b/modules/FindCorrade.cmake @@ -0,0 +1,755 @@ +#.rst: +# Find Corrade +# ------------ +# +# Finds the Corrade library. Basic usage:: +# +# find_package(Corrade REQUIRED) +# +# This module tries to find the base Corrade library and then defines the +# following: +# +# Corrade_FOUND - Whether the base library was found +# CORRADE_LIB_SUFFIX_MODULE - Path to CorradeLibSuffix.cmake module +# +# This command will try to find only the base library, not the optional +# components, which are: +# +# Containers - Containers library +# Interconnect - Interconnect library +# Main - Main library +# PluginManager - PluginManager library +# TestSuite - TestSuite library +# Utility - Utility library +# rc - corrade-rc executable +# +# Example usage with specifying additional components is:: +# +# find_package(Corrade REQUIRED Utility TestSuite) +# +# For each component is then defined: +# +# Corrade_*_FOUND - Whether the component was found +# Corrade::* - Component imported target +# +# The package is found if either debug or release version of each library is +# found. If both debug and release libraries are found, proper version is +# chosen based on actual build configuration of the project (i.e. Debug build +# is linked to debug libraries, Release build to release libraries). +# +# Corrade conditionally defines ``CORRADE_IS_DEBUG_BUILD`` preprocessor +# variable in case build configuration is ``Debug`` (not Corrade itself, but +# build configuration of the project using it). Useful e.g. for selecting +# proper plugin directory. +# +# Corrade defines the following custom target properties: +# +# CORRADE_CXX_STANDARD - C++ standard to require when compiling given +# target. Does nothing if :variable:`CMAKE_CXX_FLAGS` already contains +# particular standard setting flag or if given target contains +# :prop_tgt:`CMAKE_CXX_STANDARD` property. Allowed value is 11, 14 or 17. +# INTERFACE_CORRADE_CXX_STANDARD - C++ standard to require when using given +# target. Does nothing if :variable:`CMAKE_CXX_FLAGS` already contains +# particular standard setting flag or if given target contains +# :prop_tgt:`CMAKE_CXX_STANDARD` property. Allowed value is 11, 14 or 17. +# CORRADE_USE_PEDANTIC_FLAGS - Enable additional compiler/linker flags. +# Boolean. +# +# These properties are inherited from directory properties, meaning that if you +# set them on directories, they get implicitly set on all targets in given +# directory (with a possibility to do target-specific overrides). All Corrade +# libraries have the :prop_tgt:`INTERFACE_CORRADE_CXX_STANDARD` property set to +# 11, meaning that you will always have at least C++11 enabled once you link to +# any Corrade library. +# +# Features of found Corrade library are exposed in these variables: +# +# CORRADE_MSVC_COMPATIBILITY - Defined if compiled with compatibility +# mode for MSVC 2019+ without the /permissive- flag set +# CORRADE_MSVC2017_COMPATIBILITY - Defined if compiled with compatibility +# mode for MSVC 2017 +# CORRADE_MSVC2015_COMPATIBILITY - Defined if compiled with compatibility +# mode for MSVC 2015 +# CORRADE_BUILD_DEPRECATED - Defined if compiled with deprecated features +# included +# CORRADE_BUILD_STATIC - Defined if compiled as static libraries. +# Default are shared libraries. +# CORRADE_BUILD_STATIC_UNIQUE_GLOBALS - Defined if static libraries keep their +# globals unique even across different shared libraries. Enabled by default +# for static builds. +# CORRADE_BUILD_MULTITHREADED - Defined if compiled in a way that makes it +# possible to safely use certain Corrade features simultaneously in multiple +# threads +# CORRADE_BUILD_CPU_RUNTIME_DISPATCH - Defined if built with code paths +# optimized for multiple architectres with the best matching variant selected +# at runtime based on detected CPU features +# CORRADE_TARGET_UNIX - Defined if compiled for some Unix flavor +# (Linux, BSD, macOS) +# CORRADE_TARGET_APPLE - Defined if compiled for Apple platforms +# CORRADE_TARGET_IOS - Defined if compiled for iOS (device or +# simulator) +# CORRADE_TARGET_IOS_SIMULATOR - Defined if compiled for iOS Simulator +# CORRADE_TARGET_WINDOWS - Defined if compiled for Windows +# CORRADE_TARGET_WINDOWS_RT - Defined if compiled for Windows RT +# CORRADE_TARGET_EMSCRIPTEN - Defined if compiled for Emscripten +# CORRADE_TARGET_ANDROID - Defined if compiled for Android +# CORRADE_TARGET_GCC - Defined if compiling with GCC or GCC- +# compatible Clang +# CORRADE_TARGET_CLANG - Defined if compiling with Clang or any of its +# variants +# CORRADE_TARGET_APPLE_CLANG - Defined if compiling with Apple's Clang +# CORRADE_TARGET_CLANG_CL - Defined if compiling with Clang-CL (Clang +# with a MSVC frontend) +# CORRADE_TARGET_MSVC - Defined if compiling with MSVC or Clang with +# a MSVC frontend +# CORRADE_TARGET_MINGW - Defined if compiling under MinGW +# CORRADE_CPU_USE_IFUNC - Defined if GNU IFUNC is allowed to be used +# for runtime dispatch in the Cpu library +# CORRADE_PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT - Defined if PluginManager +# doesn't support dynamic plugin loading due to platform limitations +# CORRADE_TESTSUITE_TARGET_XCTEST - Defined if TestSuite is targeting Xcode +# XCTest +# CORRADE_UTILITY_USE_ANSI_COLORS - Defined if ANSI escape sequences are used +# for colored output with Utility::Debug on Windows +# +# Additionally these variables are defined for internal usage: +# +# CORRADE_INCLUDE_DIR - Root include dir +# CORRADE_*_LIBRARY_DEBUG - Debug version of given library, if found +# CORRADE_*_LIBRARY_RELEASE - Release version of given library, if found +# CORRADE_*_EXECUTABLE - Location of given executable, if found +# CORRADE_*_EXECUTABLE_EMULATOR - Emulator to run CORRADE_*_EXECUTABLE, if a +# non-native version was found when cross-compiling +# CORRADE_USE_MODULE - Path to UseCorrade.cmake module (included +# automatically) +# CORRADE_DEPENDENCY_MODULE_DIR - Path to Find modules for dependencies used +# internally by Corrade. Defined only if any such modules are expected to +# exist on given platform. +# CORRADE_TESTSUITE_XCTEST_RUNNER - Path to XCTestRunner.mm.in file +# CORRADE_TESTSUITE_ADB_RUNNER - Path to AdbRunner.sh file +# CORRADE_UTILITY_JS - Path to CorradeUtility.js file +# CORRADE_PEDANTIC_COMPILER_OPTIONS - List of pedantic compiler options used +# for targets with :prop_tgt:`CORRADE_USE_PEDANTIC_FLAGS` enabled +# CORRADE_PEDANTIC_COMPILER_DEFINITIONS - List of pedantic compiler +# definitions used for targets with :prop_tgt:`CORRADE_USE_PEDANTIC_FLAGS` +# enabled +# CORRADE_CXX{11,14,17,20}_STANDARD_FLAG - Compiler flag to use for targeting +# C++11, 14, 17 or 20 in cases where it's not possible to use +# :prop_tgt:`CORRADE_CXX_STANDARD`. Not defined if a standard switch is +# already present in :variable:`CMAKE_CXX_FLAGS`. +# +# Corrade provides these macros and functions: +# +# .. command:: corrade_add_test +# +# Add unit test using Corrade's TestSuite:: +# +# corrade_add_test( +# ... +# [LIBRARIES ...] +# [FILES ...] +# [ARGUMENTS ...]) +# +# Test name is also executable name. You can use ``LIBRARIES`` to specify +# libraries to link with instead of using :command:`target_link_libraries()`. +# The ``Corrade::TestSuite`` target is linked automatically to each test. Note +# that the :command:`enable_testing()` function must be called explicitly. +# Arguments passed after ``ARGUMENTS`` will be appended to the test +# command line. ``ARGUMENTS`` are supported everywhere except when +# ``CORRADE_TESTSUITE_TARGET_XCTEST`` is enabled. +# +# You can list files needed by the test in the ``FILES`` section. If given +# filename is relative, it is treated relatively to `CMAKE_CURRENT_SOURCE_DIR`. +# The files are added to the :prop_test:`REQUIRED_FILES` target property. On +# Emscripten they are bundled to the executable and available in the virtual +# filesystem root. On Android they are copied along the executable to the +# target. In case of Emscripten and Android, if the file is absolute or +# contains ``..``, only the leaf name is used. Alternatively you can have a +# filename formatted as ``@``, in which case the ```` is +# treated as local filesystem location and ```` as remote/virtual +# filesystem location. The remote location can't be absolute or contain ``..`` +# / ``@`` characters. +# +# Unless :variable:`CORRADE_TESTSUITE_TARGET_XCTEST` is set, test cases on iOS +# targets are created as bundles with bundle identifier set to CMake project +# name by default. Use the cache variable :variable:`CORRADE_TESTSUITE_BUNDLE_IDENTIFIER_PREFIX` +# to change it to something else. +# +# .. command:: corrade_add_resource +# +# Compile data resources into application binary:: +# +# corrade_add_resource( ) +# +# Depends on ``Corrade::rc``, which is part of Corrade utilities. This command +# generates resource data using given configuration file in current build +# directory. Argument name is name under which the resources can be explicitly +# loaded. Variable ```` contains compiled resource filename, which is +# then used for compiling library / executable. On CMake >= 3.1 the +# `resources.conf` file can contain UTF-8-encoded filenames. Example usage:: +# +# corrade_add_resource(app_resources resources.conf) +# add_executable(app source1 source2 ... ${app_resources}) +# +# .. command:: corrade_add_plugin +# +# Add dynamic plugin:: +# +# corrade_add_plugin( +# ";" +# ";" +# +# ...) +# +# The macro adds a preprocessor directive ``CORRADE_DYNAMIC_PLUGIN`` when +# compiling ````. Additional libraries can be linked in via +# :command:`target_link_libraries(plugin_name ...) `. +# On DLL platforms, the plugin DLLs and metadata files are put into +# ```` / ```` and the +# ``*.lib`` files into ```` / +# ````. On non-DLL platforms everything is put +# into ```` / ````. +# +# If the plugin interface disables plugin metadata files, the +# ```` can be set to ``""``, in which case no metadata file is +# copied anywhere. Otherwise the metadata file is copied and renamed to +# ````, retaining its original extension. +# +# corrade_add_plugin( +# +# +# +# ...) +# +# Unlike the above version this puts everything into ```` on +# both DLL and non-DLL platforms. If ```` is set to +# :variable:`CMAKE_CURRENT_BINARY_DIR` (e.g. for testing purposes), the files +# are copied directly, without the need to perform install step. Note that the +# files are actually put into configuration-based subdirectory, i.e. +# ``${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}``. See documentation of +# :variable:`CMAKE_CFG_INTDIR` variable for more information. +# +# .. command:: corrade_add_static_plugin +# +# Add static plugin:: +# +# corrade_add_static_plugin( +# ";" +# +# ...) +# +# The macro adds a preprocessor directive ``CORRADE_STATIC_PLUGIN`` when +# compiling ````. Additional libraries can be linked in via +# :command:`target_link_libraries(plugin_name ...) `. +# The ```` is ignored and included just for compatibility +# with the :command:`corrade_add_plugin` command, everything is installed into +# ````. Note that plugins built in debug configuration +# (e.g. with :variable:`CMAKE_BUILD_TYPE` set to ``Debug``) have ``"-d"`` +# suffix to make it possible to have both debug and release plugins installed +# alongside each other. +# +# If the plugin interface disables plugin metadata files, the +# ```` can be set to ``""``, in which case no metadata file is +# used. Otherwise the metadata file is bundled and renamed to +# ````, retaining its original extension. +# +# corrade_add_static_plugin( +# +# +# ...) +# +# Equivalent to the above with ```` set to ````. +# If ```` is set to :variable:`CMAKE_CURRENT_BINARY_DIR` (e.g. for +# testing purposes), no installation rules are added. +# +# .. command:: corrade_find_dlls_for_libs +# +# Find corresponding DLLs for library files:: +# +# corrade_find_dlls_for_libs( ...) +# +# Available only on Windows, for all ``*.lib`` files tries to find +# corresponding DLL file. Useful for bundling dependencies for e.g. WinRT +# packages. +# + +# +# This file is part of Corrade. +# +# Copyright © 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, +# 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025 +# Vladimír Vondruš +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +# DEALINGS IN THE SOFTWARE. +# + +# Root include dir +find_path(CORRADE_INCLUDE_DIR + NAMES Corrade/Corrade.h) +mark_as_advanced(CORRADE_INCLUDE_DIR) + +# Configuration file +find_file(_CORRADE_CONFIGURE_FILE configure.h + HINTS ${CORRADE_INCLUDE_DIR}/Corrade/) +mark_as_advanced(_CORRADE_CONFIGURE_FILE) + +# We need to open configure.h file from CORRADE_INCLUDE_DIR before we check for +# the components. Bail out with proper error message if it wasn't found. The +# complete check with all components is further below. +if(NOT CORRADE_INCLUDE_DIR) + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(Corrade + REQUIRED_VARS CORRADE_INCLUDE_DIR _CORRADE_CONFIGURE_FILE) +endif() + +# Read flags from configuration +file(READ ${_CORRADE_CONFIGURE_FILE} _corradeConfigure) +string(REGEX REPLACE ";" "\\\\;" _corradeConfigure "${_corradeConfigure}") +string(REGEX REPLACE "\n" ";" _corradeConfigure "${_corradeConfigure}") +set(_corradeFlags + MSVC2015_COMPATIBILITY + MSVC2017_COMPATIBILITY + MSVC_COMPATIBILITY + BUILD_DEPRECATED + BUILD_STATIC + BUILD_STATIC_UNIQUE_GLOBALS + BUILD_MULTITHREADED + BUILD_CPU_RUNTIME_DISPATCH + TARGET_UNIX + TARGET_APPLE + TARGET_IOS + TARGET_IOS_SIMULATOR + TARGET_WINDOWS + TARGET_WINDOWS_RT + TARGET_EMSCRIPTEN + TARGET_ANDROID + # TARGET_X86 etc, TARGET_32BIT, TARGET_BIG_ENDIAN and TARGET_LIBCXX etc. + # are not exposed to CMake as the meaning is unclear on platforms with + # multi-arch binaries or when mixing different STL implementations. + # TARGET_GCC etc are figured out via UseCorrade.cmake, as the compiler can + # be different when compiling the lib & when using it. + CPU_USE_IFUNC + PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT + TESTSUITE_TARGET_XCTEST + UTILITY_USE_ANSI_COLORS) +foreach(_corradeFlag ${_corradeFlags}) + list(FIND _corradeConfigure "#define CORRADE_${_corradeFlag}" _corrade_${_corradeFlag}) + if(NOT _corrade_${_corradeFlag} EQUAL -1) + set(CORRADE_${_corradeFlag} 1) + endif() +endforeach() + +# CMake module dir +find_path(_CORRADE_MODULE_DIR + NAMES UseCorrade.cmake CorradeLibSuffix.cmake + PATH_SUFFIXES share/cmake/Corrade) +mark_as_advanced(_CORRADE_MODULE_DIR) +if(CORRADE_TARGET_EMSCRIPTEN) + find_path(CORRADE_DEPENDENCY_MODULE_DIR + NAMES FindNodeJs.cmake + PATH_SUFFIXES share/cmake/Corrade/dependencies) + mark_as_advanced(CORRADE_DEPENDENCY_MODULE_DIR) +endif() + +set(CORRADE_USE_MODULE ${_CORRADE_MODULE_DIR}/UseCorrade.cmake) +set(CORRADE_LIB_SUFFIX_MODULE ${_CORRADE_MODULE_DIR}/CorradeLibSuffix.cmake) + +# Component distinction (listing them explicitly to avoid mistakes with finding +# unknown components) +set(_CORRADE_LIBRARY_COMPONENTS + Containers Interconnect Main PluginManager TestSuite Utility) +# These libraries are excluded from DLL detection if Corrade is built as shared +set(_CORRADE_LIBRARY_COMPONENTS_ALWAYS_STATIC + Main) +set(_CORRADE_HEADER_ONLY_COMPONENTS Containers) +if(NOT CORRADE_TARGET_WINDOWS) + # CorradeMain is a real library only on windows, a dummy target elsewhere + list(APPEND _CORRADE_HEADER_ONLY_COMPONENTS Main) +endif() +set(_CORRADE_EXECUTABLE_COMPONENTS rc) +# Currently everything is enabled implicitly. Keep in sync with Corrade's root +# CMakeLists.txt. +set(_CORRADE_IMPLICITLY_ENABLED_COMPONENTS + Containers Interconnect Main PluginManager TestSuite Utility rc) + +# Inter-component dependencies +set(_CORRADE_Containers_DEPENDENCIES Utility) +set(_CORRADE_Interconnect_DEPENDENCIES Containers Utility) +set(_CORRADE_PluginManager_DEPENDENCIES Containers Utility rc) +set(_CORRADE_TestSuite_DEPENDENCIES Containers Utility Main) # see below +set(_CORRADE_Utility_DEPENDENCIES Containers rc) + +# Ensure that all inter-component dependencies are specified as well +foreach(_component ${Corrade_FIND_COMPONENTS}) + # Mark the dependencies as required if the component is also required + if(Corrade_FIND_REQUIRED_${_component}) + foreach(_dependency ${_CORRADE_${_component}_DEPENDENCIES}) + set(Corrade_FIND_REQUIRED_${_dependency} TRUE) + endforeach() + endif() + + list(APPEND _CORRADE_ADDITIONAL_COMPONENTS ${_CORRADE_${_component}_DEPENDENCIES}) +endforeach() + +# Main is linked only in corrade_add_test(), not to everything that depends on +# TestSuite, so remove it from the list again once we filled the above +# variables +set(_CORRADE_TestSuite_DEPENDENCIES Containers Utility) + +# Join the lists, remove duplicate components +set(_CORRADE_ORIGINAL_FIND_COMPONENTS ${Corrade_FIND_COMPONENTS}) +if(_CORRADE_ADDITIONAL_COMPONENTS) + list(INSERT Corrade_FIND_COMPONENTS 0 ${_CORRADE_ADDITIONAL_COMPONENTS}) +endif() +if(Corrade_FIND_COMPONENTS) + list(REMOVE_DUPLICATES Corrade_FIND_COMPONENTS) +endif() + +# Special cases of include paths. Libraries not listed here have a path suffix +# and include name derived from the library name in the loop below. +set(_CORRADE_MAIN_INCLUDE_PATH_SUFFIX Corrade) +set(_CORRADE_MAIN_INCLUDE_PATH_NAMES Corrade.h) + +# Find all components +foreach(_component ${Corrade_FIND_COMPONENTS}) + string(TOUPPER ${_component} _COMPONENT) + + # Create imported target in case the library is found. If the project is + # added as subproject to CMake, the target already exists and all the + # required setup is already done from the build tree. + if(TARGET "Corrade::${_component}") # Quotes to "fix" KDE's higlighter + set(Corrade_${_component}_FOUND TRUE) + else() + # Default include path names to look for for library / header-only + # components, unless set above already + if(_component IN_LIST _CORRADE_LIBRARY_COMPONENTS) + if(NOT _CORRADE_${_COMPONENT}_INCLUDE_PATH_SUFFIX) + set(_CORRADE_${_COMPONENT}_INCLUDE_PATH_SUFFIX Corrade/${_component}) + endif() + if(NOT _CORRADE_${_COMPONENT}_INCLUDE_PATH_NAMES) + set(_CORRADE_${_COMPONENT}_INCLUDE_PATH_NAMES ${_component}.h) + endif() + endif() + + # Library (and not header-only) components + if(_component IN_LIST _CORRADE_LIBRARY_COMPONENTS AND NOT _component IN_LIST _CORRADE_HEADER_ONLY_COMPONENTS) + # Try to find both debug and release version + find_library(CORRADE_${_COMPONENT}_LIBRARY_DEBUG Corrade${_component}-d) + find_library(CORRADE_${_COMPONENT}_LIBRARY_RELEASE Corrade${_component}) + mark_as_advanced(CORRADE_${_COMPONENT}_LIBRARY_DEBUG + CORRADE_${_COMPONENT}_LIBRARY_RELEASE) + + # On Windows, if we have a dynamic build of given library, find the + # DLLs as well. Abuse find_program() since the DLLs should be + # alongside usual executables. On MinGW they however have a lib + # prefix. + if(CORRADE_TARGET_WINDOWS AND NOT CORRADE_BUILD_STATIC AND NOT _component IN_LIST _CORRADE_LIBRARY_COMPONENTS_ALWAYS_STATIC) + find_program(CORRADE_${_COMPONENT}_DLL_DEBUG ${CMAKE_SHARED_LIBRARY_PREFIX}Corrade${_component}-d.dll) + find_program(CORRADE_${_COMPONENT}_DLL_RELEASE ${CMAKE_SHARED_LIBRARY_PREFIX}Corrade${_component}.dll) + mark_as_advanced(CORRADE_${_COMPONENT}_DLL_DEBUG + CORRADE_${_COMPONENT}_DLL_RELEASE) + # If not on Windows or on a static build, unset the DLL variables + # to avoid leaks when switching shared and static builds + else() + unset(CORRADE_${_COMPONENT}_DLL_DEBUG CACHE) + unset(CORRADE_${_COMPONENT}_DLL_RELEASE CACHE) + endif() + + # Executable components + elseif(_component IN_LIST _CORRADE_EXECUTABLE_COMPONENTS) + find_program(CORRADE_${_COMPONENT}_EXECUTABLE corrade-${_component}) + mark_as_advanced(CORRADE_${_COMPONENT}_EXECUTABLE) + + # If the executable wasn't found, we're cross-compiling, an + # emulator is set and we're on CMake 3.6+ that actually uses + # CMAKE_CROSSCOMPILING_EMULATOR in add_custom_command((), try to + # find the cross-compiled version as a (slower) fallback. This + # assumes the toolchain sets CMAKE_FIND_ROOT_PATH_MODE_PROGRAM to + # NEVER, i.e. that the search is restricted to native executables + # by default. + if(NOT CORRADE_${_COMPONENT}_EXECUTABLE AND CMAKE_CROSSCOMPILING AND CMAKE_CROSSCOMPILING_EMULATOR AND NOT CMAKE_VERSION VERSION_LESS 3.6) + # Additionally, there are no CMAKE_FIND_PROGRAM_SUFFIXES akin + # to CMAKE_FIND_LIBRARY_SUFFIXES for libraries, so we have to + # try manually. + if(CORRADE_TARGET_EMSCRIPTEN) + set(_CORRADE_PROGRAM_EXTENSION .js) + endif() + find_program(CORRADE_${_COMPONENT}_EXECUTABLE + NAMES + corrade-${_component} + corrade-${_component}${_CORRADE_PROGRAM_EXTENSION} + ONLY_CMAKE_FIND_ROOT_PATH) + if(CORRADE_${_COMPONENT}_EXECUTABLE) + set(CORRADE_${_COMPONENT}_EXECUTABLE_EMULATOR ${CMAKE_CROSSCOMPILING_EMULATOR} CACHE PATH "Emulator for running a cross-compiled corrade-${_component} executable") + mark_as_advanced(CORRADE_${_COMPONENT}_EXECUTABLE_EMULATOR) + endif() + endif() + + # If not a header-only component it's something unknown, skip. FPHSA + # will take care of handling this below. + elseif(NOT _component IN_LIST _CORRADE_HEADER_ONLY_COMPONENTS) + continue() + endif() + + # Find library includes + if(_component IN_LIST _CORRADE_LIBRARY_COMPONENTS) + find_path(_CORRADE_${_COMPONENT}_INCLUDE_DIR + NAMES ${_CORRADE_${_COMPONENT}_INCLUDE_PATH_NAMES} + HINTS ${CORRADE_INCLUDE_DIR}/${_CORRADE_${_COMPONENT}_INCLUDE_PATH_SUFFIX}) + mark_as_advanced(_CORRADE_${_COMPONENT}_INCLUDE_DIR) + endif() + + # Decide if the component was found. If not, skip the rest, which + # creates and populates the target and finds additional dependencies. + # If found, the _FOUND variable may still get reset by something below. + if( + # If the component is a library, it should have the include dir + (_component IN_LIST _CORRADE_LIBRARY_COMPONENTS AND _CORRADE_${_COMPONENT}_INCLUDE_DIR AND ( + # And it should be either header-only + _component IN_LIST _CORRADE_HEADER_ONLY_COMPONENTS OR + # Or have a debug library, and a DLL found if expected + (CORRADE_${_COMPONENT}_LIBRARY_DEBUG AND ( + NOT DEFINED CORRADE_${_COMPONENT}_DLL_DEBUG OR + CORRADE_${_COMPONENT}_DLL_DEBUG)) OR + # Or have a release library, and a DLL found if expected + (CORRADE_${_COMPONENT}_LIBRARY_RELEASE AND ( + NOT DEFINED CORRADE_${_COMPONENT}_DLL_RELEASE OR + CORRADE_${_COMPONENT}_DLL_RELEASE)))) OR + # If the component is an executable, it should have just the + # location + (_component IN_LIST _CORRADE_EXECUTABLE_COMPONENTS AND CORRADE_${_COMPONENT}_EXECUTABLE) + ) + set(Corrade_${_component}_FOUND TRUE) + else() + set(Corrade_${_component}_FOUND FALSE) + continue() + endif() + + # Target for header-only library components + if(_component IN_LIST _CORRADE_HEADER_ONLY_COMPONENTS) + add_library(Corrade::${_component} INTERFACE IMPORTED) + + # Target and location for (non-header-only) libraries + elseif(_component IN_LIST _CORRADE_LIBRARY_COMPONENTS) + if(CORRADE_BUILD_STATIC OR _component IN_LIST _CORRADE_LIBRARY_COMPONENTS_ALWAYS_STATIC) + add_library(Corrade::${_component} STATIC IMPORTED) + else() + add_library(Corrade::${_component} SHARED IMPORTED) + endif() + + foreach(_CONFIG DEBUG RELEASE) + if(NOT CORRADE_${_COMPONENT}_LIBRARY_${_CONFIG}) + continue() + endif() + + set_property(TARGET Corrade::${_component} APPEND PROPERTY + IMPORTED_CONFIGURATIONS ${_CONFIG}) + # Unfortunately for a DLL the two properties are swapped out, + # *.lib goes to IMPLIB, so it's duplicated like this + if(DEFINED CORRADE_${_COMPONENT}_DLL_${_CONFIG}) + # Quotes to "fix" KDE's higlighter + set_target_properties("Corrade::${_component}" PROPERTIES + IMPORTED_LOCATION_${_CONFIG} ${CORRADE_${_COMPONENT}_DLL_${_CONFIG}} + IMPORTED_IMPLIB_${_CONFIG} ${CORRADE_${_COMPONENT}_LIBRARY_${_CONFIG}}) + else() + set_property(TARGET Corrade::${_component} PROPERTY + IMPORTED_LOCATION_${_CONFIG} ${CORRADE_${_COMPONENT}_LIBRARY_${_CONFIG}}) + endif() + endforeach() + + # Target and location for executable components + elseif(_component IN_LIST _CORRADE_EXECUTABLE_COMPONENTS) + add_executable(Corrade::${_component} IMPORTED) + + set_property(TARGET Corrade::${_component} PROPERTY + IMPORTED_LOCATION ${CORRADE_${_COMPONENT}_EXECUTABLE}) + endif() + + # No special setup for Containers library + + # Interconnect library + if(_component STREQUAL Interconnect) + # Disable /OPT:ICF on MSVC, which merges functions with identical + # contents and thus breaks signal comparison. Same case is for + # clang-cl which uses the MSVC linker by default. + if(CORRADE_TARGET_WINDOWS AND (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" OR CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")) + if(CMAKE_VERSION VERSION_LESS 3.13) + set_property(TARGET Corrade::${_component} PROPERTY + INTERFACE_LINK_LIBRARIES "-OPT:NOICF,REF") + else() + set_property(TARGET Corrade::${_component} PROPERTY + INTERFACE_LINK_OPTIONS "/OPT:NOICF,REF") + endif() + endif() + + # Main library + elseif(_component STREQUAL Main) + if(CORRADE_TARGET_WINDOWS) + if(NOT MINGW) + # Abusing INTERFACE_LINK_LIBRARIES because + # INTERFACE_LINK_OPTIONS is only since 3.13. They treat + # things with `-` in front as linker flags and fortunately + # I can use `-ENTRY` instead of `/ENTRY`. + # https://gitlab.kitware.com/cmake/cmake/issues/16543 + set_property(TARGET Corrade::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES "-ENTRY:$<$>>:wmainCRTStartup>$<$>:wWinMainCRTStartup>") + else() + set_property(TARGET Corrade::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES "-municode") + endif() + endif() + + # PluginManager library + elseif(_component STREQUAL PluginManager) + # -ldl is handled by Utility now + + # TestSuite library has some additional files. If those are not found, + # set the component _FOUND variable to false so it works properly both + # when the component is required and when it's optional. + elseif(_component STREQUAL TestSuite) + # XCTest runner file + if(CORRADE_TESTSUITE_TARGET_XCTEST) + find_file(CORRADE_TESTSUITE_XCTEST_RUNNER XCTestRunner.mm.in + PATH_SUFFIXES share/corrade/TestSuite) + if(NOT CORRADE_TESTSUITE_XCTEST_RUNNER) + set(Corrade_${_component}_FOUND FALSE) + endif() + + # ADB runner file + elseif(CORRADE_TARGET_ANDROID) + find_file(CORRADE_TESTSUITE_ADB_RUNNER AdbRunner.sh + PATH_SUFFIXES share/corrade/TestSuite) + if(NOT CORRADE_TESTSUITE_ADB_RUNNER) + set(Corrade_${_component}_FOUND FALSE) + endif() + + # Emscripten runner file + elseif(CORRADE_TARGET_EMSCRIPTEN) + find_file(CORRADE_TESTSUITE_EMSCRIPTEN_RUNNER EmscriptenRunner.html.in + PATH_SUFFIXES share/corrade/TestSuite) + if(NOT CORRADE_TESTSUITE_EMSCRIPTEN_RUNNER) + set(Corrade_${_component}_FOUND FALSE) + endif() + endif() + + # Utility library (contains all setup that is used by others) + elseif(_component STREQUAL Utility) + # Top-level include directory + set_property(TARGET Corrade::${_component} APPEND PROPERTY + INTERFACE_INCLUDE_DIRECTORIES ${CORRADE_INCLUDE_DIR}) + + # Require (at least) C++11 for users + set_property(TARGET Corrade::${_component} PROPERTY + INTERFACE_CORRADE_CXX_STANDARD 11) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + COMPATIBLE_INTERFACE_NUMBER_MAX CORRADE_CXX_STANDARD) + + # -fno-strict-aliasing is set in UseCorrade.cmake for everyone who + # enables CORRADE_USE_PEDANTIC_FLAGS. Not all projects linking to + # Corrade enable it (or can't enable it), but this flag is + # essential to prevent insane bugs and random breakages, so force + # it for anyone linking to Corrade::Utility. Similar code is in + # Corrade/Utility/CMakeLists.txt. + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR (CMAKE_CXX_COMPILER_ID MATCHES "(Apple)?Clang" AND NOT CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC") OR CORRADE_TARGET_EMSCRIPTEN) + set_property(TARGET Corrade::${_component} APPEND PROPERTY INTERFACE_COMPILE_OPTIONS -fno-strict-aliasing) + endif() + + # Path::libraryLocation() needs this + if(CORRADE_TARGET_UNIX) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS}) + endif() + # AndroidLogStreamBuffer class needs to be linked to log library + if(CORRADE_TARGET_ANDROID) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES "log") + endif() + # Emscripten has various stuff implemented in JS + if(CORRADE_TARGET_EMSCRIPTEN) + find_file(CORRADE_UTILITY_JS CorradeUtility.js + PATH_SUFFIXES lib) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + # TODO switch to INTERFACE_LINK_OPTIONS and SHELL: once we + # require CMake 3.13 unconditionally + INTERFACE_LINK_LIBRARIES "--js-library ${CORRADE_UTILITY_JS}") + endif() + endif() + + # Add inter-library dependencies + if(_component IN_LIST _CORRADE_LIBRARY_COMPONENTS OR _component IN_LIST _CORRADE_HEADER_ONLY_COMPONENTS) + foreach(_dependency ${_CORRADE_${_component}_DEPENDENCIES}) + if(_dependency IN_LIST _CORRADE_LIBRARY_COMPONENTS OR _dependency IN_LIST _CORRADE_HEADER_ONLY_COMPONENTS) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Corrade::${_dependency}) + endif() + endforeach() + endif() + endif() +endforeach() + +# For CMake 3.16+ with REASON_FAILURE_MESSAGE, provide additional potentially +# useful info about the failed components. +if(NOT CMAKE_VERSION VERSION_LESS 3.16) + set(_CORRADE_REASON_FAILURE_MESSAGE ) + # Go only through the originally specified find_package() components, not + # the dependencies added by us afterwards + foreach(_component ${_CORRADE_ORIGINAL_FIND_COMPONENTS}) + if(Corrade_${_component}_FOUND) + continue() + endif() + + # If it's not known at all, tell the user -- it might be a new library + # and an old Find module, or something platform-specific. + if(NOT _component IN_LIST _CORRADE_LIBRARY_COMPONENTS AND NOT _component IN_LIST _CORRADE_EXECUTABLE_COMPONENTS) + list(APPEND _CORRADE_REASON_FAILURE_MESSAGE "${_component} is not a known component on this platform.") + # Otherwise, if it's not among implicitly built components, hint that + # the user may need to enable it. + # TODO: currently, the _FOUND variable doesn't reflect if dependencies + # were found. When it will, this needs to be updated to avoid + # misleading messages. + elseif(NOT _component IN_LIST _CORRADE_IMPLICITLY_ENABLED_COMPONENTS) + string(TOUPPER ${_component} _COMPONENT) + list(APPEND _CORRADE_REASON_FAILURE_MESSAGE "${_component} is not built by default. Make sure you enabled CORRADE_WITH_${_COMPONENT} when building Corrade.") + # Otherwise we have no idea. Better be silent than to print something + # misleading. + else() + endif() + endforeach() + + string(REPLACE ";" " " _CORRADE_REASON_FAILURE_MESSAGE "${_CORRADE_REASON_FAILURE_MESSAGE}") + set(_CORRADE_REASON_FAILURE_MESSAGE REASON_FAILURE_MESSAGE "${_CORRADE_REASON_FAILURE_MESSAGE}") +endif() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Corrade REQUIRED_VARS + CORRADE_INCLUDE_DIR + _CORRADE_MODULE_DIR + _CORRADE_CONFIGURE_FILE + HANDLE_COMPONENTS + ${_CORRADE_REASON_FAILURE_MESSAGE}) + +# Finalize the finding process +include(${CORRADE_USE_MODULE}) + +set(CORRADE_INCLUDE_INSTALL_DIR include/Corrade) + +if(CORRADE_BUILD_DEPRECATED AND CORRADE_INCLUDE_INSTALL_PREFIX AND NOT CORRADE_INCLUDE_INSTALL_PREFIX STREQUAL ".") + message(DEPRECATION "CORRADE_INCLUDE_INSTALL_PREFIX is obsolete as its primary use was for old Android NDK versions. Please switch to the NDK r19+ layout instead of using this variable and recreate your build directory to get rid of this warning.") + set(CORRADE_INCLUDE_INSTALL_DIR ${CORRADE_INCLUDE_INSTALL_PREFIX}/${CORRADE_INCLUDE_INSTALL_DIR}) +endif() diff --git a/modules/FindMagnum.cmake b/modules/FindMagnum.cmake new file mode 100644 index 0000000..03656d1 --- /dev/null +++ b/modules/FindMagnum.cmake @@ -0,0 +1,1404 @@ +#.rst: +# Find Magnum +# ----------- +# +# Finds the Magnum library. Basic usage:: +# +# find_package(Magnum REQUIRED) +# +# This module tries to find the base Magnum library and then defines the +# following: +# +# Magnum_FOUND - Whether the base library was found +# MAGNUM_DEPLOY_PREFIX - Prefix where to put final application +# executables, defaults to ``.``. If a relative path is used, it's relative +# to :variable:`CMAKE_INSTALL_PREFIX`. +# MAGNUM_PLUGINS_DEBUG_DIR - Base directory with dynamic plugins for +# debug builds, defaults to magnum-d/ subdirectory of dir where Magnum +# library was found +# MAGNUM_PLUGINS_RELEASE_DIR - Base directory with dynamic plugins for +# release builds, defaults to magnum/ subdirectory of dir where Magnum +# library was found +# MAGNUM_PLUGINS_DIR - Base directory with dynamic plugins, defaults +# to :variable:`MAGNUM_PLUGINS_RELEASE_DIR` in release builds and +# multi-configuration builds or to :variable:`MAGNUM_PLUGINS_DEBUG_DIR` in +# debug builds +# MAGNUM_PLUGINS_FONT[|_DEBUG|_RELEASE]_DIR - Directory with dynamic font +# plugins +# MAGNUM_PLUGINS_FONTCONVERTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic +# font converter plugins +# MAGNUM_PLUGINS_IMAGECONVERTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic +# image converter plugins +# MAGNUM_PLUGINS_SCENECONVERTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic +# scene converter plugins +# MAGNUM_PLUGINS_IMPORTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic +# importer plugins +# MAGNUM_PLUGINS_AUDIOIMPORTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic +# audio importer plugins +# +# If Magnum is built for Emscripten, the following variables contain paths to +# various support files: +# +# MAGNUM_EMSCRIPTENAPPLICATION_JS - Path to the EmscriptenApplication.js file +# MAGNUM_WINDOWLESSEMSCRIPTENAPPLICATION_JS - Path to the +# WindowlessEmscriptenApplication.js file +# MAGNUM_WEBAPPLICATION_CSS - Path to the WebApplication.css file +# +# This command will try to find only the base library, not the optional +# components. The base library depends on Corrade and OpenGL libraries (or +# OpenGL ES libraries). Additional dependencies are specified by the +# components. The optional components are: +# +# AnyAudioImporter - Any audio importer +# AnyImageConverter - Any image converter +# AnyImageImporter - Any image importer +# AnySceneConverter - Any scene converter +# AnySceneImporter - Any scene importer +# Audio - Audio library +# DebugTools - DebugTools library +# GL - GL library +# MaterialTools - MaterialTools library +# MeshTools - MeshTools library +# Primitives - Primitives library +# SceneGraph - SceneGraph library +# SceneTools - SceneTools library +# Shaders - Shaders library +# ShaderTools - ShaderTools library +# Text - Text library +# TextureTools - TextureTools library +# Trade - Trade library +# Vk - Vk library +# AndroidApplication - Android application +# EmscriptenApplication - Emscripten application +# GlfwApplication - GLFW application +# GlxApplication - GLX application +# Sdl2Application - SDL2 application +# XEglApplication - X/EGL application +# WindowlessCglApplication - Windowless CGL application +# WindowlessEglApplication - Windowless EGL application +# WindowlessGlxApplication - Windowless GLX application +# WindowlessIosApplication - Windowless iOS application +# WindowlessWglApplication - Windowless WGL application +# CglContext - CGL context +# EglContext - EGL context +# GlxContext - GLX context +# WglContext - WGL context +# OpenGLTester - OpenGLTester class +# VulkanTester - VulkanTester class +# MagnumFont - Magnum bitmap font plugin +# MagnumFontConverter - Magnum bitmap font converter plugin +# ObjImporter - OBJ importer plugin +# TgaImageConverter - TGA image converter plugin +# TgaImporter - TGA importer plugin +# WavAudioImporter - WAV audio importer plugin +# distancefieldconverter - magnum-distancefieldconverter executable +# fontconverter - magnum-fontconverter executable +# imageconverter - magnum-imageconverter executable +# sceneconverterter - magnum-sceneconverter executable +# shaderconverterter - magnum-shaderconverter executable +# gl-info - magnum-gl-info executable +# vk-info - magnum-vk-info executable +# al-info - magnum-al-info executable +# +# Example usage with specifying additional components is:: +# +# find_package(Magnum REQUIRED Trade MeshTools Primitives GlfwApplication) +# +# For each component is then defined: +# +# Magnum_*_FOUND - Whether the component was found +# Magnum::* - Component imported target +# +# If exactly one ``*Application`` or exactly one ``Windowless*Application`` +# component is requested and found, its target is available in convenience +# alias ``Magnum::Application`` / ``Magnum::WindowlessApplication`` to simplify +# porting. Similarly, if exactly one ``*Context`` component is requested and +# found, its target is available in convenience alias ``Magnum::GLContext``. +# +# The package is found if either debug or release version of each requested +# library (or plugin) is found. If both debug and release libraries (or +# plugins) are found, proper version is chosen based on actual build +# configuration of the project (i.e. Debug build is linked to debug libraries, +# Release build to release libraries). Note that this autodetection might fail +# for the :variable:`MAGNUM_PLUGINS_DIR` variable, especially on +# multi-configuration build systems. You can make use of +# ``CORRADE_IS_DEBUG_BUILD`` preprocessor variable along with +# ``MAGNUM_PLUGINS_*_DEBUG_DIR`` / ``MAGNUM_PLUGINS_*_RELEASE_DIR`` variables +# to decide in preprocessing step. +# +# Features of found Magnum library are exposed in these variables: +# +# MAGNUM_BUILD_DEPRECATED - Defined if compiled with deprecated features +# included +# MAGNUM_BUILD_STATIC - Defined if compiled as static libraries +# MAGNUM_BUILD_STATIC_UNIQUE_GLOBALS - Defined if static libraries keep the +# globals unique even across different shared libraries +# MAGNUM_TARGET_GL - Defined if compiled with OpenGL interop +# MAGNUM_TARGET_GLES - Defined if compiled for OpenGL ES +# MAGNUM_TARGET_WEBGL - Defined if compiled for WebGL +# MAGNUM_TARGET_GLES2 - Defined if compiled for OpenGL ES 2.0 / WebGL +# 1 instead of OpenGL ES 3.0+ / WebGL 2 +# MAGNUM_TARGET_EGL - Defined if compiled for EGL instead of a +# platform-specific OpenGL support library like CGL, EAGL, GLX or WGL +# MAGNUM_TARGET_VK - Defined if compiled with Vulkan interop +# +# The following variables are provided for backwards compatibility purposes +# only when MAGNUM_BUILD_DEPRECATED is enabled and will be removed in a future +# release: +# +# MAGNUM_BUILD_MULTITHREADED - Alias to CORRADE_BUILD_MULTITHREADED. Use +# CORRADE_BUILD_MULTITHREADED instead. +# MAGNUM_TARGET_HEADLESS - Alias to MAGNUM_TARGET_EGL, unless on iOS, +# Android, Emscripten or Windows RT. Use MAGNUM_TARGET_EGL instead. +# MAGNUM_TARGET_DESKTOP_GLES` - Defined if compiled for OpenGL ES but +# GLX / WGL is used instead of EGL. Use MAGNUM_TARGET_EGL instead. +# MAGNUM_TARGET_GLES3 - Defined if compiled for OpenGL ES 3.0+ / +# WebGL 2. Use an inverse of the MAGNUM_TARGET_GLES2 variable instead. +# +# Additionally these variables are defined for internal usage: +# +# MAGNUM_INCLUDE_DIR - Root include dir (w/o dependencies) +# MAGNUM_LIBRARY_DEBUG - Debug version of Magnum library, if found +# MAGNUM_LIBRARY_RELEASE - Release version of Magnum library, if found +# MAGNUM_*_LIBRARY_DEBUG - Debug version of given library, if found +# MAGNUM_*_LIBRARY_RELEASE - Release version of given library, if found +# MAGNUM_PLATFORM_JS - Path to MagnumPlatform.js file +# MAGNUM_BINARY_INSTALL_DIR - Binary installation directory +# MAGNUM_LIBRARY_INSTALL_DIR - Library installation directory +# MAGNUM_DATA_INSTALL_DIR - Data installation directory +# MAGNUM_PLUGINS_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Plugin binary +# installation directory +# MAGNUM_PLUGINS_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Plugin library +# installation directory +# MAGNUM_PLUGINS_SHADERCONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Shader +# converter plugin binary installation directory +# MAGNUM_PLUGINS_SHADERCONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Shader +# converter plugin library installation directory +# MAGNUM_PLUGINS_FONT_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Font plugin binary +# installation directory +# MAGNUM_PLUGINS_FONT_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Font plugin +# library installation directory +# MAGNUM_PLUGINS_FONTCONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Font +# converter plugin binary installation directory +# MAGNUM_PLUGINS_FONTCONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Font +# converter plugin library installation directory +# MAGNUM_PLUGINS_IMAGECONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Image +# converter plugin binary installation directory +# MAGNUM_PLUGINS_IMAGECONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Image +# converter plugin library installation directory +# MAGNUM_PLUGINS_IMPORTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Importer +# plugin binary installation directory +# MAGNUM_PLUGINS_IMPORTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Importer +# plugin library installation directory +# MAGNUM_PLUGINS_SCENECONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Scene +# converter plugin binary installation directory +# MAGNUM_PLUGINS_SCENECONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Scene +# converter plugin library installation directory +# MAGNUM_PLUGINS_AUDIOIMPORTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Audio +# importer plugin binary installation directory +# MAGNUM_PLUGINS_AUDIOIMPORTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Audio +# importer plugin library installation directory +# MAGNUM_INCLUDE_INSTALL_DIR - Header installation directory +# MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR - Plugin header installation directory +# + +# +# This file is part of Magnum. +# +# Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, +# 2020, 2021, 2022, 2023, 2024, 2025 +# Vladimír Vondruš +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files (the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and/or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +# DEALINGS IN THE SOFTWARE. +# + +# CMake policies used by FindMagnum are popped again at the end. +cmake_policy(PUSH) +# Prefer GLVND when finding OpenGL. If this causes problems (known to fail with +# NVidia drivers in Debian Buster, reported on 2019-04-09), users can override +# this by setting OpenGL_GL_PREFERENCE to LEGACY. +if(POLICY CMP0072) + cmake_policy(SET CMP0072 NEW) +endif() + +# Corrade library dependencies +set(_MAGNUM_CORRADE_DEPENDENCIES ) +foreach(_magnum_component ${Magnum_FIND_COMPONENTS}) + set(_MAGNUM_${_magnum_component}_CORRADE_DEPENDENCIES ) + + # Unrolling the transitive dependencies here so this doesn't need to be + # after resolving inter-component dependencies. Listing also all plugins. + if(_magnum_component MATCHES "^(Audio|DebugTools|MeshTools|Primitives|SceneTools|ShaderTools|Text|TextureTools|Trade|.+Importer|.+ImageConverter|.+Font|.+ShaderConverter)$") + list(APPEND _MAGNUM_${_magnum_component}_CORRADE_DEPENDENCIES PluginManager) + endif() + if(_magnum_component STREQUAL DebugTools) + # DebugTools depends on TestSuite optionally, so if it's not there + # assume it wasn't compiled against it. Also, all variables from the + # FindCorrade module overwrite the local variables here (in particular + # _component, _COMPONENT and such), so we need to prefix extensively. + find_package(Corrade QUIET COMPONENTS TestSuite) + if(Corrade_TestSuite_FOUND) + list(APPEND _MAGNUM_${_magnum_component}_CORRADE_DEPENDENCIES TestSuite) + endif() + endif() + + list(APPEND _MAGNUM_CORRADE_DEPENDENCIES ${_MAGNUM_${_magnum_component}_CORRADE_DEPENDENCIES}) +endforeach() +find_package(Corrade REQUIRED Utility ${_MAGNUM_CORRADE_DEPENDENCIES}) + +# Root include dir +find_path(MAGNUM_INCLUDE_DIR + NAMES Magnum/Magnum.h) +mark_as_advanced(MAGNUM_INCLUDE_DIR) + +# Configuration file +find_file(_MAGNUM_CONFIGURE_FILE configure.h + HINTS ${MAGNUM_INCLUDE_DIR}/Magnum/) +mark_as_advanced(_MAGNUM_CONFIGURE_FILE) + +# We need to open configure.h file from MAGNUM_INCLUDE_DIR before we check for +# the components. Bail out with proper error message if it wasn't found. The +# complete check with all components is further below. +if(NOT MAGNUM_INCLUDE_DIR) + include(FindPackageHandleStandardArgs) + find_package_handle_standard_args(Magnum + REQUIRED_VARS MAGNUM_INCLUDE_DIR _MAGNUM_CONFIGURE_FILE) +endif() + +# Read flags from configuration +file(READ ${_MAGNUM_CONFIGURE_FILE} _magnumConfigure) +string(REGEX REPLACE ";" "\\\\;" _magnumConfigure "${_magnumConfigure}") +string(REGEX REPLACE "\n" ";" _magnumConfigure "${_magnumConfigure}") +set(_magnumFlags + BUILD_DEPRECATED + BUILD_STATIC + BUILD_STATIC_UNIQUE_GLOBALS + TARGET_GL + TARGET_GLES + TARGET_GLES2 + TARGET_WEBGL + TARGET_EGL + TARGET_VK) +foreach(_magnumFlag ${_magnumFlags}) + list(FIND _magnumConfigure "#define MAGNUM_${_magnumFlag}" _magnum_${_magnumFlag}) + if(NOT _magnum_${_magnumFlag} EQUAL -1) + set(MAGNUM_${_magnumFlag} 1) + endif() +endforeach() + +# For compatibility only, to be removed at some point. Refer to +# src/Magnum/configure.h.cmake for the decision logic here. +if(MAGNUM_BUILD_DEPRECATED) + if(CORRADE_BUILD_MULTITHREADED) + set(MAGNUM_BUILD_MULTITHREADED 1) + endif() + if(NOT CORRADE_TARGET_IOS AND NOT CORRADE_TARGET_ANDROID AND NOT CORRADE_TARGET_EMSCRIPTEN AND NOT CORRADE_TARGET_WINDOWS_RT) + if(NOT MAGNUM_TARGET_GLES AND MAGNUM_TARGET_EGL) + set(MAGNUM_TARGET_HEADLESS 1) + endif() + if(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_EGL) + set(MAGNUM_TARGET_DESKTOP_GLES 1) + endif() + endif() + if(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_GLES2) + set(MAGNUM_TARGET_GLES3 1) + endif() +endif() + +# CMake module dir for dependencies. It might not be present at all if no +# feature that needs them is enabled, in which case it'll be left at NOTFOUND. +# But in that case it should also not be subsequently needed for any +# find_package(). If this is called from a superproject, the +# _MAGNUM_DEPENDENCY_MODULE_DIR is already set by modules/CMakeLists.txt. +find_path(_MAGNUM_DEPENDENCY_MODULE_DIR + NAMES + FindEGL.cmake FindGLFW.cmake FindOpenAL.cmake FindOpenGLES2.cmake + FindOpenGLES3.cmake FindSDL2.cmake FindVulkan.cmake + PATH_SUFFIXES share/cmake/Magnum/dependencies) +mark_as_advanced(_MAGNUM_DEPENDENCY_MODULE_DIR) + +# If the module dir is found and is not present in CMAKE_MODULE_PATH already +# (such as when someone explicitly added it, or if it's the Magnum's modules/ +# dir in case of a superproject), add it as the first before all other. Set a +# flag to remove it again at the end, so the modules don't clash with Find +# modules of the same name from other projects. +if(_MAGNUM_DEPENDENCY_MODULE_DIR AND NOT _MAGNUM_DEPENDENCY_MODULE_DIR IN_LIST CMAKE_MODULE_PATH) + set(CMAKE_MODULE_PATH ${_MAGNUM_DEPENDENCY_MODULE_DIR} ${CMAKE_MODULE_PATH}) + set(_MAGNUM_REMOVE_DEPENDENCY_MODULE_DIR_FROM_CMAKE_PATH ON) +else() + unset(_MAGNUM_REMOVE_DEPENDENCY_MODULE_DIR_FROM_CMAKE_PATH) +endif() + +# Base Magnum library +if(NOT TARGET Magnum::Magnum) + add_library(Magnum::Magnum UNKNOWN IMPORTED) + + # Try to find both debug and release version + find_library(MAGNUM_LIBRARY_DEBUG Magnum-d) + find_library(MAGNUM_LIBRARY_RELEASE Magnum) + mark_as_advanced(MAGNUM_LIBRARY_DEBUG + MAGNUM_LIBRARY_RELEASE) + + # Set the _MAGNUM_LIBRARY variable based on what was found to use it in a + # FPHSA call below + if(MAGNUM_LIBRARY_DEBUG AND MAGNUM_LIBRARY_RELEASE) + set(_MAGNUM_LIBRARY MAGNUM_LIBRARY_RELEASE) + elseif(MAGNUM_LIBRARY_DEBUG) + set(_MAGNUM_LIBRARY MAGNUM_LIBRARY_DEBUG) + elseif(MAGNUM_LIBRARY_RELEASE) + set(_MAGNUM_LIBRARY MAGNUM_LIBRARY_RELEASE) + endif() + + if(MAGNUM_LIBRARY_RELEASE) + set_property(TARGET Magnum::Magnum APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_property(TARGET Magnum::Magnum PROPERTY + IMPORTED_LOCATION_RELEASE ${MAGNUM_LIBRARY_RELEASE}) + endif() + + if(MAGNUM_LIBRARY_DEBUG) + set_property(TARGET Magnum::Magnum APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_property(TARGET Magnum::Magnum PROPERTY + IMPORTED_LOCATION_DEBUG ${MAGNUM_LIBRARY_DEBUG}) + endif() + + # Include directories + set_property(TARGET Magnum::Magnum APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES + ${MAGNUM_INCLUDE_DIR}) + + # Dependent libraries + set_property(TARGET Magnum::Magnum APPEND PROPERTY INTERFACE_LINK_LIBRARIES + Corrade::Utility) +else() + set(MAGNUM_LIBRARY Magnum::Magnum) +endif() + +# Component distinction (listing them explicitly to avoid mistakes with finding +# components from other repositories) +set(_MAGNUM_LIBRARY_COMPONENTS + Audio DebugTools GL MaterialTools MeshTools Primitives SceneGraph + SceneTools Shaders ShaderTools Text TextureTools Trade + WindowlessEglApplication EglContext OpenGLTester) +# These libraries are excluded from DLL detection if Magnum is built as shared. +# Additionally, all *Application and *Context libraries are excluded as well. +set(_MAGNUM_LIBRARY_COMPONENTS_ALWAYS_STATIC + OpenGLTester) +set(_MAGNUM_PLUGIN_COMPONENTS + AnyAudioImporter AnyImageConverter AnyImageImporter AnySceneConverter + AnySceneImporter MagnumFont MagnumFontConverter ObjImporter + TgaImageConverter TgaImporter WavAudioImporter) +set(_MAGNUM_EXECUTABLE_COMPONENTS + imageconverter sceneconverter shaderconverter gl-info al-info) +# Audio and Vk libs aren't enabled by default, and none of the Context, +# Application, Tester libs nor plugins are. Keep in sync with Magnum's root +# CMakeLists.txt. +set(_MAGNUM_IMPLICITLY_ENABLED_COMPONENTS + DebugTools MeshTools SceneGraph Shaders ShaderTools Text TextureTools Trade + GL Primitives) +if(NOT CORRADE_TARGET_EMSCRIPTEN) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS Vk VulkanTester) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS_ALWAYS_STATIC VulkanTester) + list(APPEND _MAGNUM_EXECUTABLE_COMPONENTS vk-info) +endif() +if(NOT CORRADE_TARGET_ANDROID) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS Sdl2Application) +endif() +if(NOT CORRADE_TARGET_ANDROID AND NOT CORRADE_TARGET_IOS AND NOT CORRADE_TARGET_EMSCRIPTEN) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS GlfwApplication) +endif() +if(CORRADE_TARGET_ANDROID) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS AndroidApplication) +endif() +if(CORRADE_TARGET_EMSCRIPTEN) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS EmscriptenApplication) +endif() +if(CORRADE_TARGET_IOS) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS WindowlessIosApplication) +elseif(CORRADE_TARGET_APPLE AND NOT MAGNUM_TARGET_GLES) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS WindowlessCglApplication CglContext) +endif() +if(CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS GlxApplication XEglApplication WindowlessGlxApplication GlxContext) +endif() +if(CORRADE_TARGET_WINDOWS) + list(APPEND _MAGNUM_LIBRARY_COMPONENTS WindowlessWglApplication WglContext) +endif() +if(CORRADE_TARGET_UNIX OR CORRADE_TARGET_WINDOWS) + list(APPEND _MAGNUM_EXECUTABLE_COMPONENTS fontconverter distancefieldconverter) +endif() + +# Inter-component dependencies +set(_MAGNUM_Audio_DEPENDENCIES ) + +# Trade is used by CompareImage. If Trade is not enabled, CompareImage is not +# compiled at all. +set(_MAGNUM_DebugTools_DEPENDENCIES Trade) +set(_MAGNUM_DebugTools_Trade_DEPENDENCY_IS_OPTIONAL ON) +# MeshTools, Primitives, SceneGraph and Shaders are used only for GL renderers +# in DebugTools. All of this is optional, compiled in only if the base library +# was selected. +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_DebugTools_DEPENDENCIES MeshTools Primitives SceneGraph Shaders GL) + set(_MAGNUM_DebugTools_MeshTools_DEPENDENCY_IS_OPTIONAL ON) + set(_MAGNUM_DebugTools_Primitives_DEPENDENCY_IS_OPTIONAL ON) + set(_MAGNUM_DebugTools_SceneGraph_DEPENDENCY_IS_OPTIONAL ON) + set(_MAGNUM_DebugTools_Shaders_DEPENDENCY_IS_OPTIONAL ON) + set(_MAGNUM_DebugTools_GL_DEPENDENCY_IS_OPTIONAL ON) +endif() + +set(_MAGNUM_MaterialTools_DEPENDENCIES Trade) + +set(_MAGNUM_MeshTools_DEPENDENCIES Trade) +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_MeshTools_DEPENDENCIES GL) +endif() + +set(_MAGNUM_OpenGLTester_DEPENDENCIES GL) +if(MAGNUM_TARGET_EGL) + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessEglApplication) +elseif(CORRADE_TARGET_IOS) + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessIosApplication) +elseif(CORRADE_TARGET_APPLE) + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessCglApplication) +elseif(CORRADE_TARGET_UNIX) + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessGlxApplication) +elseif(CORRADE_TARGET_WINDOWS) + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessWglApplication) +endif() + +set(_MAGNUM_Primitives_DEPENDENCIES MeshTools Trade) +if(MAGNUM_TARGET_GL) + # GL not required by Primitives themselves, but transitively by MeshTools + list(APPEND _MAGNUM_Primitives_DEPENDENCIES GL) +endif() + +set(_MAGNUM_SceneGraph_DEPENDENCIES ) +set(_MAGNUM_SceneTools_DEPENDENCIES Trade) +set(_MAGNUM_Shaders_DEPENDENCIES ) +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_Shaders_DEPENDENCIES GL) +endif() + +set(_MAGNUM_Text_DEPENDENCIES TextureTools) +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_Text_DEPENDENCIES GL) +endif() + +set(_MAGNUM_TextureTools_DEPENDENCIES ) +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_TextureTools_DEPENDENCIES GL) +endif() + +set(_MAGNUM_Trade_DEPENDENCIES ) +set(_MAGNUM_VulkanTester_DEPENDENCIES Vk) +set(_MAGNUM_AndroidApplication_DEPENDENCIES GL) + +set(_MAGNUM_EmscriptenApplication_DEPENDENCIES) +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_EmscriptenApplication_DEPENDENCIES GL) +endif() + +set(_MAGNUM_GlfwApplication_DEPENDENCIES ) +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_GlfwApplication_DEPENDENCIES GL) +endif() + +set(_MAGNUM_GlxApplication_DEPENDENCIES GL) + +set(_MAGNUM_Sdl2Application_DEPENDENCIES ) +if(MAGNUM_TARGET_GL) + list(APPEND _MAGNUM_Sdl2Application_DEPENDENCIES GL) +endif() + +set(_MAGNUM_WindowlessCglApplication_DEPENDENCIES GL) +set(_MAGNUM_WindowlessEglApplication_DEPENDENCIES GL) +set(_MAGNUM_WindowlessGlxApplication_DEPENDENCIES GL) +set(_MAGNUM_WindowlessIosApplication_DEPENDENCIES GL) +set(_MAGNUM_WindowlessWglApplication_DEPENDENCIES GL) +set(_MAGNUM_XEglApplication_DEPENDENCIES GL) +set(_MAGNUM_CglContext_DEPENDENCIES GL) +set(_MAGNUM_EglContext_DEPENDENCIES GL) +set(_MAGNUM_GlxContext_DEPENDENCIES GL) +set(_MAGNUM_WglContext_DEPENDENCIES GL) + +set(_MAGNUM_MagnumFont_DEPENDENCIES Trade TgaImporter GL) # and below +set(_MAGNUM_MagnumFontConverter_DEPENDENCIES Trade TgaImageConverter) # and below +set(_MAGNUM_ObjImporter_DEPENDENCIES MeshTools) # and below +foreach(_component ${_MAGNUM_PLUGIN_COMPONENTS}) + if(_component MATCHES ".+AudioImporter") + list(APPEND _MAGNUM_${_component}_DEPENDENCIES Audio) + elseif(_component MATCHES ".+ShaderConverter") + list(APPEND _MAGNUM_${_component}_DEPENDENCIES ShaderTools) + elseif(_component MATCHES ".+(Importer|ImageConverter|SceneConverter)") + list(APPEND _MAGNUM_${_component}_DEPENDENCIES Trade) + elseif(_component MATCHES ".+(Font|FontConverter)") + list(APPEND _MAGNUM_${_component}_DEPENDENCIES Text TextureTools) + endif() +endforeach() + +# Ensure that all inter-component dependencies are specified as well +set(_MAGNUM_ADDITIONAL_COMPONENTS ) +foreach(_component ${Magnum_FIND_COMPONENTS}) + # Mark the dependencies as required if the component is also required, but + # only if they themselves are not optional (for example parts of DebugTools + # are present only if their respective base library is compiled) + if(Magnum_FIND_REQUIRED_${_component}) + foreach(_dependency ${_MAGNUM_${_component}_DEPENDENCIES}) + if(NOT _MAGNUM_${_component}_${_dependency}_DEPENDENCY_IS_OPTIONAL) + set(Magnum_FIND_REQUIRED_${_dependency} TRUE) + endif() + endforeach() + endif() + + list(APPEND _MAGNUM_ADDITIONAL_COMPONENTS ${_MAGNUM_${_component}_DEPENDENCIES}) +endforeach() + +# Join the lists, remove duplicate components +set(_MAGNUM_ORIGINAL_FIND_COMPONENTS ${Magnum_FIND_COMPONENTS}) +if(_MAGNUM_ADDITIONAL_COMPONENTS) + list(INSERT Magnum_FIND_COMPONENTS 0 ${_MAGNUM_ADDITIONAL_COMPONENTS}) +endif() +if(Magnum_FIND_COMPONENTS) + list(REMOVE_DUPLICATES Magnum_FIND_COMPONENTS) +endif() + +# Special cases of include paths. Libraries not listed here have a path suffix +# and include name derived from the library name in the loop below. +set(_MAGNUM_MATERIALTOOLS_INCLUDE_PATH_NAMES PhongToPbrMetallicRoughness.h) +set(_MAGNUM_MESHTOOLS_INCLUDE_PATH_NAMES CompressIndices.h) +set(_MAGNUM_OPENGLTESTER_INCLUDE_PATH_SUFFIX Magnum/GL) +set(_MAGNUM_VULKANTESTER_INCLUDE_PATH_SUFFIX Magnum/Vk) +set(_MAGNUM_PRIMITIVES_INCLUDE_PATH_NAMES Cube.h) +set(_MAGNUM_SCENETOOLS_INCLUDE_PATH_NAMES Hierarchy.h) + +# Find all components. Maintain a list of components that'll need to have +# their optional dependencies checked. +set(_MAGNUM_OPTIONAL_DEPENDENCIES_TO_ADD ) +foreach(_component ${Magnum_FIND_COMPONENTS}) + string(TOUPPER ${_component} _COMPONENT) + + # Create imported target in case the library is found. If the project is + # added as subproject to CMake, the target already exists and all the + # required setup is already done from the build tree. + if(TARGET "Magnum::${_component}") # Quotes to "fix" KDE's higlighter + set(Magnum_${_component}_FOUND TRUE) + else() + # Library components + if(_component IN_LIST _MAGNUM_LIBRARY_COMPONENTS) + # Include path names to find, unless specified above already. + # Application and context libraries are a special case as well. + if(_component MATCHES ".+Application") + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/Platform) + elseif(_component MATCHES ".+Context") + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/Platform) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES GLContext.h) + endif() + if(NOT _MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/${_component}) + endif() + if(NOT _MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES ${_component}.h) + endif() + + # Try to find both debug and release version + find_library(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG Magnum${_component}-d) + find_library(MAGNUM_${_COMPONENT}_LIBRARY_RELEASE Magnum${_component}) + mark_as_advanced(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG + MAGNUM_${_COMPONENT}_LIBRARY_RELEASE) + + # On Windows, if we have a dynamic build of given library, find the + # DLLs as well. Abuse find_program() since the DLLs should be + # alongside usual executables. On MinGW they however have a lib + # prefix. + if(CORRADE_TARGET_WINDOWS AND NOT MAGNUM_BUILD_STATIC AND NOT _component IN_LIST _MAGNUM_LIBRARY_COMPONENTS_ALWAYS_STATIC AND NOT _component MATCHES ".+Application" AND NOT _component MATCHES ".+Context") + find_program(MAGNUM_${_COMPONENT}_DLL_DEBUG ${CMAKE_SHARED_LIBRARY_PREFIX}Magnum${_component}-d.dll) + find_program(MAGNUM_${_COMPONENT}_DLL_RELEASE ${CMAKE_SHARED_LIBRARY_PREFIX}Magnum${_component}.dll) + mark_as_advanced(MAGNUM_${_COMPONENT}_DLL_DEBUG + MAGNUM_${_COMPONENT}_DLL_RELEASE) + # If not on Windows or on a static build, unset the DLL variables + # to avoid leaks when switching shared and static builds + else() + unset(MAGNUM_${_COMPONENT}_DLL_DEBUG CACHE) + unset(MAGNUM_${_COMPONENT}_DLL_RELEASE CACHE) + endif() + + # Plugin components + elseif(_component IN_LIST _MAGNUM_PLUGIN_COMPONENTS) + # AudioImporter plugin specific name suffixes + if(_component MATCHES ".+AudioImporter$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX audioimporters) + + # Audio importer class is Audio::*Importer, thus we need to + # convert *AudioImporter.h to *Importer.h + string(REPLACE "AudioImporter" "Importer" _MAGNUM_${_COMPONENT}_HEADER_NAME "${_component}") + if(NOT _MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES ${_MAGNUM_${_COMPONENT}_HEADER_NAME}.h) + endif() + + # ShaderConverter plugin specific name suffixes + elseif(_component MATCHES ".+ShaderConverter$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX shaderconverters) + + # Importer plugin specific name suffixes + elseif(_component MATCHES ".+Importer$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX importers) + + # Font plugin specific name suffixes + elseif(_component MATCHES ".+Font$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX fonts) + + # ImageConverter plugin specific name suffixes + elseif(_component MATCHES ".+ImageConverter$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX imageconverters) + + # SceneConverter plugin specific name suffixes + elseif(_component MATCHES ".+SceneConverter$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX sceneconverters) + + # FontConverter plugin specific name suffixes + elseif(_component MATCHES ".+FontConverter$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX fontconverters) + endif() + + # Include path names to find, unless specified above + if(NOT _MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX MagnumPlugins/${_component}) + endif() + if(NOT _MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES ${_component}.h) + endif() + + # Dynamic plugins don't have any prefix (e.g. `lib` on Linux), + # search with empty prefix and then reset that back so we don't + # accidentally break something else + set(_tmp_prefixes "${CMAKE_FIND_LIBRARY_PREFIXES}") + set(CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES};") + + # Try to find both debug and release version. Dynamic and static + # debug libraries are in different places. Static debug plugins are + # in magnum/ with a -d suffix while dynamic debug plugins are in + # magnum-d/ with no suffix. Problem is that Vcpkg's library linking + # automagic needs the static libs to be in the root library + # directory along with everything else and so we need to search for + # the -d suffixed version *before* the unsuffixed so it doesn't + # pick the release library for both debug and release. + find_library(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG ${_component}-d + PATH_SUFFIXES magnum/${_MAGNUM_${_COMPONENT}_PATH_SUFFIX}) + find_library(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG ${_component} + PATH_SUFFIXES magnum-d/${_MAGNUM_${_COMPONENT}_PATH_SUFFIX}) + find_library(MAGNUM_${_COMPONENT}_LIBRARY_RELEASE ${_component} + PATH_SUFFIXES magnum/${_MAGNUM_${_COMPONENT}_PATH_SUFFIX}) + mark_as_advanced(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG + MAGNUM_${_COMPONENT}_LIBRARY_RELEASE) + + # Reset back + set(CMAKE_FIND_LIBRARY_PREFIXES "${_tmp_prefixes}") + + # Executables + elseif(_component IN_LIST _MAGNUM_EXECUTABLE_COMPONENTS) + find_program(MAGNUM_${_COMPONENT}_EXECUTABLE magnum-${_component}) + mark_as_advanced(MAGNUM_${_COMPONENT}_EXECUTABLE) + + # Something unknown, skip. FPHSA will take care of handling this below. + else() + continue() + endif() + + # Find library/plugin includes + if(_component IN_LIST _MAGNUM_LIBRARY_COMPONENTS OR _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS) + find_path(_MAGNUM_${_COMPONENT}_INCLUDE_DIR + NAMES ${_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES} + HINTS ${MAGNUM_INCLUDE_DIR}/${_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX}) + mark_as_advanced(_MAGNUM_${_COMPONENT}_INCLUDE_DIR) + endif() + + # Determine if the plugin is static or dynamic by reading the + # per-plugin config file. Plugins use this for automatic import if + # static. + # TODO: add per-library configure.h as well, for consistency with + # extras, plugins and integration + if(_component IN_LIST _MAGNUM_PLUGIN_COMPONENTS) + find_file(_MAGNUM_${_COMPONENT}_CONFIGURE_FILE configure.h + HINTS ${_MAGNUM_${_COMPONENT}_INCLUDE_DIR}) + mark_as_advanced(_MAGNUM_${_COMPONENT}_CONFIGURE_FILE) + + # If the file wasn't found, skip this so it fails on the FPHSA + # below and not right here. + if(_MAGNUM_${_COMPONENT}_CONFIGURE_FILE) + file(READ ${_MAGNUM_${_COMPONENT}_CONFIGURE_FILE} _magnumPluginConfigure) + string(REGEX REPLACE ";" "\\\\;" _magnumPluginConfigure "${_magnumPluginConfigure}") + string(REGEX REPLACE "\n" ";" _magnumPluginConfigure "${_magnumPluginConfigure}") + list(FIND _magnumPluginConfigure "#define MAGNUM_${_COMPONENT}_BUILD_STATIC" _magnumPluginBuildStatic) + if(NOT _magnumPluginBuildStatic EQUAL -1) + # The variable is inconsistently named between C++ and + # CMake in extras, plugins and integration, keep it + # underscored / private until that's resolved + set(_MAGNUM_${_COMPONENT}_BUILD_STATIC ON) + endif() + endif() + endif() + + # Decide if the library was found. If not, skip the rest, which + # populates the target properties and finds additional dependencies. + # This means that the rest can also rely on that e.g. FindEGL.cmake is + # present in _MAGNUM_DEPENDENCY_MODULE_DIR -- given that the library + # needing EGL was found, it likely also installed FindEGL for itself. + if( + # If the component is a library, it should have the include dir + ((_component IN_LIST _MAGNUM_LIBRARY_COMPONENTS OR _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS) AND _MAGNUM_${_COMPONENT}_INCLUDE_DIR AND ( + # And it should have a debug library, and a DLL found if + # expected + (MAGNUM_${_COMPONENT}_LIBRARY_DEBUG AND ( + NOT DEFINED MAGNUM_${_COMPONENT}_DLL_DEBUG OR + MAGNUM_${_COMPONENT}_DLL_DEBUG)) OR + # Or have a release library, and a DLL found if expected + (MAGNUM_${_COMPONENT}_LIBRARY_RELEASE AND ( + NOT DEFINED MAGNUM_${_COMPONENT}_DLL_RELEASE OR + MAGNUM_${_COMPONENT}_DLL_RELEASE)))) OR + # If the component is an executable, it should have just the + # location + (_component IN_LIST _MAGNUM_EXECUTABLE_COMPONENTS AND MAGNUM_${_COMPONENT}_EXECUTABLE) + ) + set(Magnum_${_component}_FOUND TRUE) + else() + set(Magnum_${_component}_FOUND FALSE) + continue() + endif() + + # Target and location for libraries + if(_component IN_LIST _MAGNUM_LIBRARY_COMPONENTS) + if(MAGNUM_BUILD_STATIC OR _component IN_LIST _MAGNUM_LIBRARY_COMPONENTS_ALWAYS_STATIC OR _component MATCHES ".+Application" OR _component MATCHES ".+Context") + add_library(Magnum::${_component} STATIC IMPORTED) + else() + add_library(Magnum::${_component} SHARED IMPORTED) + endif() + + foreach(_CONFIG DEBUG RELEASE) + if(NOT MAGNUM_${_COMPONENT}_LIBRARY_${_CONFIG}) + continue() + endif() + + set_property(TARGET Magnum::${_component} APPEND PROPERTY + IMPORTED_CONFIGURATIONS ${_CONFIG}) + # Unfortunately for a DLL the two properties are swapped out, + # *.lib goes to IMPLIB, so it's duplicated like this + if(DEFINED MAGNUM_${_COMPONENT}_DLL_${_CONFIG}) + # Quotes to "fix" KDE's higlighter + set_target_properties("Magnum::${_component}" PROPERTIES + IMPORTED_LOCATION_${_CONFIG} ${MAGNUM_${_COMPONENT}_DLL_${_CONFIG}} + IMPORTED_IMPLIB_${_CONFIG} ${MAGNUM_${_COMPONENT}_LIBRARY_${_CONFIG}}) + else() + set_property(TARGET Magnum::${_component} PROPERTY + IMPORTED_LOCATION_${_CONFIG} ${MAGNUM_${_COMPONENT}_LIBRARY_${_CONFIG}}) + endif() + endforeach() + + # Target and location for plugins. Not dealing with DLL locations for + # those. + elseif(_component IN_LIST _MAGNUM_PLUGIN_COMPONENTS) + add_library(Magnum::${_component} UNKNOWN IMPORTED) + + foreach(_CONFIG DEBUG RELEASE) + if(NOT MAGNUM_${_COMPONENT}_LIBRARY_${_CONFIG}) + continue() + endif() + + set_property(TARGET Magnum::${_component} APPEND PROPERTY + IMPORTED_CONFIGURATIONS ${_CONFIG}) + set_property(TARGET Magnum::${_component} PROPERTY + IMPORTED_LOCATION_${_CONFIG} ${MAGNUM_${_COMPONENT}_LIBRARY_${_CONFIG}}) + endforeach() + + # Target and location for executable components + elseif(_component IN_LIST _MAGNUM_EXECUTABLE_COMPONENTS) + add_executable(Magnum::${_component} IMPORTED) + + set_property(TARGET Magnum::${_component} PROPERTY + IMPORTED_LOCATION ${MAGNUM_${_COMPONENT}_EXECUTABLE}) + endif() + + # Applications + if(_component MATCHES ".+Application") + # Android application dependencies + if(_component STREQUAL AndroidApplication) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES android EGL::EGL) + + # Emscripten application dependencies + elseif(_component STREQUAL EmscriptenApplication) + # Emscripten has various stuff implemented in JS + if(CORRADE_TARGET_EMSCRIPTEN) + find_file(MAGNUM_PLATFORM_JS MagnumPlatform.js + PATH_SUFFIXES lib) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + # TODO switch to INTERFACE_LINK_OPTIONS and SHELL: once + # we require CMake 3.13 unconditionally + INTERFACE_LINK_LIBRARIES "--js-library ${MAGNUM_PLATFORM_JS}") + endif() + + # GLFW application dependencies + elseif(_component STREQUAL GlfwApplication) + find_package(GLFW) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES GLFW::GLFW) + # Use the Foundation framework on Apple to query the DPI awareness + if(CORRADE_TARGET_APPLE) + find_library(_MAGNUM_APPLE_FOUNDATION_FRAMEWORK_LIBRARY Foundation) + mark_as_advanced(_MAGNUM_APPLE_FOUNDATION_FRAMEWORK_LIBRARY) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${_MAGNUM_APPLE_FOUNDATION_FRAMEWORK_LIBRARY}) + # Needed for opt-in DPI queries + elseif(CORRADE_TARGET_UNIX) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS}) + endif() + + # With GLVND (since CMake 3.10) we need to explicitly link to + # GLX/EGL because libOpenGL doesn't provide it. For EGL we have + # our own EGL find module, which makes things simpler. The + # upstream FindOpenGL is anything but simple. Also can't use + # OpenGL_OpenGL_FOUND, because that one is set also if GLVND is + # *not* found. WTF. Also can't just check for + # OPENGL_opengl_LIBRARY because that's set even if + # OpenGL_GL_PREFERENCE is explicitly set to LEGACY. + if(MAGNUM_TARGET_GL) + if(MAGNUM_TARGET_EGL) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND + PROPERTY INTERFACE_LINK_LIBRARIES EGL::EGL) + elseif(CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE) + find_package(OpenGL) + if(OPENGL_opengl_LIBRARY AND OpenGL_GL_PREFERENCE STREQUAL GLVND) + set_property(TARGET Magnum::${_component} APPEND + PROPERTY INTERFACE_LINK_LIBRARIES OpenGL::GLX) + endif() + endif() + endif() + + # SDL2 application dependencies + elseif(_component STREQUAL Sdl2Application) + find_package(SDL2) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES SDL2::SDL2) + # Use the Foundation framework on Apple to query the DPI awareness + if(CORRADE_TARGET_APPLE) + find_library(_MAGNUM_APPLE_FOUNDATION_FRAMEWORK_LIBRARY Foundation) + mark_as_advanced(_MAGNUM_APPLE_FOUNDATION_FRAMEWORK_LIBRARY) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${_MAGNUM_APPLE_FOUNDATION_FRAMEWORK_LIBRARY}) + # Needed for opt-in DPI queries + elseif(CORRADE_TARGET_UNIX) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${CMAKE_DL_LIBS}) + # Emscripten has various stuff implemented in JS + elseif(CORRADE_TARGET_EMSCRIPTEN) + find_file(MAGNUM_PLATFORM_JS MagnumPlatform.js + PATH_SUFFIXES lib) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + # TODO switch to INTERFACE_LINK_OPTIONS and SHELL: once + # we require CMake 3.13 unconditionally + INTERFACE_LINK_LIBRARIES "--js-library ${MAGNUM_PLATFORM_JS}") + endif() + + # With GLVND (since CMake 3.10) we need to explicitly link to + # GLX/EGL because libOpenGL doesn't provide it. For EGL we have + # our own EGL find module, which makes things simpler. The + # upstream FindOpenGL is anything but simple. Also can't use + # OpenGL_OpenGL_FOUND, because that one is set also if GLVND is + # *not* found. WTF. Also can't just check for + # OPENGL_opengl_LIBRARY because that's set even if + # OpenGL_GL_PREFERENCE is explicitly set to LEGACY. + if(MAGNUM_TARGET_GL) + if(MAGNUM_TARGET_EGL) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND + PROPERTY INTERFACE_LINK_LIBRARIES EGL::EGL) + elseif(CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE) + find_package(OpenGL) + if(OPENGL_opengl_LIBRARY AND OpenGL_GL_PREFERENCE STREQUAL GLVND) + set_property(TARGET Magnum::${_component} APPEND + PROPERTY INTERFACE_LINK_LIBRARIES OpenGL::GLX) + endif() + endif() + endif() + + # (Windowless) GLX application dependencies + elseif(_component STREQUAL GlxApplication OR _component STREQUAL WindowlessGlxApplication) + find_package(X11) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_INCLUDE_DIRECTORIES ${X11_INCLUDE_DIR}) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${X11_LIBRARIES}) + + # With GLVND (since CMake 3.10) we need to explicitly link to + # GLX because libOpenGL doesn't provide it. Also can't use + # OpenGL_OpenGL_FOUND, because that one is set also if GLVND is + # *not* found. WTF. Also can't just check for + # OPENGL_opengl_LIBRARY because that's set even if + # OpenGL_GL_PREFERENCE is explicitly set to LEGACY. + # + # If MAGNUM_TARGET_GLES and MAGNUM_TARGET_EGL is set, these + # applications can be built only if GLVND is available as + # otherwise there would be a conflict between libGL and + # libGLES. Thus, if GLVND is not available, it won't link + # libGLX here, but that shouldn't be a problem since the + # application library won't exist either. + find_package(OpenGL) + if(OPENGL_opengl_LIBRARY AND OpenGL_GL_PREFERENCE STREQUAL GLVND) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES OpenGL::GLX) + endif() + + # Windowless CGL application has no additional dependencies + + # Windowless EGL application dependencies + elseif(_component STREQUAL WindowlessEglApplication) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES EGL::EGL) + + # Windowless iOS application dependencies + elseif(_component STREQUAL WindowlessIosApplication) + # We need to link to Foundation framework to use ObjC + find_library(_MAGNUM_IOS_FOUNDATION_FRAMEWORK_LIBRARY Foundation) + mark_as_advanced(_MAGNUM_IOS_FOUNDATION_FRAMEWORK_LIBRARY) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES EGL::EGL ${_MAGNUM_IOS_FOUNDATION_FRAMEWORK_LIBRARY}) + + # Windowless WGL application has no additional dependencies + + # X/EGL application dependencies + elseif(_component STREQUAL XEglApplication) + find_package(EGL) + find_package(X11) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_INCLUDE_DIRECTORIES ${X11_INCLUDE_DIR}) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES EGL::EGL ${X11_LIBRARIES}) + endif() + + # Context libraries + elseif(_component MATCHES ".+Context") + # GLX context dependencies + if(_component STREQUAL GlxContext) + # With GLVND (since CMake 3.10) we need to explicitly link to + # GLX because libOpenGL doesn't provide it. Also can't use + # OpenGL_OpenGL_FOUND, because that one is set also if GLVND is + # *not* found. If GLVND is not used, link to X11 instead. Also + # can't just check for OPENGL_opengl_LIBRARY because that's set + # even if OpenGL_GL_PREFERENCE is explicitly set to LEGACY. + find_package(OpenGL) + if(OPENGL_opengl_LIBRARY AND OpenGL_GL_PREFERENCE STREQUAL GLVND) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES OpenGL::GLX) + else() + find_package(X11) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_INCLUDE_DIRECTORIES ${X11_INCLUDE_DIR}) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${X11_LIBRARIES}) + endif() + + # EGL context dependencies + elseif(_component STREQUAL EglContext) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES EGL::EGL) + endif() + + # No additional dependencies for CGL context + # No additional dependencies for WGL context + + # Audio library + elseif(_component STREQUAL Audio) + find_package(OpenAL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES OpenAL::OpenAL) + + # No special setup for DebugTools library + + # GL library + elseif(_component STREQUAL GL) + if(NOT MAGNUM_TARGET_GLES OR (MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_EGL AND NOT CORRADE_TARGET_IOS)) + # If the GLVND library (CMake 3.10+) was found, link to the + # imported target. Otherwise (and also on all systems except + # Linux) link to the classic libGL. Can't use + # OpenGL_OpenGL_FOUND, because that one is set also if GLVND is + # *not* found. WTF. Also can't just check for + # OPENGL_opengl_LIBRARY because that's set even if + # OpenGL_GL_PREFERENCE is explicitly set to LEGACY. + find_package(OpenGL REQUIRED) + if(OPENGL_opengl_LIBRARY AND OpenGL_GL_PREFERENCE STREQUAL GLVND) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES OpenGL::OpenGL) + else() + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${OPENGL_gl_LIBRARY}) + endif() + elseif(MAGNUM_TARGET_GLES2) + find_package(OpenGLES2 REQUIRED) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES OpenGLES2::OpenGLES2) + else() + find_package(OpenGLES3 REQUIRED) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES OpenGLES3::OpenGLES3) + endif() + + # No special setup for MaterialTools library + # No special setup for MeshTools library + # No special setup for OpenGLTester library + # No special setup for VulkanTester library + # No special setup for Primitives library + # No special setup for SceneGraph library + # No special setup for SceneTools library + # No special setup for ShaderTools library + # No special setup for Shaders library + # No special setup for Text library + # No special setup for TextureTools library + # No special setup for Trade library + + # Vk library + elseif(_component STREQUAL Vk) + find_package(Vulkan REQUIRED) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Vulkan::Vulkan) + endif() + + # No special setup for AnyAudioImporter plugin + # No special setup for AnyImageConverter plugin + # No special setup for AnyImageImporter plugin + # No special setup for AnySceneImporter plugin + # No special setup for MagnumFont plugin + # No special setup for MagnumFontConverter plugin + # No special setup for ObjImporter plugin + # No special setup for TgaImageConverter plugin + # No special setup for TgaImporter plugin + # No special setup for WavAudioImporter plugin + + # Automatic import of static plugins + if(_component IN_LIST _MAGNUM_PLUGIN_COMPONENTS AND _MAGNUM_${_COMPONENT}_BUILD_STATIC) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_SOURCES ${_MAGNUM_${_COMPONENT}_INCLUDE_DIR}/importStaticPlugin.cpp) + endif() + + # Link to core Magnum library, add inter-library dependencies. If there + # are optional dependencies, defer adding them to later once we know if + # they were found or not. + if(_component IN_LIST _MAGNUM_LIBRARY_COMPONENTS OR _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS) + foreach(_dependency ${_MAGNUM_${_component}_CORRADE_DEPENDENCIES}) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Corrade::${_dependency}) + endforeach() + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Magnum::Magnum) + set(_MAGNUM_${_component}_OPTIONAL_DEPENDENCIES_TO_ADD ) + foreach(_dependency ${_MAGNUM_${_component}_DEPENDENCIES}) + if(NOT _MAGNUM_${_component}_${_dependency}_DEPENDENCY_IS_OPTIONAL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Magnum::${_dependency}) + else() + list(APPEND _MAGNUM_${_component}_OPTIONAL_DEPENDENCIES_TO_ADD + ${_dependency}) + endif() + endforeach() + if(_MAGNUM_${_component}_OPTIONAL_DEPENDENCIES_TO_ADD) + list(APPEND _MAGNUM_OPTIONAL_DEPENDENCIES_TO_ADD ${_component}) + endif() + endif() + endif() + + # Global aliases for Windowless*Application, *Application and *Context + # components. If already set, unset them to avoid ambiguity. + if(_component MATCHES "Windowless.+Application") + if(NOT DEFINED _MAGNUM_WINDOWLESSAPPLICATION_ALIAS) + set(_MAGNUM_WINDOWLESSAPPLICATION_ALIAS Magnum::${_component}) + else() + unset(_MAGNUM_WINDOWLESSAPPLICATION_ALIAS) + endif() + elseif(_component MATCHES ".+Application") + if(NOT DEFINED _MAGNUM_APPLICATION_ALIAS) + set(_MAGNUM_APPLICATION_ALIAS Magnum::${_component}) + else() + unset(_MAGNUM_APPLICATION_ALIAS) + endif() + elseif(_component MATCHES ".+Context") + if(NOT DEFINED _MAGNUM_GLCONTEXT_ALIAS) + set(_MAGNUM_GLCONTEXT_ALIAS Magnum::${_component}) + else() + unset(_MAGNUM_GLCONTEXT_ALIAS) + endif() + endif() +endforeach() + +# Emscripten-specific files and flags +if(CORRADE_TARGET_EMSCRIPTEN) + find_file(MAGNUM_EMSCRIPTENAPPLICATION_JS EmscriptenApplication.js + PATH_SUFFIXES share/magnum) + find_file(MAGNUM_WINDOWLESSEMSCRIPTENAPPLICATION_JS WindowlessEmscriptenApplication.js + PATH_SUFFIXES share/magnum) + find_file(MAGNUM_WEBAPPLICATION_CSS WebApplication.css + PATH_SUFFIXES share/magnum) + mark_as_advanced( + MAGNUM_EMSCRIPTENAPPLICATION_JS + MAGNUM_WINDOWLESSEMSCRIPTENAPPLICATION_JS + MAGNUM_WEBAPPLICATION_CSS) + set(MAGNUM_EXTRAS_NEEDED + MAGNUM_EMSCRIPTENAPPLICATION_JS + MAGNUM_WINDOWLESSEMSCRIPTENAPPLICATION_JS + MAGNUM_WEBAPPLICATION_CSS) +endif() + +# For CMake 3.16+ with REASON_FAILURE_MESSAGE, provide additional potentially +# useful info about the failed components. +if(NOT CMAKE_VERSION VERSION_LESS 3.16) + set(_MAGNUM_REASON_FAILURE_MESSAGE ) + # Go only through the originally specified find_package() components, not + # the dependencies added by us afterwards + foreach(_component ${_MAGNUM_ORIGINAL_FIND_COMPONENTS}) + if(Magnum_${_component}_FOUND) + continue() + endif() + + # If it's not known at all, tell the user -- it might be a new library + # and an old Find module, or something platform-specific. + if(NOT _component IN_LIST _MAGNUM_LIBRARY_COMPONENTS AND NOT _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS AND NOT _component IN_LIST _MAGNUM_EXECUTABLE_COMPONENTS) + list(APPEND _MAGNUM_REASON_FAILURE_MESSAGE "${_component} is not a known component on this platform.") + # Otherwise, if it's not among implicitly built components, hint that + # the user may need to enable it + # TODO: currently, the _FOUND variable doesn't reflect if dependencies + # were found. When it will, this needs to be updated to avoid + # misleading messages. + elseif(NOT _component IN_LIST _MAGNUM_IMPLICITLY_ENABLED_COMPONENTS) + string(TOUPPER ${_component} _COMPONENT) + list(APPEND _MAGNUM_REASON_FAILURE_MESSAGE "${_component} is not built by default. Make sure you enabled MAGNUM_WITH_${_COMPONENT} when building Magnum.") + # Otherwise we have no idea. Better be silent than to print something + # misleading. + else() + endif() + endforeach() + + string(REPLACE ";" " " _MAGNUM_REASON_FAILURE_MESSAGE "${_MAGNUM_REASON_FAILURE_MESSAGE}") + set(_MAGNUM_REASON_FAILURE_MESSAGE REASON_FAILURE_MESSAGE "${_MAGNUM_REASON_FAILURE_MESSAGE}") +endif() + +# Remove Magnum's dependency module dir from CMAKE_MODULE_PATH again. Do it +# before the FPHSA call which may exit early in case of a failure. +if(_MAGNUM_REMOVE_DEPENDENCY_MODULE_DIR_FROM_CMAKE_PATH) + list(REMOVE_ITEM CMAKE_MODULE_PATH ${_MAGNUM_DEPENDENCY_MODULE_DIR}) + unset(_MAGNUM_REMOVE_DEPENDENCY_MODULE_DIR_FROM_CMAKE_PATH) +endif() + +# Complete the check with also all components +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Magnum + REQUIRED_VARS MAGNUM_INCLUDE_DIR ${_MAGNUM_LIBRARY} ${MAGNUM_EXTRAS_NEEDED} + HANDLE_COMPONENTS + ${_MAGNUM_REASON_FAILURE_MESSAGE}) + +# Components with optional dependencies -- add them once we know if they were +# found or not. +foreach(_component ${_MAGNUM_OPTIONAL_DEPENDENCIES_TO_ADD}) + foreach(_dependency ${_MAGNUM_${_component}_OPTIONAL_DEPENDENCIES_TO_ADD}) + if(Magnum_${_dependency}_FOUND) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Magnum::${_dependency}) + endif() + endforeach() +endforeach() + +# Create Windowless*Application, *Application and *Context aliases +# TODO: ugh why can't I make an alias of IMPORTED target? +if(_MAGNUM_WINDOWLESSAPPLICATION_ALIAS AND NOT TARGET Magnum::WindowlessApplication) + get_target_property(_MAGNUM_WINDOWLESSAPPLICATION_ALIASED_TARGET ${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS} ALIASED_TARGET) + if(_MAGNUM_WINDOWLESSAPPLICATION_ALIASED_TARGET) + add_library(Magnum::WindowlessApplication ALIAS ${_MAGNUM_WINDOWLESSAPPLICATION_ALIASED_TARGET}) + else() + add_library(Magnum::WindowlessApplication UNKNOWN IMPORTED) + foreach(property IMPORTED_CONFIGURATIONS INTERFACE_INCLUDE_DIRECTORIES INTERFACE_COMPILE_DEFINITIONS INTERFACE_COMPILE_OPTIONS INTERFACE_LINK_LIBRARIES) + get_target_property(_MAGNUM_WINDOWLESSAPPLICATION_${property} ${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS} ${property}) + if(_MAGNUM_WINDOWLESSAPPLICATION_${property}) + set_target_properties(Magnum::WindowlessApplication PROPERTIES + ${property} "${_MAGNUM_WINDOWLESSAPPLICATION_${property}}") + endif() + endforeach() + get_target_property(_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_LOCATION_RELEASE ${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS} IMPORTED_LOCATION_RELEASE) + get_target_property(_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_LOCATION_DEBUG ${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS} IMPORTED_LOCATION_DEBUG) + if(_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_LOCATION_RELEASE) + set_target_properties(Magnum::WindowlessApplication PROPERTIES + IMPORTED_LOCATION_RELEASE ${_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_LOCATION_RELEASE}) + endif() + if(_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_LOCATION_DEBUG) + set_target_properties(Magnum::WindowlessApplication PROPERTIES + IMPORTED_LOCATION_DEBUG ${_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_LOCATION_DEBUG}) + endif() + endif() + # Prevent creating the alias again + unset(_MAGNUM_WINDOWLESSAPPLICATION_ALIAS) +endif() +if(_MAGNUM_APPLICATION_ALIAS AND NOT TARGET Magnum::Application) + get_target_property(_MAGNUM_APPLICATION_ALIASED_TARGET ${_MAGNUM_APPLICATION_ALIAS} ALIASED_TARGET) + if(_MAGNUM_APPLICATION_ALIASED_TARGET) + add_library(Magnum::Application ALIAS ${_MAGNUM_APPLICATION_ALIASED_TARGET}) + else() + add_library(Magnum::Application UNKNOWN IMPORTED) + foreach(property IMPORTED_CONFIGURATIONS INTERFACE_INCLUDE_DIRECTORIES INTERFACE_COMPILE_DEFINITIONS INTERFACE_COMPILE_OPTIONS INTERFACE_LINK_LIBRARIES) + get_target_property(_MAGNUM_APPLICATION_${property} + ${_MAGNUM_APPLICATION_ALIAS} ${property}) + if(_MAGNUM_APPLICATION_${property}) + set_target_properties(Magnum::Application PROPERTIES ${property} + "${_MAGNUM_APPLICATION_${property}}") + endif() + endforeach() + get_target_property(_MAGNUM_APPLICATION_IMPORTED_LOCATION_RELEASE ${_MAGNUM_APPLICATION_ALIAS} IMPORTED_LOCATION_RELEASE) + get_target_property(_MAGNUM_APPLICATION_IMPORTED_LOCATION_DEBUG ${_MAGNUM_APPLICATION_ALIAS} IMPORTED_LOCATION_DEBUG) + if(_MAGNUM_APPLICATION_IMPORTED_LOCATION_RELEASE) + set_target_properties(Magnum::Application PROPERTIES + IMPORTED_LOCATION_RELEASE ${_MAGNUM_APPLICATION_IMPORTED_LOCATION_RELEASE}) + endif() + if(_MAGNUM_APPLICATION_IMPORTED_LOCATION_DEBUG) + set_target_properties(Magnum::Application PROPERTIES + IMPORTED_LOCATION_DEBUG ${_MAGNUM_APPLICATION_IMPORTED_LOCATION_DEBUG}) + endif() + endif() + # Prevent creating the alias again + unset(_MAGNUM_APPLICATION_ALIAS) +endif() +if(_MAGNUM_GLCONTEXT_ALIAS AND NOT TARGET Magnum::GLContext) + get_target_property(_MAGNUM_GLCONTEXT_ALIASED_TARGET ${_MAGNUM_GLCONTEXT_ALIAS} ALIASED_TARGET) + if(_MAGNUM_GLCONTEXT_ALIASED_TARGET) + add_library(Magnum::GLContext ALIAS ${_MAGNUM_GLCONTEXT_ALIASED_TARGET}) + else() + add_library(Magnum::GLContext UNKNOWN IMPORTED) + foreach(property IMPORTED_CONFIGURATIONS INTERFACE_INCLUDE_DIRECTORIES INTERFACE_COMPILE_DEFINITIONS INTERFACE_COMPILE_OPTIONS INTERFACE_LINK_LIBRARIES) + get_target_property(_MAGNUM_GLCONTEXT_${property} ${_MAGNUM_GLCONTEXT_ALIAS} ${property}) + if(_MAGNUM_GLCONTEXT_${property}) + set_target_properties(Magnum::GLContext PROPERTIES ${property} + "${_MAGNUM_GLCONTEXT_${property}}") + endif() + endforeach() + get_target_property(_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_RELEASE ${_MAGNUM_GLCONTEXT_ALIAS} IMPORTED_LOCATION_RELEASE) + get_target_property(_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_DEBUG ${_MAGNUM_GLCONTEXT_ALIAS} IMPORTED_LOCATION_DEBUG) + if(_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_RELEASE) + set_target_properties(Magnum::GLContext PROPERTIES + IMPORTED_LOCATION_RELEASE ${_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_RELEASE}) + endif() + if(_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_DEBUG) + set_target_properties(Magnum::GLContext PROPERTIES + IMPORTED_LOCATION_DEBUG ${_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_DEBUG}) + endif() + endif() + # Prevent creating the alias again + unset(_MAGNUM_GLCONTEXT_ALIAS) +endif() + +# Installation and deploy dirs +set(MAGNUM_DEPLOY_PREFIX "." + CACHE STRING "Prefix where to put final application executables") + +include(${CORRADE_LIB_SUFFIX_MODULE}) +set(MAGNUM_BINARY_INSTALL_DIR bin) +set(MAGNUM_LIBRARY_INSTALL_DIR lib${LIB_SUFFIX}) +set(MAGNUM_DATA_INSTALL_DIR share/magnum) +set(MAGNUM_INCLUDE_INSTALL_DIR include/Magnum) +set(MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR include/MagnumExternal) +set(MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR include/MagnumPlugins) +if(MAGNUM_BUILD_DEPRECATED AND MAGNUM_INCLUDE_INSTALL_PREFIX AND NOT MAGNUM_INCLUDE_INSTALL_PREFIX STREQUAL ".") + message(DEPRECATION "MAGNUM_INCLUDE_INSTALL_PREFIX is obsolete as its primary use was for old Android NDK versions. Please switch to the NDK r19+ layout instead of using this variable and recreate your build directory to get rid of this warning.") + set(MAGNUM_DATA_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/${MAGNUM_DATA_INSTALL_DIR}) + set(MAGNUM_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/${MAGNUM_INCLUDE_INSTALL_DIR}) + set(MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/${MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR}) + set(MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/${MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR}) +endif() + +set(MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_BINARY_INSTALL_DIR}/magnum-d) +set(MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR ${MAGNUM_LIBRARY_INSTALL_DIR}/magnum-d) +set(MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR ${MAGNUM_BINARY_INSTALL_DIR}/magnum) +set(MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_LIBRARY_INSTALL_DIR}/magnum) + +set(MAGNUM_PLUGINS_SHADERCONVERTER_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR}/shaderconverters) +set(MAGNUM_PLUGINS_SHADERCONVERTER_DEBUG_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR}/shaderconverters) +set(MAGNUM_PLUGINS_SHADERCONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR}/shaderconverters) +set(MAGNUM_PLUGINS_SHADERCONVERTER_RELEASE_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR}/shaderconverters) +set(MAGNUM_PLUGINS_FONT_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR}/fonts) +set(MAGNUM_PLUGINS_FONT_DEBUG_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR}/fonts) +set(MAGNUM_PLUGINS_FONT_RELEASE_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR}/fonts) +set(MAGNUM_PLUGINS_FONT_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR}/fonts) +set(MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR}/fontconverters) +set(MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR}/fontconverters) +set(MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR}/imageconverters) +set(MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR}/imageconverters) +set(MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR}/imageconverters) +set(MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR}/imageconverters) +set(MAGNUM_PLUGINS_IMPORTER_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR}/importers) +set(MAGNUM_PLUGINS_IMPORTER_DEBUG_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR}/importers) +set(MAGNUM_PLUGINS_IMPORTER_RELEASE_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR}/importers) +set(MAGNUM_PLUGINS_IMPORTER_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR}/importers) +set(MAGNUM_PLUGINS_SCENECONVERTER_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR}/sceneconverters) +set(MAGNUM_PLUGINS_SCENECONVERTER_DEBUG_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR}/sceneconverters) +set(MAGNUM_PLUGINS_SCENECONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR}/sceneconverters) +set(MAGNUM_PLUGINS_SCENECONVERTER_RELEASE_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR}/sceneconverters) +set(MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR}/audioimporters) +set(MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR}/audioimporters) +set(MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_BINARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR}/audioimporters) +set(MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_LIBRARY_INSTALL_DIR ${MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR}/audioimporters) + +# Get base plugin directory from main library location. This is *not* PATH, +# because CMake always converts the path to an absolute location internally, +# making it impossible to specify relative paths there. Sorry in advance for +# not having the dir selection button in CMake GUI. +set(MAGNUM_PLUGINS_DEBUG_DIR "" + CACHE STRING "Base directory where to look for Magnum plugins for debug builds") +set(MAGNUM_PLUGINS_RELEASE_DIR "" + CACHE STRING "Base directory where to look for Magnum plugins for release builds") +set(MAGNUM_PLUGINS_DIR "" + CACHE STRING "Base directory where to look for Magnum plugins") + +# Plugin directories. Set only if the above are non-empty. otherwise empty as +# well. +if(MAGNUM_PLUGINS_DIR) + set(MAGNUM_PLUGINS_FONT_DIR ${MAGNUM_PLUGINS_DIR}/fonts) + set(MAGNUM_PLUGINS_FONTCONVERTER_DIR ${MAGNUM_PLUGINS_DIR}/fontconverters) + set(MAGNUM_PLUGINS_IMAGECONVERTER_DIR ${MAGNUM_PLUGINS_DIR}/imageconverters) + set(MAGNUM_PLUGINS_IMPORTER_DIR ${MAGNUM_PLUGINS_DIR}/importers) + set(MAGNUM_PLUGINS_SCENECONVERTER_DIR ${MAGNUM_PLUGINS_DIR}/sceneconverters) + set(MAGNUM_PLUGINS_AUDIOIMPORTER_DIR ${MAGNUM_PLUGINS_DIR}/audioimporters) +endif() +if(MAGNUM_PLUGINS_DEBUG_DIR) + set(MAGNUM_PLUGINS_FONT_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/fonts) + set(MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/fontconverters) + set(MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/imageconverters) + set(MAGNUM_PLUGINS_IMPORTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/importers) + set(MAGNUM_PLUGINS_FONT_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/fonts) + set(MAGNUM_PLUGINS_SCENECONVERTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/sceneconverters) + set(MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/audioimporters) +endif() +if(MAGNUM_PLUGINS_RELEASE_DIR) + set(MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/fontconverters) + set(MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/imageconverters) + set(MAGNUM_PLUGINS_IMPORTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/importers) + set(MAGNUM_PLUGINS_SCENECONVERTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/sceneconverters) + set(MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/audioimporters) +endif() + +# Resets CMake policies set at the top of the file to not affect other code. +cmake_policy(POP) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..bd0828b --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,12 @@ +find_package(Magnum REQUIRED GL Sdl2Application) + +set_directory_properties(PROPERTIES CORRADE_USE_PEDANTIC_FLAGS ON) + +add_executable(${PROJECT_NAME} Chocolate.cpp) +target_link_libraries(${PROJECT_NAME} PRIVATE + Magnum::Application + Magnum::GL + Magnum::Magnum) + +# Make the executable a default target to build & run in Visual Studio +set_property(DIRECTORY ${PROJECT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${PROJECT_NAME}) diff --git a/src/Chocolate.cpp b/src/Chocolate.cpp new file mode 100644 index 0000000..cbf8c8f --- /dev/null +++ b/src/Chocolate.cpp @@ -0,0 +1,26 @@ +#include +#include + +using namespace Magnum; + +class Chocolate: public Platform::Application { + public: + explicit Chocolate(const Arguments& arguments); + + private: + void drawEvent() override; +}; + +Chocolate::Chocolate(const Arguments& arguments): Platform::Application{arguments} { + /* TODO: Add your initialization code here */ +} + +void Chocolate::drawEvent() { + GL::defaultFramebuffer.clear(GL::FramebufferClear::Color); + + /* TODO: Add your drawing code here */ + + swapBuffers(); +} + +MAGNUM_APPLICATION_MAIN(Chocolate)