commit e01c09fbccd16dcf3741b7d7c4c9825ebc347b63 Author: Dusan Maliarik Date: Thu Jun 18 18:25:03 2020 -0600 Big bang diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..5873bbc --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.cmake +build +CMakeLists.txt.user diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..05c149d --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,25 @@ +cmake_minimum_required(VERSION 3.5) + +project(MyApplication LANGUAGES CXX) + +set(CMAKE_INCLUDE_CURRENT_DIR ON) +set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/modules/" ${CMAKE_MODULE_PATH}) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) + +set(CMAKE_AUTOUIC ON) +set(CMAKE_AUTOMOC ON) +set(CMAKE_AUTORCC ON) + +set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +if(ANDROID) + set(ANDROID_PACKAGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/android") + if (ANDROID_ABI STREQUAL "armeabi-v7a") + set(ANDROID_EXTRA_LIBS + ${CMAKE_CURRENT_SOURCE_DIR}/path/to/libcrypto.so + ${CMAKE_CURRENT_SOURCE_DIR}/path/to/libssl.so) + endif() +endif() + +add_subdirectory(src) diff --git a/modules/FindCorrade.cmake b/modules/FindCorrade.cmake new file mode 100644 index 0000000..ab78763 --- /dev/null +++ b/modules/FindCorrade.cmake @@ -0,0 +1,569 @@ +#.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 +# CORRADE_INCLUDE_INSTALL_PREFIX - Prefix where to put platform-independent +# include and other files, defaults to ``.``. If a relative path is used, +# it's relative to :variable:`CMAKE_INSTALL_PREFIX`. +# +# This command will try to find only the base library, not the optional +# components, which are: +# +# Containers - Containers 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_MSVC2019_COMPATIBILITY - Defined if compiled with compatibility +# mode for MSVC 2019 +# 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 APIs +# included +# CORRADE_BUILD_STATIC - Defined if compiled as static libraries. +# Default are shared libraries. +# CORRADE_BUILD_MULTITHREADED - Defined if compiled in a way that makes it +# possible to safely use certain Corrade features simultaenously in multiple +# threads +# 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_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 targetting 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_USE_MODULE - Path to UseCorrade.cmake module (included +# automatically) +# CORRADE_TESTSUITE_XCTEST_RUNNER - Path to XCTestRunner.mm.in file +# CORRADE_TESTSUITE_ADB_RUNNER - Path to AdbRunner.sh 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 +# +# Workflows without :prop_tgt:`IMPORTED` targets are deprecated and the +# following variables are included just for backwards compatibility and only if +# :variable:`CORRADE_BUILD_DEPRECATED` is enabled: +# +# CORRADE_CXX_FLAGS - Pedantic compile flags. Use +# :prop_tgt:`CORRADE_USE_PEDANTIC_FLAGS` property or +# :variable:`CORRADE_PEDANTIC_COMPILER_DEFINITIONS` / +# :variable:`CORRADE_PEDANTIC_COMPILER_OPTIONS` list variables instead. +# +# 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 preprocessor directive ``CORRADE_DYNAMIC_PLUGIN``. 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 ````/ +# ````. +# +# corrade_add_plugin( +# +# +# +# ...) +# +# Unline 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 preprocessor directive ``CORRADE_STATIC_PLUGIN``. 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. +# +# 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 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) +set(_corradeFlags + # WARNING: CAREFUL HERE, the string(FIND) succeeds even if a subset is + # found -- so e.g. looking for TARGET_GL will match TARGET_GLES2 as well. + # So far that's not a problem, but might become an issue for new flags. + MSVC2015_COMPATIBILITY + MSVC2017_COMPATIBILITY + MSVC2019_COMPATIBILITY + BUILD_DEPRECATED + BUILD_STATIC + BUILD_MULTITHREADED + TARGET_UNIX + TARGET_APPLE + TARGET_IOS + TARGET_IOS_SIMULATOR + TARGET_WINDOWS + TARGET_WINDOWS_RT + TARGET_EMSCRIPTEN + TARGET_ANDROID + PLUGINMANAGER_NO_DYNAMIC_PLUGIN_SUPPORT + TESTSUITE_TARGET_XCTEST + UTILITY_USE_ANSI_COLORS) +foreach(_corradeFlag ${_corradeFlags}) + string(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) + +set(CORRADE_USE_MODULE ${_CORRADE_MODULE_DIR}/UseCorrade.cmake) +set(CORRADE_LIB_SUFFIX_MODULE ${_CORRADE_MODULE_DIR}/CorradeLibSuffix.cmake) + +# Ensure that all inter-component dependencies are specified as well +foreach(_component ${Corrade_FIND_COMPONENTS}) + string(TOUPPER ${_component} _COMPONENT) + + if(_component STREQUAL Containers) + set(_CORRADE_${_COMPONENT}_DEPENDENCIES Utility) + elseif(_component STREQUAL Interconnect) + set(_CORRADE_${_COMPONENT}_DEPENDENCIES Utility) + elseif(_component STREQUAL PluginManager) + set(_CORRADE_${_COMPONENT}_DEPENDENCIES Containers Utility rc) + elseif(_component STREQUAL TestSuite) + set(_CORRADE_${_COMPONENT}_DEPENDENCIES Utility Main) # see below + elseif(_component STREQUAL Utility) + set(_CORRADE_${_COMPONENT}_DEPENDENCIES Containers rc) + endif() + + # 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}) + + # 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 + if(_component STREQUAL TestSuite) + set(_CORRADE_${_COMPONENT}_DEPENDENCIES Utility) + endif() +endforeach() + +# Join the lists, remove duplicate 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() + +# Component distinction +set(_CORRADE_LIBRARY_COMPONENTS "^(Containers|Interconnect|Main|PluginManager|TestSuite|Utility)$") +if(CORRADE_TARGET_WINDOWS) + # CorradeMain is a real library only on windows, a dummy target elsewhere + set(_CORRADE_HEADER_ONLY_COMPONENTS "^(Containers)$") +else() + set(_CORRADE_HEADER_ONLY_COMPONENTS "^(Containers|Main)$") +endif() +set(_CORRADE_EXECUTABLE_COMPONENTS "^(rc)$") + +# 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}) + set(Corrade_${_component}_FOUND TRUE) + else() + # Library (and not header-only) components + if(_component MATCHES ${_CORRADE_LIBRARY_COMPONENTS} AND NOT _component MATCHES ${_CORRADE_HEADER_ONLY_COMPONENTS}) + add_library(Corrade::${_component} UNKNOWN IMPORTED) + + # 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) + + if(CORRADE_${_COMPONENT}_LIBRARY_RELEASE) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_property(TARGET Corrade::${_component} PROPERTY + IMPORTED_LOCATION_RELEASE ${CORRADE_${_COMPONENT}_LIBRARY_RELEASE}) + endif() + + if(CORRADE_${_COMPONENT}_LIBRARY_DEBUG) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_property(TARGET Corrade::${_component} PROPERTY + IMPORTED_LOCATION_DEBUG ${CORRADE_${_COMPONENT}_LIBRARY_DEBUG}) + endif() + endif() + + # Header-only library components + if(_component MATCHES ${_CORRADE_HEADER_ONLY_COMPONENTS}) + add_library(Corrade::${_component} INTERFACE IMPORTED) + endif() + + # Default include path names to look for for library / header-only + # components + if(_component MATCHES ${_CORRADE_LIBRARY_COMPONENTS}) + set(_CORRADE_${_COMPONENT}_INCLUDE_PATH_SUFFIX Corrade/${_component}) + set(_CORRADE_${_COMPONENT}_INCLUDE_PATH_NAMES ${_component}.h) + endif() + + # Executable components + if(_component MATCHES ${_CORRADE_EXECUTABLE_COMPONENTS}) + add_executable(Corrade::${_component} IMPORTED) + + find_program(CORRADE_${_COMPONENT}_EXECUTABLE corrade-${_component}) + mark_as_advanced(CORRADE_${_COMPONENT}_EXECUTABLE) + + if(CORRADE_${_COMPONENT}_EXECUTABLE) + set_property(TARGET Corrade::${_component} PROPERTY + IMPORTED_LOCATION ${CORRADE_${_COMPONENT}_EXECUTABLE}) + endif() + 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 + if(CORRADE_TARGET_WINDOWS AND CMAKE_CXX_COMPILER_ID 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) + set(_CORRADE_${_COMPONENT}_INCLUDE_PATH_SUFFIX Corrade) + set(_CORRADE_${_COMPONENT}_INCLUDE_PATH_NAMES Corrade.h) + + 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 + 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) + set(CORRADE_TESTSUITE_XCTEST_RUNNER_NEEDED CORRADE_TESTSUITE_XCTEST_RUNNER) + + # ADB runner file + elseif(CORRADE_TARGET_ANDROID) + find_file(CORRADE_TESTSUITE_ADB_RUNNER AdbRunner.sh + PATH_SUFFIXES share/corrade/TestSuite) + set(CORRADE_TESTSUITE_ADB_RUNNER_NEEDED CORRADE_TESTSUITE_ADB_RUNNER) + + # Emscripten runner file + elseif(CORRADE_TARGET_EMSCRIPTEN) + find_file(CORRADE_TESTSUITE_EMSCRIPTEN_RUNNER EmscriptenRunner.html.in + PATH_SUFFIXES share/corrade/TestSuite) + set(CORRADE_TESTSUITE_EMSCRIPTEN_RUNNER_NEEDED CORRADE_TESTSUITE_EMSCRIPTEN_RUNNER) + 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) + + # Directory::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() + endif() + + # Find library includes + if(_component MATCHES ${_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() + + # Add inter-library dependencies + if(_component MATCHES ${_CORRADE_LIBRARY_COMPONENTS} OR _component MATCHES ${_CORRADE_HEADER_ONLY_COMPONENTS}) + foreach(_dependency ${_CORRADE_${_COMPONENT}_DEPENDENCIES}) + if(_dependency MATCHES ${_CORRADE_LIBRARY_COMPONENTS} OR _dependency MATCHES ${_CORRADE_HEADER_ONLY_COMPONENTS}) + set_property(TARGET Corrade::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Corrade::${_dependency}) + endif() + endforeach() + endif() + + # Decide if the component was found + if((_component MATCHES ${_CORRADE_LIBRARY_COMPONENTS} AND _CORRADE_${_COMPONENT}_INCLUDE_DIR AND (_component MATCHES ${_CORRADE_HEADER_ONLY_COMPONENTS} OR CORRADE_${_COMPONENT}_LIBRARY_RELEASE OR CORRADE_${_COMPONENT}_LIBRARY_DEBUG)) OR (_component MATCHES ${_CORRADE_EXECUTABLE_COMPONENTS} AND CORRADE_${_COMPONENT}_EXECUTABLE)) + set(Corrade_${_component}_FOUND TRUE) + else() + set(Corrade_${_component}_FOUND FALSE) + endif() + endif() +endforeach() + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(Corrade REQUIRED_VARS + CORRADE_INCLUDE_DIR + _CORRADE_MODULE_DIR + _CORRADE_CONFIGURE_FILE + ${CORRADE_TESTSUITE_XCTEST_RUNNER_NEEDED} + ${CORRADE_TESTSUITE_ADB_RUNNER_NEEDED} + ${CORRADE_TESTSUITE_EMSCRIPTEN_RUNNER_NEEDED} + HANDLE_COMPONENTS) + +# Finalize the finding process +include(${CORRADE_USE_MODULE}) + +# Installation dirs +set(CORRADE_INCLUDE_INSTALL_PREFIX "." + CACHE STRING "Prefix where to put platform-independent include and other files") + +set(CORRADE_INCLUDE_INSTALL_DIR ${CORRADE_INCLUDE_INSTALL_PREFIX}/include/Corrade) diff --git a/modules/FindMagnum.cmake b/modules/FindMagnum.cmake new file mode 100644 index 0000000..f471cd7 --- /dev/null +++ b/modules/FindMagnum.cmake @@ -0,0 +1,1150 @@ +#.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_INCLUDE_INSTALL_PREFIX - Prefix where to put platform-independent +# include and other files, 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_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 +# AnySceneImporter - Any scene importer +# Audio - Audio library +# DebugTools - DebugTools library +# GL - GL library +# MeshTools - MeshTools library +# Primitives - Primitives library +# SceneGraph - SceneGraph library +# Shaders - Shaders 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 +# WindowlessWindowsEglApplication - Windowless Windows/EGL application +# CglContext - CGL context +# EglContext - EGL context +# GlxContext - GLX context +# WglContext - WGL context +# OpenGLTester - OpenGLTester 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 +# gl-info - magnum-gl-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 APIs +# included +# MAGNUM_BUILD_STATIC - Defined if compiled as static libraries +# MAGNUM_TARGET_GL - Defined if compiled with OpenGL interop +# MAGNUM_TARGET_GLES - Defined if compiled for OpenGL ES +# MAGNUM_TARGET_GLES2 - Defined if compiled for OpenGL ES 2.0 +# MAGNUM_TARGET_GLES3 - Defined if compiled for OpenGL ES 3.0 +# MAGNUM_TARGET_DESKTOP_GLES - Defined if compiled with OpenGL ES +# emulation on desktop OpenGL +# MAGNUM_TARGET_WEBGL - Defined if compiled for WebGL +# MAGNUM_TARGET_HEADLESS - Defined if compiled for headless machines +# 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. +# +# Additionally these variables are defined for internal usage: +# +# MAGNUM_INCLUDE_DIR - Root include dir (w/o dependencies) +# MAGNUM_LIBRARY - Magnum library (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 - Component libraries (w/o dependencies) +# MAGNUM_*_LIBRARY_DEBUG - Debug version of given library, if found +# MAGNUM_*_LIBRARY_RELEASE - Release version of given library, if found +# 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_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_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 +# 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. +# + +# Corrade library dependencies +set(_MAGNUM_CORRADE_DEPENDENCIES ) +foreach(_component ${Magnum_FIND_COMPONENTS}) + string(TOUPPER ${_component} _COMPONENT) + + # Unrolling the transitive dependencies here so this doesn't need to be + # after resolving inter-component dependencies. Listing also all plugins. + if(_component MATCHES "^(Audio|DebugTools|MeshTools|Primitives|Text|TextureTools|Trade|.+Importer|.+ImageConverter|.+Font)$") + set(_MAGNUM_${_COMPONENT}_CORRADE_DEPENDENCIES PluginManager) + endif() + + list(APPEND _MAGNUM_CORRADE_DEPENDENCIES ${_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) +set(_magnumFlags + # WARNING: CAREFUL HERE, the string(FIND) succeeds even if a subset is + # found -- so e.g. looking for TARGET_GL will match TARGET_GLES2 as well. + # So far that's not a problem, but might become an issue for new flags. + BUILD_DEPRECATED + BUILD_STATIC + TARGET_GL + TARGET_GLES + TARGET_GLES2 + TARGET_GLES3 + TARGET_DESKTOP_GLES + TARGET_WEBGL + TARGET_HEADLESS + TARGET_VK) +foreach(_magnumFlag ${_magnumFlags}) + string(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 +if(MAGNUM_BUILD_DEPRECATED AND CORRADE_BUILD_MULTITHREADED) + set(MAGNUM_BUILD_MULTITHREADED 1) +endif() + +# OpenGL library preference. Prefer to use GLVND, since that's the better +# approach nowadays, but allow the users to override it from outside in case +# it is broken for some reason (Nvidia drivers in Debian's testing (Buster) -- +# reported on 2019-04-09). +if(NOT CMAKE_VERSION VERSION_LESS 3.10 AND NOT OpenGL_GL_PREFERENCE) + set(OpenGL_GL_PREFERENCE GLVND) +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, use that + # information to guess also build type of dynamic plugins + if(MAGNUM_LIBRARY_DEBUG AND MAGNUM_LIBRARY_RELEASE) + set(MAGNUM_LIBRARY ${MAGNUM_LIBRARY_RELEASE}) + get_filename_component(_MAGNUM_PLUGINS_DIR_PREFIX ${MAGNUM_LIBRARY_DEBUG} PATH) + if(CMAKE_BUILD_TYPE STREQUAL "Debug") + set(_MAGNUM_PLUGINS_DIR_SUFFIX "-d") + endif() + elseif(MAGNUM_LIBRARY_DEBUG) + set(MAGNUM_LIBRARY ${MAGNUM_LIBRARY_DEBUG}) + get_filename_component(_MAGNUM_PLUGINS_DIR_PREFIX ${MAGNUM_LIBRARY_DEBUG} PATH) + set(_MAGNUM_PLUGINS_DIR_SUFFIX "-d") + elseif(MAGNUM_LIBRARY_RELEASE) + set(MAGNUM_LIBRARY ${MAGNUM_LIBRARY_RELEASE}) + get_filename_component(_MAGNUM_PLUGINS_DIR_PREFIX ${MAGNUM_LIBRARY_RELEASE} PATH) + endif() + + # On DLL platforms the plugins are stored in bin/ instead of lib/, modify + # _MAGNUM_PLUGINS_DIR_PREFIX accordingly + if(CORRADE_TARGET_WINDOWS) + get_filename_component(_MAGNUM_PLUGINS_DIR_PREFIX ${_MAGNUM_PLUGINS_DIR_PREFIX} PATH) + set(_MAGNUM_PLUGINS_DIR_PREFIX ${_MAGNUM_PLUGINS_DIR_PREFIX}/bin) + 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}) + # Some deprecated APIs use headers (but not externally defined symbols) + # from the GL library, link those includes as well + if(MAGNUM_BUILD_DEPRECATED AND MAGNUM_TARGET_GL) + set_property(TARGET Magnum::Magnum APPEND PROPERTY + INTERFACE_INCLUDE_DIRECTORIES ${MAGNUM_INCLUDE_DIR}/MagnumExternal/OpenGL) + endif() + + # 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_COMPONENT_LIST + Audio DebugTools GL MeshTools Primitives SceneGraph Shaders Text + TextureTools Trade Vk + AndroidApplication EmscriptenApplication GlfwApplication GlxApplication + Sdl2Application XEglApplication WindowlessCglApplication + WindowlessEglApplication WindowlessGlxApplication WindowlessIosApplication + WindowlessWglApplication WindowlessWindowsEglApplication + CglContext EglContext GlxContext WglContext + OpenGLTester) +set(_MAGNUM_PLUGIN_COMPONENT_LIST + AnyAudioImporter AnyImageConverter AnyImageImporter AnySceneImporter + MagnumFont MagnumFontConverter ObjImporter TgaImageConverter TgaImporter + WavAudioImporter) +set(_MAGNUM_EXECUTABLE_COMPONENT_LIST + distancefieldconverter fontconverter imageconverter gl-info al-info) + +# Inter-component dependencies +set(_MAGNUM_Audio_DEPENDENCIES ) + +set(_MAGNUM_DebugTools_DEPENDENCIES ) +if(MAGNUM_TARGET_GL) + # MeshTools, Primitives, SceneGraph and Shaders are used only for GL + # renderers. All of this is optional, compiled in only if the base library + # was selected. + list(APPEND _MAGNUM_DebugTools_DEPENDENCIES MeshTools Primitives SceneGraph Shaders Trade 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_Trade_DEPENDENCY_IS_OPTIONAL ON) + set(_MAGNUM_DebugTools_GL_DEPENDENCY_IS_OPTIONAL ON) +endif() + +set(_MAGNUM_MeshTools_DEPENDENCIES ) +if(MAGNUM_TARGET_GL) + # Trade is used only in compile(), which needs GL as well + list(APPEND _MAGNUM_MeshTools_DEPENDENCIES Trade GL) +endif() + +set(_MAGNUM_OpenGLTester_DEPENDENCIES GL) +if(MAGNUM_TARGET_HEADLESS OR CORRADE_TARGET_EMSCRIPTEN OR CORRADE_TARGET_ANDROID) + 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) + if(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_DESKTOP_GLES) + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessEglApplication) + else() + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessGlxApplication) + endif() +elseif(CORRADE_TARGET_WINDOWS) + if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES) + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessWglApplication) + else() + list(APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessWindowsEglApplication) + endif() +endif() + +set(_MAGNUM_Primitives_DEPENDENCIES Trade) +set(_MAGNUM_SceneGraph_DEPENDENCIES ) +set(_MAGNUM_Shaders_DEPENDENCIES GL) +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_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_WindowlessWindowsEglApplication_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_COMPONENT_LIST}) + if(_component MATCHES ".+AudioImporter") + list(APPEND _MAGNUM_${_component}_DEPENDENCIES Audio) + elseif(_component MATCHES ".+(Importer|ImageConverter)") + 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 +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() + +# Convert components lists to regular expressions so I can use if(MATCHES). +# TODO: Drop this once CMake 3.3 and if(IN_LIST) can be used +foreach(_WHAT LIBRARY PLUGIN EXECUTABLE) + string(REPLACE ";" "|" _MAGNUM_${_WHAT}_COMPONENTS "${_MAGNUM_${_WHAT}_COMPONENT_LIST}") + set(_MAGNUM_${_WHAT}_COMPONENTS "^(${_MAGNUM_${_WHAT}_COMPONENTS})$") +endforeach() + +# 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}) + set(Magnum_${_component}_FOUND TRUE) + else() + # Library components + if(_component MATCHES ${_MAGNUM_LIBRARY_COMPONENTS}) + add_library(Magnum::${_component} UNKNOWN IMPORTED) + + # Set library defaults, find the library + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/${_component}) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES ${_component}.h) + + # 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) + endif() + + # Plugin components + if(_component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS}) + add_library(Magnum::${_component} UNKNOWN IMPORTED) + + # 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}") + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES ${_MAGNUM_${_COMPONENT}_HEADER_NAME}.h) + + # 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) + + # FontConverter plugin specific name suffixes + elseif(_component MATCHES ".+FontConverter$") + set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX fontconverters) + endif() + + # Don't override the exception for *AudioImporter plugins + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX MagnumPlugins/${_component}) + 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 + # accidentaly 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}") + endif() + + # Library location for libraries/plugins + if(_component MATCHES ${_MAGNUM_LIBRARY_COMPONENTS} OR _component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS}) + if(MAGNUM_${_COMPONENT}_LIBRARY_RELEASE) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_property(TARGET Magnum::${_component} PROPERTY + IMPORTED_LOCATION_RELEASE ${MAGNUM_${_COMPONENT}_LIBRARY_RELEASE}) + endif() + + if(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_property(TARGET Magnum::${_component} PROPERTY + IMPORTED_LOCATION_DEBUG ${MAGNUM_${_COMPONENT}_LIBRARY_DEBUG}) + endif() + endif() + + # Executables + if(_component MATCHES ${_MAGNUM_EXECUTABLE_COMPONENTS}) + add_executable(Magnum::${_component} IMPORTED) + + find_program(MAGNUM_${_COMPONENT}_EXECUTABLE magnum-${_component}) + mark_as_advanced(MAGNUM_${_COMPONENT}_EXECUTABLE) + + if(MAGNUM_${_COMPONENT}_EXECUTABLE) + set_property(TARGET Magnum::${_component} PROPERTY + IMPORTED_LOCATION ${MAGNUM_${_COMPONENT}_EXECUTABLE}) + endif() + endif() + + # Applications + if(_component MATCHES ".+Application") + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/Platform) + + # Android application dependencies + if(_component STREQUAL AndroidApplication) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES android EGL::EGL) + + # EmscriptenApplication has no additional dependencies + + # 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.11) 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(CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE AND (NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)) + 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() + elseif(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_DESKTOP_GLES AND NOT CORRADE_TARGET_EMSCRIPTEN) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND + PROPERTY INTERFACE_LINK_LIBRARIES EGL::EGL) + 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}) + endif() + + # With GLVND (since CMake 3.11) 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(CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE AND (NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)) + 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() + elseif(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_DESKTOP_GLES AND NOT CORRADE_TARGET_EMSCRIPTEN) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND + PROPERTY INTERFACE_LINK_LIBRARIES EGL::EGL) + 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.11) 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. + 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 + + # Windowless Windows/EGL application dependencies + elseif(_component STREQUAL WindowlessWindowsEglApplication) + find_package(EGL) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES EGL::EGL) + + # 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") + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/Platform) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES GLContext.h) + + # GLX context dependencies + if(_component STREQUAL GlxContext) + # With GLVND (since CMake 3.11) 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_INCLUDE_DIRECTORIES ${OPENAL_INCLUDE_DIR}) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES ${OPENAL_LIBRARY} Corrade::PluginManager) + + # No special setup for DebugTools library + + # GL library + elseif(_component STREQUAL GL) + if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES) + # If the GLVND library (CMake 3.11+) 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) + elseif(MAGNUM_TARGET_GLES3) + find_package(OpenGLES3 REQUIRED) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES OpenGLES3::OpenGLES3) + endif() + + # MeshTools library + elseif(_component STREQUAL MeshTools) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES CompressIndices.h) + + # OpenGLTester library + elseif(_component STREQUAL OpenGLTester) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/GL) + + # Primitives library + elseif(_component STREQUAL Primitives) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES Cube.h) + + # No special setup for SceneGraph library + # No special setup for Shaders library + + # Text library + elseif(_component STREQUAL Text) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Corrade::PluginManager) + + # TextureTools library + elseif(_component STREQUAL TextureTools) + set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES Atlas.h) + + # Trade library + elseif(_component STREQUAL Trade) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_LINK_LIBRARIES Corrade::PluginManager) + + # Vk library + elseif(_component STREQUAL Vk) + set(Vulkan_INCLUDE_DIR ${MAGNUM_INCLUDE_DIR}/MagnumExternal/Vulkan) + 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 + + # Find library/plugin includes + if(_component MATCHES ${_MAGNUM_LIBRARY_COMPONENTS} OR _component MATCHES ${_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() + + # Automatic import of static plugins. Skip in case the include dir was + # not found -- that'll fail later with a proper message. + if(_component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS} AND _MAGNUM_${_COMPONENT}_INCLUDE_DIR) + # Automatic import of static plugins + file(READ ${_MAGNUM_${_COMPONENT}_INCLUDE_DIR}/configure.h _magnum${_component}Configure) + string(FIND "${_magnum${_component}Configure}" "#define MAGNUM_${_COMPONENT}_BUILD_STATIC" _magnum${_component}_BUILD_STATIC) + if(NOT _magnum${_component}_BUILD_STATIC EQUAL -1) + set_property(TARGET Magnum::${_component} APPEND PROPERTY + INTERFACE_SOURCES ${_MAGNUM_${_COMPONENT}_INCLUDE_DIR}/importStaticPlugin.cpp) + endif() + 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 MATCHES ${_MAGNUM_LIBRARY_COMPONENTS} OR _component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS}) + 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() + + # Decide if the library was found + if(((_component MATCHES ${_MAGNUM_LIBRARY_COMPONENTS} OR _component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS}) AND _MAGNUM_${_COMPONENT}_INCLUDE_DIR AND (MAGNUM_${_COMPONENT}_LIBRARY_DEBUG OR MAGNUM_${_COMPONENT}_LIBRARY_RELEASE)) OR (_component MATCHES ${_MAGNUM_EXECUTABLE_COMPONENTS} AND MAGNUM_${_COMPONENT}_EXECUTABLE)) + set(Magnum_${_component}_FOUND TRUE) + else() + set(Magnum_${_component}_FOUND FALSE) + 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) + + # If we are on CMake 3.13 and up, `-s USE_WEBGL2=1` linker option is + # propagated from FindOpenGLES3.cmake already. If not (and the GL library + # is used), we need to modify the global CMAKE_EXE_LINKER_FLAGS. Do it here + # instead of in FindOpenGLES3.cmake so it works also for CMake subprojects + # (in which case find_package(OpenGLES3) is called in (and so + # CMAKE_EXE_LINKER_FLAGS would be modified in) Magnum's root CMakeLists.txt + # and thus can't affect the variable in the outer project). CMake supports + # IN_LIST as an operator since 3.1 (Emscripten needs at least 3.7), but + # it's behind a policy, so enable that one as well. + cmake_policy(SET CMP0057 NEW) + if(CMAKE_VERSION VERSION_LESS 3.13 AND GL IN_LIST Magnum_FIND_COMPONENTS AND NOT MAGNUM_TARGET_GLES2 AND NOT CMAKE_EXE_LINKER_FLAGS MATCHES "-s USE_WEBGL2=1") + set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s USE_WEBGL2=1") + endif() +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) + +# 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") +set(MAGNUM_INCLUDE_INSTALL_PREFIX "." + CACHE STRING "Prefix where to put platform-independent include and other files") + +include(${CORRADE_LIB_SUFFIX_MODULE}) +set(MAGNUM_BINARY_INSTALL_DIR bin) +set(MAGNUM_LIBRARY_INSTALL_DIR lib${LIB_SUFFIX}) +set(MAGNUM_DATA_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/share/magnum) +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_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_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) +set(MAGNUM_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/include/Magnum) +set(MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/include/MagnumExternal) +set(MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/include/MagnumPlugins) + +# 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 ${_MAGNUM_PLUGINS_DIR_PREFIX}/magnum-d + CACHE STRING "Base directory where to look for Magnum plugins for debug builds") +set(MAGNUM_PLUGINS_RELEASE_DIR ${_MAGNUM_PLUGINS_DIR_PREFIX}/magnum + CACHE STRING "Base directory where to look for Magnum plugins for release builds") +set(MAGNUM_PLUGINS_DIR ${_MAGNUM_PLUGINS_DIR_PREFIX}/magnum${_MAGNUM_PLUGINS_DIR_SUFFIX} + CACHE STRING "Base directory where to look for Magnum plugins") + +# Plugin directories +set(MAGNUM_PLUGINS_FONT_DIR ${MAGNUM_PLUGINS_DIR}/fonts) +set(MAGNUM_PLUGINS_FONT_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/fonts) +set(MAGNUM_PLUGINS_FONT_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/fonts) +set(MAGNUM_PLUGINS_FONTCONVERTER_DIR ${MAGNUM_PLUGINS_DIR}/fontconverters) +set(MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/fontconverters) +set(MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/fontconverters) +set(MAGNUM_PLUGINS_IMAGECONVERTER_DIR ${MAGNUM_PLUGINS_DIR}/imageconverters) +set(MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/imageconverters) +set(MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/imageconverters) +set(MAGNUM_PLUGINS_IMPORTER_DIR ${MAGNUM_PLUGINS_DIR}/importers) +set(MAGNUM_PLUGINS_IMPORTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/importers) +set(MAGNUM_PLUGINS_IMPORTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/importers) +set(MAGNUM_PLUGINS_AUDIOIMPORTER_DIR ${MAGNUM_PLUGINS_DIR}/audioimporters) +set(MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/audioimporters) +set(MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/audioimporters) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..cf9944e --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,57 @@ +find_package(Corrade REQUIRED Main) +find_package(Magnum REQUIRED + GL + MeshTools + Primitives + SceneGraph + Shaders) +find_package(Qt5 REQUIRED COMPONENTS + Core + Quick) + +if(MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_DESKTOP_GLES) + find_package(Magnum REQUIRED EglContext) +elseif(CORRADE_TARGET_WINDOWS) + find_package(Magnum REQUIRED WglContext) +elseif(CORRADE_TARGET_APPLE) + find_package(Magnum REQUIRED CglContext) +elseif(CORRADE_TARGET_UNIX) + find_package(Magnum REQUIRED GlxContext) +else() + message(FATAL_ERROR "Magnum context creation is not supported on this platform") +endif() + +set_directory_properties(PROPERTIES CORRADE_USE_PEDANTIC_FLAGS ON) + +if(ANDROID) + add_library(MyApplication SHARED + arc_ball.cpp + magnum_render.cpp + magnum_item.cpp + qml/main.qrc + main.cpp) +else() + add_executable(MyApplication + arc_ball.cpp + magnum_render.cpp + magnum_item.cpp + qml/main.qrc + main.cpp) +endif() + +# set_property(SOURCE usr/include/Magnum/GL/Attribute.h PROPERTY SKIP_AUTOMOC ON) + +target_compile_definitions(MyApplication + PRIVATE $<$,$>:QT_QML_DEBUG>) +target_link_libraries(MyApplication PRIVATE + Corrade::Main + Magnum::GL + Magnum::GLContext + Magnum::Magnum + Magnum::MeshTools + Magnum::Primitives + Magnum::SceneGraph + Magnum::Shaders + Qt5::Core + Qt5::Quick) + diff --git a/src/arc_ball.cpp b/src/arc_ball.cpp new file mode 100644 index 0000000..1ffc61b --- /dev/null +++ b/src/arc_ball.cpp @@ -0,0 +1,134 @@ +#include + +#include "arc_ball.h" + +/* Project a point in NDC onto the arcball sphere */ +Quaternion ndcToArcBall(const Vector2 &p) { + const Float dist = Math::dot(p, p); + + /* Point is on sphere */ + if (dist <= 1.0f) + return {{p.x(), p.y(), Math::sqrt(1.0f - dist)}, 0.0f}; + + /* Point is outside sphere */ + else { + const Vector2 proj = p.normalized(); + return {{proj.x(), proj.y(), 0.0f}, 0.0f}; + } +} + +ArcBall::ArcBall(const Vector3 &eye, const Vector3 &viewCenter, + const Vector3 &upDir, Deg fov, const Vector2i &windowSize) + : m_fov{fov}, m_windowSize{windowSize} { + setViewParameters(eye, viewCenter, upDir); +} + +void ArcBall::setViewParameters(const Vector3 &eye, const Vector3 &viewCenter, + const Vector3 &upDir) { + const Vector3 dir = viewCenter - eye; + Vector3 zAxis = dir.normalized(); + Vector3 xAxis = (Math::cross(zAxis, upDir.normalized())).normalized(); + Vector3 yAxis = (Math::cross(xAxis, zAxis)).normalized(); + xAxis = (Math::cross(zAxis, yAxis)).normalized(); + + m_targetPosition = -viewCenter; + m_targetZooming = -dir.length(); + m_targetQRotation = + Quaternion::fromMatrix(Matrix3x3{xAxis, yAxis, -zAxis}.transposed()) + .normalized(); + + m_positionT0 = m_currentPosition = m_targetPosition; + m_zoomingT0 = m_currentZooming = m_targetZooming; + m_qRotationT0 = m_currentQRotation = m_targetQRotation; + + updateInternalTransformations(); +} + +void ArcBall::reset() { + m_targetPosition = m_positionT0; + m_targetZooming = m_zoomingT0; + m_targetQRotation = m_qRotationT0; +} + +void ArcBall::setLagging(const Float lagging) { + CORRADE_INTERNAL_ASSERT(lagging >= 0.0f && lagging < 1.0f); + m_lagging = lagging; +} + +void ArcBall::initTransformation(const Vector2i &mousePos) { + m_prevMousePosNDC = screenCoordToNDC(mousePos); +} + +void ArcBall::rotate(const Vector2i &mousePos) { + const Vector2 mousePosNDC = screenCoordToNDC(mousePos); + const Quaternion currentQRotation = ndcToArcBall(mousePosNDC); + const Quaternion prevQRotation = ndcToArcBall(m_prevMousePosNDC); + m_prevMousePosNDC = mousePosNDC; + m_targetQRotation = + (currentQRotation * prevQRotation * m_targetQRotation).normalized(); +} + +void ArcBall::translate(const Vector2i &mousePos) { + const Vector2 mousePosNDC = screenCoordToNDC(mousePos); + const Vector2 translationNDC = mousePosNDC - m_prevMousePosNDC; + m_prevMousePosNDC = mousePosNDC; + translateDelta(translationNDC); +} + +void ArcBall::translateDelta(const Vector2 &translationNDC) { + /* Half size of the screen viewport at the view center and perpendicular + with the viewDir */ + const Float hh = Math::abs(m_targetZooming) * Math::tan(m_fov * 0.5f); + const Float hw = hh * Vector2{m_windowSize}.aspectRatio(); + + m_targetPosition += m_inverseView.transformVector( + {translationNDC.x() * hw, translationNDC.y() * hh, 0.0f}); +} + +void ArcBall::zoom(const Float delta) { m_targetZooming += delta; } + +bool ArcBall::updateTransformation() { + const Vector3 diffViewCenter = m_targetPosition - m_currentPosition; + const Quaternion diffRotation = m_targetQRotation - m_currentQRotation; + const Float diffZooming = m_targetZooming - m_currentZooming; + + const Float dViewCenter = Math::dot(diffViewCenter, diffViewCenter); + const Float dRotation = Math::dot(diffRotation, diffRotation); + const Float dZooming = diffZooming * diffZooming; + + /* Nothing change */ + if (dViewCenter < 1.0e-10f && dRotation < 1.0e-10f && dZooming < 1.0e-10f) { + return false; + } + + /* Nearly done: just jump directly to the target */ + if (dViewCenter < 1.0e-6f && dRotation < 1.0e-6f && dZooming < 1.0e-6f) { + m_currentPosition = m_targetPosition; + m_currentQRotation = m_targetQRotation; + m_currentZooming = m_targetZooming; + + /* Interpolate between the current transformation and the target + transformation */ + } else { + const Float t = 1 - m_lagging; + m_currentPosition = Math::lerp(m_currentPosition, m_targetPosition, t); + m_currentZooming = Math::lerp(m_currentZooming, m_targetZooming, t); + m_currentQRotation = + Math::slerpShortestPath(m_currentQRotation, m_targetQRotation, t); + } + + updateInternalTransformations(); + return true; +} + +void ArcBall::updateInternalTransformations() { + m_view = DualQuaternion::translation(Vector3::zAxis(m_currentZooming)) * + DualQuaternion{m_currentQRotation} * + DualQuaternion::translation(m_currentPosition); + m_inverseView = m_view.inverted(); +} + +Vector2 ArcBall::screenCoordToNDC(const Vector2i &mousePos) const { + return {mousePos.x() * 2.0f / m_windowSize.x() - 1.0f, + 1.0f - 2.0f * mousePos.y() / m_windowSize.y()}; +} diff --git a/src/arc_ball.h b/src/arc_ball.h new file mode 100644 index 0000000..7d52c79 --- /dev/null +++ b/src/arc_ball.h @@ -0,0 +1,100 @@ +#ifndef ARCBALL_H +#define ARCBALL_H + +#include +#include +#include +#include +#include + +using namespace Magnum; + +Quaternion ndcToArcBall(const Vector2 &p); + +/* Implementation of Ken Shoemake's arcball camera with smooth navigation + feature: https://www.talisman.org/~erlkonig/misc/shoemake92-arcball.pdf */ +class ArcBall { +public: + ArcBall(const Vector3 &cameraPosition, const Vector3 &viewCenter, + const Vector3 &upDir, Deg fov, const Vector2i &windowSize); + + /* Set the camera view parameters: eye position, view center, up + direction */ + void setViewParameters(const Vector3 &eye, const Vector3 &viewCenter, + const Vector3 &upDir); + + /* Reset the camera to its initial position, view center, and up dir */ + void reset(); + + /* Update screen size after the window has been resized */ + void reshape(const Vector2i &windowSize) { m_windowSize = windowSize; } + + /* Update any unfinished transformation due to lagging, return true if + the camera matrices have changed */ + bool updateTransformation(); + + /* Get/set the amount of lagging such that the camera will (slowly) + smoothly navigate. Lagging must be in [0, 1) */ + Float lagging() const { return m_lagging; } + void setLagging(Float lagging); + + /* Initialize the first (screen) mouse position for camera + transformation. This should be called in mouse pressed event. */ + void initTransformation(const Vector2i &mousePos); + + /* Rotate the camera from the previous (screen) mouse position to the + current (screen) position */ + void rotate(const Vector2i &mousePos); + + /* Translate the camera from the previous (screen) mouse position to + the current (screen) mouse position */ + void translate(const Vector2i &mousePos); + + /* Translate the camera by the delta amount of (NDC) mouse position. + Note that NDC position must be in [-1, -1] to [1, 1]. */ + void translateDelta(const Vector2 &translationNDC); + + /* Zoom the camera (positive delta = zoom in, negative = zoom out) */ + void zoom(Float delta); + + /* Get the camera's view transformation as a qual quaternion */ + const DualQuaternion &view() const { return m_view; } + + /* Get the camera's view transformation as a matrix */ + Matrix4 viewMatrix() const { return m_view.toMatrix(); } + + /* Get the camera's inverse view matrix (which also produces + transformation of the camera) */ + Matrix4 inverseViewMatrix() const { return m_inverseView.toMatrix(); } + + /* Get the camera's transformation as a dual quaternion */ + const DualQuaternion &transformation() const { return m_inverseView; } + + /* Get the camera's transformation matrix */ + Matrix4 transformationMatrix() const { return m_inverseView.toMatrix(); } + + /* Return the distance from the camera position to the center view */ + Float viewDistance() const { return Math::abs(m_targetZooming); } + +protected: + /* Update the camera transformations */ + void updateInternalTransformations(); + + /* Transform from screen coordinate to NDC - normalized device + coordinate. The top-left of the screen corresponds to [-1, 1] NDC, + and the bottom right is [1, -1] NDC. */ + Vector2 screenCoordToNDC(const Vector2i &mousePos) const; + + Deg m_fov; + Vector2i m_windowSize; + + Vector2 m_prevMousePosNDC; + Float m_lagging{}; + + Vector3 m_targetPosition, m_currentPosition, m_positionT0; + Quaternion m_targetQRotation, m_currentQRotation, m_qRotationT0; + Float m_targetZooming, m_currentZooming, m_zoomingT0; + DualQuaternion m_view, m_inverseView; +}; + +#endif diff --git a/src/arc_ball_camera.h b/src/arc_ball_camera.h new file mode 100644 index 0000000..a7a720f --- /dev/null +++ b/src/arc_ball_camera.h @@ -0,0 +1,65 @@ +#ifndef ARCBALLCAMERA_H +#define ARCBALLCAMERA_H + +#include +#include +#include +#include +#include "arc_ball.h" + +using namespace Magnum; + +/* Arcball camera implementation integrated into the SceneGraph */ +class ArcBallCamera : public ArcBall { +public: + template + ArcBallCamera(SceneGraph::Scene &scene, + const Vector3 &cameraPosition, const Vector3 &viewCenter, + const Vector3 &upDir, Deg fov, const Vector2i &windowSize, + const Vector2i &viewportSize) + : ArcBall{cameraPosition, viewCenter, upDir, fov, windowSize} { + /* Create a camera object of a concrete type */ + auto *cameraObject = new SceneGraph::Object{&scene}; + (*(m_camera = new SceneGraph::Camera3D{*cameraObject})) + .setAspectRatioPolicy(SceneGraph::AspectRatioPolicy::Extend) + .setProjectionMatrix(Matrix4::perspectiveProjection( + fov, Vector2{windowSize}.aspectRatio(), 0.01f, 100.0f)) + .setViewport(viewportSize); + + /* Save the abstract transformation interface and initialize the + camera position through that */ + (*(m_cameraObject = cameraObject)) + .rotate(transformation().rotation()) + .translate(transformation().translation()); + } + + /* Update screen and viewport size after the window has been resized */ + void reshape(const Vector2i &windowSize, const Vector2i &viewportSize) { + m_windowSize = windowSize; + m_camera->setViewport(viewportSize); + } + + /* Update the SceneGraph camera if arcball has been changed */ + bool update() { + /* call the internal update */ + if (!updateTransformation()) + return false; + + (*m_cameraObject) + .resetTransformation() + .rotate(transformation().rotation()) + .translate(transformation().translation()); + return true; + } + + /* Draw objects using the internal scenegraph camera */ + void draw(SceneGraph::DrawableGroup3D &drawables) { + m_camera->draw(drawables); + } + +private: + SceneGraph::AbstractTranslationRotation3D *m_cameraObject{}; + SceneGraph::Camera3D *m_camera{}; +}; + +#endif diff --git a/src/glclampf.h b/src/glclampf.h new file mode 100644 index 0000000..6972974 --- /dev/null +++ b/src/glclampf.h @@ -0,0 +1,11 @@ +#ifndef GLCLAMPF_H +#define GLCLAMPF_H + +#if 1 +typedef GLfloat GLclampf; +#undef __glew_h__ /* shh, Qt, shh */ +#undef __GLEW_H__ +#include +#endif + +#endif // GLCLAMPF_H diff --git a/src/magnum_item.cpp b/src/magnum_item.cpp new file mode 100644 index 0000000..8d348de --- /dev/null +++ b/src/magnum_item.cpp @@ -0,0 +1,126 @@ +#include +#include +#include +#include +#include +#include "magnum_item.h" +#include "magnum_render.h" + +using namespace std; +using namespace Magnum; +using namespace Math::Literals; + +class MagnumFBORenderer : public QQuickFramebufferObject::Renderer { +public: + MagnumFBORenderer(QQuickWindow *window, MagnumRenderer *renderer) : + m_window(window), + m_renderer(renderer) {} + + void render() override { + m_renderer->render(); + m_window->resetOpenGLState(); + update(); + } + + void synchronize(QQuickFramebufferObject *item) override { + auto mitem = static_cast(item); + m_renderer->t(mitem->t()); + m_renderer->hue(mitem->hue()); + m_renderer->count(mitem->count()); + } + + QOpenGLFramebufferObject *createFramebufferObject(const QSize &size) override { + QOpenGLFramebufferObjectFormat format; + format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil); + format.setSamples(4); + m_fbo = new QOpenGLFramebufferObject(size, format); + // --- + if (m_ctx == nullptr) + m_ctx = new Platform::GLContext(); + Platform::GLContext::makeCurrent(m_ctx); + m_renderer->reset( + m_ctx, + GL::Framebuffer::wrap( + m_fbo->handle(), {{}, {size.width(), + size.height()}}), + Vector2i{m_window->width(), m_window->height()}, + Vector2i{size.width(), size.height()}); + return m_fbo; + } + +private: + QQuickWindow *m_window; + QOpenGLFramebufferObject *m_fbo; + Platform::GLContext *m_ctx{}; + MagnumRenderer *m_renderer; +}; + +MagnumItem::MagnumItem() : m_renderer(new MagnumRenderer()) { + setMirrorVertically(true); + setAcceptHoverEvents(true); + setAcceptedMouseButtons(Qt::AllButtons); + setFlag(ItemAcceptsInputMethod, true); +} + +QQuickFramebufferObject::Renderer *MagnumItem::createRenderer() const { + return new MagnumFBORenderer(window(), m_renderer); +} + +void MagnumItem::setT(qreal t) { + if (t == m_t) return; + m_t = t; + emit tChanged(); + update(); +} + +void MagnumItem::setHue(qreal hue) { + if (hue == m_hue) return; + m_hue = hue; + emit hueChanged(); + update(); +} + +void MagnumItem::setCount(qint8 count) { + if (count == m_count) return; + m_count = count; + emit countChanged(); + update(); +} + +void MagnumItem::keyPressEvent(QKeyEvent *evt) { + switch (evt->key()) { + case Qt::Key_L: +// if (m_camera->lagging() > 0.0f) { +// m_camera->setLagging(0.0f); +// } else { +// m_camera->setLagging(0.85f); +// } + break; + } + evt->accept(); +} + +void MagnumItem::mousePressEvent(QMouseEvent *evt) { +} + +void MagnumItem::mouseReleaseEvent(QMouseEvent *evt) { +} + +void MagnumItem::mouseMoveEvent(QMouseEvent *evt) {} + +void MagnumItem::wheelEvent(QWheelEvent *evt) {} + +class CleanupJob : public QRunnable { +public: + CleanupJob(MagnumRenderer *renderer) : m_renderer(renderer) {} + void run() override { delete m_renderer; } +private: + MagnumRenderer *m_renderer; +}; + +void MagnumItem::releaseResources() { + window()->scheduleRenderJob( + new CleanupJob(m_renderer), + QQuickWindow::BeforeSynchronizingStage); + m_renderer = nullptr; +} diff --git a/src/magnum_item.h b/src/magnum_item.h new file mode 100644 index 0000000..ba76506 --- /dev/null +++ b/src/magnum_item.h @@ -0,0 +1,55 @@ +#ifndef MAGNUM_ITEM_H +#define MAGNUM_ITEM_H + +#include +#include +#include "glclampf.h" +#include +#include + +// Forward declaring the renderer to avoid CMake's AUTOMOC +// to process Magnum's headers (where it fails) + +class MagnumRenderer; + +class MagnumItem : public QQuickFramebufferObject { + Q_OBJECT + Q_PROPERTY(qreal t READ t WRITE setT NOTIFY tChanged) + Q_PROPERTY(qreal hue READ hue WRITE setHue NOTIFY hueChanged) + Q_PROPERTY(qreal count READ count WRITE setCount NOTIFY countChanged) +public: + MagnumItem(); + Renderer *createRenderer() const override; + + inline qreal t() const { return m_t; } + void setT(qreal t); + + inline qreal hue() const { return m_hue; } + void setHue(qreal hue); + + inline qint8 count() const { return m_count; } + void setCount(qint8 count); + +signals: + void tChanged(); + void hueChanged(); + void countChanged(); + +protected: + void keyPressEvent(QKeyEvent *evt) override; + void mousePressEvent(QMouseEvent *evt) override; + void mouseReleaseEvent(QMouseEvent *evt) override; + void mouseMoveEvent(QMouseEvent *evt) override; + void wheelEvent(QWheelEvent *evt) override; + +private: + void releaseResources() override; + + qreal m_t; + qreal m_hue; + qint8 m_count; + + MagnumRenderer *m_renderer; +}; + +#endif // MAGNUM_ITEM_H diff --git a/src/magnum_render.cpp b/src/magnum_render.cpp new file mode 100644 index 0000000..59e1150 --- /dev/null +++ b/src/magnum_render.cpp @@ -0,0 +1,149 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "magnum_render.h" + +using namespace Magnum; +using namespace Math::Literals; + +static const auto HUE_BG = 210.0_degf; +static const auto COLOR_BG = Color4::fromHsv({HUE_BG, .3f, .9f}, 1.f); +static const auto COLOR_GRID = Color4::fromHsv({HUE_BG, .3f, .7f}, 1.f); + +MagnumRenderer::MagnumRenderer() {} + +MagnumRenderer::~MagnumRenderer() {} + +void MagnumRenderer::t(const float t) { + if (m_subjectObject != nullptr) { + m_subjectObject->resetTransformation(); + m_subjectObject->translate(Vector3{0.f, 1.f, 0.f}); + m_subjectObject->rotateY(Rad(t*Math::Constants::pi())); + } +} + +void MagnumRenderer::hue(float hue) { + if (m_subjectShader.id()) { + auto const color = Color3::fromHsv({Rad(hue), 1.f, 1.f}); + m_subjectShader + .setDiffuseColor(color) + .setAmbientColor(Color3::fromHsv({color.hue(), 1.0f, 0.3f})); + } +} + +void MagnumRenderer::count(int count) { + m_count = count; +} + +void MagnumRenderer::lazyInitialize() { + if (m_init) return; + + // The Cube + { + m_subject = MeshTools::compile(Primitives::cubeSolid()); + m_subjectObject = new Object3D{&m_scene}; + (*m_subjectObject).translate(Vector3{0.f, 1.f, 0.f}); + + m_subjectShader = Shaders::Phong{}; + m_subjectShader + .setShininess(20.f) + .setLightColor(Color3{1.f}) + .setLightPosition(Vector3{-100.f, 100.f, 50.f}); + + new SubjectDrawable{*m_subjectObject, m_subjectShader, m_subject, m_drawables}; + } + + // The Grid + { + m_grid = MeshTools::compile(Primitives::grid3DWireframe({15, 15})); + auto obj = new Object3D{&m_scene}; + (*obj).rotateX(90.0_degf).scale(Vector3{8.0f}); + + m_gridShader = Shaders::Flat3D{}; + m_gridShader.setColor(COLOR_GRID); + + new GridDrawable{*obj, m_gridShader, m_grid, m_drawables}; + } + + // The Camera + { + const Vector3 eye{-10.0f, 8.f, -6.f}; + const Vector3 center{0.f, 1.f, 0.f}; + const Vector3 up = Vector3::yAxis(); + m_camera.emplace(m_scene, eye, center, up, 45.0_degf, + Vector2i{100, 100}, Vector2i{100, 100}); + } + + m_init = true; +} + +void MagnumRenderer::reset(Platform::GLContext *ctx, + GL::Framebuffer fbo, + Vector2i windowSize, + Vector2i viewportSize) { + lazyInitialize(); + m_camera->reshape(windowSize, viewportSize); + m_FBO = std::move(fbo); + m_ctx = ctx; +} + +void MagnumRenderer::prepGLState() { + GL::Renderer::setClearColor(COLOR_BG); + GL::Renderer::enable(GL::Renderer::Feature::DepthTest); + GL::Renderer::enable(GL::Renderer::Feature::FaceCulling); + GL::Renderer::enable(GL::Renderer::Feature::Multisampling); + + GL::Renderer::setDepthFunction(GL::Renderer::DepthFunction::LessOrEqual); + GL::Renderer::setBlendEquation(GL::Renderer::BlendEquation::Add, + GL::Renderer::BlendEquation::Add); + GL::Renderer::setBlendFunction( + GL::Renderer::BlendFunction::One, + GL::Renderer::BlendFunction::OneMinusSourceAlpha); + GL::Renderer::enable(GL::Renderer::Feature::Blending); +} + +void MagnumRenderer::render() { + m_ctx->resetState(GL::Context::State::ExitExternal); + prepGLState(); + // --- + + m_FBO.bind(); + m_FBO.clear(GL::FramebufferClear::Color | + GL::FramebufferClear::Depth); + + m_camera->update(); + m_camera->draw(m_drawables); + + /** Use instead this to limit rendering to camera changes + * bool cameraChanged = m_camera->update(); + * m_camera->draw(m_drawables); + * if (cameraChanged) { + * redraw(); + * } */ + + // --- + m_ctx->resetState(GL::Context::State::EnterExternal); +} + +void GridDrawable::draw(const Matrix4 &transformation, + SceneGraph::Camera3D &camera) { + m_shader + .setTransformationProjectionMatrix( + camera.projectionMatrix()*transformation) + .draw(m_mesh); +} + +void SubjectDrawable::draw(const Matrix4 &transformation, + SceneGraph::Camera3D &camera) { + m_shader + .setTransformationMatrix(transformation) + .setNormalMatrix(transformation.normalMatrix()) + .setProjectionMatrix(camera.projectionMatrix()) + .draw(m_mesh); +} diff --git a/src/magnum_render.h b/src/magnum_render.h new file mode 100644 index 0000000..8485288 --- /dev/null +++ b/src/magnum_render.h @@ -0,0 +1,91 @@ +#ifndef MAGNUM_RENDER_H +#define MAGNUM_RENDER_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "arc_ball_camera.h" + +using namespace Magnum; + +using Object3D = SceneGraph::Object; +using Scene3D = SceneGraph::Scene; + +class MagnumRenderer { +public: + MagnumRenderer(); + ~MagnumRenderer(); + + void reset(Platform::GLContext *ctx, + GL::Framebuffer fbo, + Vector2i windowSize, + Vector2i viewportSize); + + void render(); + + void t(float t); + void hue(float hue); + void count(int count); + +private: + void lazyInitialize(); + void prepGLState(); + + bool m_init{false}; + + float m_count{1}; + + Platform::GLContext *m_ctx; + GL::Framebuffer m_FBO{NoCreate}; + + Scene3D m_scene; + SceneGraph::DrawableGroup3D m_drawables; + Containers::Optional m_camera; + + GL::Mesh m_subject{NoCreate}; + Shaders::Phong m_subjectShader{NoCreate}; + Object3D* m_subjectObject{nullptr}; + + GL::Mesh m_grid{NoCreate}; + Shaders::Flat3D m_gridShader{NoCreate}; +}; + +class GridDrawable : public SceneGraph::Drawable3D { +public: + explicit GridDrawable(Object3D &object, Shaders::Flat3D &shader, + GL::Mesh &mesh, SceneGraph::DrawableGroup3D &drawables) + : SceneGraph::Drawable3D{object, &drawables}, + m_shader(shader), + m_mesh(mesh) {} + + void draw(const Matrix4 &transformation, SceneGraph::Camera3D &camera); + +private: + Shaders::Flat3D &m_shader; + GL::Mesh &m_mesh; +}; + +class SubjectDrawable : public SceneGraph::Drawable3D { +public: + explicit SubjectDrawable(Object3D &object, Shaders::Phong &shader, + GL::Mesh &mesh, SceneGraph::DrawableGroup3D &drawables) + : SceneGraph::Drawable3D{object, &drawables}, + m_shader(shader), + m_mesh(mesh) {} + + void draw(const Matrix4 &transformation, SceneGraph::Camera3D &camera); + +private: + Shaders::Phong &m_shader; + GL::Mesh &m_mesh; +}; + +#endif // MAGNUM_RENDER_H diff --git a/src/main.cpp b/src/main.cpp new file mode 100644 index 0000000..379c3c2 --- /dev/null +++ b/src/main.cpp @@ -0,0 +1,36 @@ +#include +#include +#include + +#include "magnum_item.h" +#include "glclampf.h" + +#include +#include +#include + +int main(int argc, char *argv[]) { + // Enable AA + QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling); + QGuiApplication::setAttribute(Qt::AA_UseOpenGLES); + + // Initialize Qt application + QGuiApplication app(argc, argv); + + // Enable logging + QLoggingCategory::setFilterRules("qt.scenegraph.general=true"); + + // Manually register custom types + qmlRegisterType("Magnum", 1, 0, "Magnum"); + + QQmlApplicationEngine engine; + const QUrl url(QStringLiteral("qrc:/main.qml")); + QObject::connect(&engine, &QQmlApplicationEngine::objectCreated, + &app, [url](QObject *obj, const QUrl &objUrl) { + if (!obj && url == objUrl) + QCoreApplication::exit(-1); + }, Qt::QueuedConnection); + engine.load(url); + + return app.exec(); +} diff --git a/src/qml/main.qml b/src/qml/main.qml new file mode 100644 index 0000000..564efd7 --- /dev/null +++ b/src/qml/main.qml @@ -0,0 +1,103 @@ +import QtQuick 2.12 +import QtQuick.Controls 2.5 +import QtQuick.Layouts 1.3 +import Magnum 1.0 + +ApplicationWindow { + visible: true + width: 640 + height: 480 + title: qsTr("My Application") + + RowLayout { + id: root + anchors.fill: parent + spacing: 0 + + ColumnLayout { + Layout.fillHeight: true + Layout.preferredWidth: parent.width * 0.25 + Layout.alignment: Qt.AlignLeft | Qt.AlignTop + Layout.margins: 20 + spacing: 20 + + Label { + text: "Controls" + font.pointSize: 14 + } + GroupBox { + Layout.preferredWidth: parent.width + + RowLayout { + anchors.left: parent.left + anchors.right: parent.right + + Label { + Layout.preferredWidth: parent.width/4 + text: "Hue" + } + Label { + text: qsTr("%1°").arg(Math.round((180/Math.PI)*hue.value)) + color: palette.highlight + } + Slider { + id: hue + anchors.right: parent.right + Layout.preferredWidth: parent.width/2 + + from: 0 + to: Math.PI*2 + } + } + } + GroupBox { + Layout.preferredWidth: parent.width + + RowLayout { + anchors.left: parent.left + anchors.right: parent.right + + Label { + Layout.preferredWidth: parent.width/4 + text: "Count" + } + Label { + text: count.value + color: palette.highlight + } + Slider { + id: count + anchors.right: parent.right + Layout.preferredWidth: parent.width/2 + + from: 1 + to: 5 + stepSize: 1 + snapMode: Slider.SnapAlways + } + } + } + Item { + Layout.preferredWidth: parent.width + + CheckBox { + text: "Lagging" + } + } + } + Magnum { + Layout.fillHeight: true + Layout.fillWidth: true + + hue: hue.value + count: count.value + + SequentialAnimation on t { + NumberAnimation { to: 1; duration: 2500; easing.type: Easing.InQuad } + NumberAnimation { to: 0; duration: 2500; easing.type: Easing.OutQuad } + loops: Animation.Infinite + running: true + } + } + } +} diff --git a/src/qml/main.qrc b/src/qml/main.qrc new file mode 100644 index 0000000..af1cc9b --- /dev/null +++ b/src/qml/main.qrc @@ -0,0 +1,6 @@ + + + main.qml + qtquickcontrols2.conf + + diff --git a/src/qml/qtquickcontrols2.conf b/src/qml/qtquickcontrols2.conf new file mode 100644 index 0000000..f2246f8 --- /dev/null +++ b/src/qml/qtquickcontrols2.conf @@ -0,0 +1,9 @@ +; This file can be edited to change the style of the application +; Read "Qt Quick Controls 2 Configuration File" for details: +; http://doc.qt.io/qt-5/qtquickcontrols2-configuration.html + +[Controls] +Style=Fusion + +[Fusion\Palette] +Highlight=#ff0000