#.rst:
# Find Magnum
# -----------
#
# Finds the Magnum library. Basic usage::
#
# find_package(Magnum REQUIRED)
#
# This module tries to find the base Magnum library and then defines the
# following:
#
# Magnum_FOUND - Whether the base library was found
# MAGNUM_DEPLOY_PREFIX - Prefix where to put final application
# executables, defaults to ``.``. If a relative path is used, it's relative
# to :variable:`CMAKE_INSTALL_PREFIX`.
# MAGNUM_PLUGINS_DEBUG_DIR - Base directory with dynamic plugins for
# debug builds, defaults to magnum-d/ subdirectory of dir where Magnum
# library was found
# MAGNUM_PLUGINS_RELEASE_DIR - Base directory with dynamic plugins for
# release builds, defaults to magnum/ subdirectory of dir where Magnum
# library was found
# MAGNUM_PLUGINS_DIR - Base directory with dynamic plugins, defaults
# to :variable:`MAGNUM_PLUGINS_RELEASE_DIR` in release builds and
# multi-configuration builds or to :variable:`MAGNUM_PLUGINS_DEBUG_DIR` in
# debug builds
# MAGNUM_PLUGINS_FONT[|_DEBUG|_RELEASE]_DIR - Directory with dynamic font
# plugins
# MAGNUM_PLUGINS_FONTCONVERTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic
# font converter plugins
# MAGNUM_PLUGINS_IMAGECONVERTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic
# image converter plugins
# MAGNUM_PLUGINS_SCENECONVERTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic
# scene converter plugins
# MAGNUM_PLUGINS_IMPORTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic
# importer plugins
# MAGNUM_PLUGINS_AUDIOIMPORTER[|_DEBUG|_RELEASE]_DIR - Directory with dynamic
# audio importer plugins
#
# If Magnum is built for Emscripten, the following variables contain paths to
# various support files:
#
# MAGNUM_EMSCRIPTENAPPLICATION_JS - Path to the EmscriptenApplication.js file
# MAGNUM_WINDOWLESSEMSCRIPTENAPPLICATION_JS - Path to the
# WindowlessEmscriptenApplication.js file
# MAGNUM_WEBAPPLICATION_CSS - Path to the WebApplication.css file
#
# This command will try to find only the base library, not the optional
# components. The base library depends on Corrade and OpenGL libraries (or
# OpenGL ES libraries). Additional dependencies are specified by the
# components. The optional components are:
#
# AnyAudioImporter - Any audio importer
# AnyImageConverter - Any image converter
# AnyImageImporter - Any image importer
# AnySceneConverter - Any scene converter
# AnySceneImporter - Any scene importer
# Audio - Audio library
# DebugTools - DebugTools library
# GL - GL library
# MaterialTools - MaterialTools library
# MeshTools - MeshTools library
# Primitives - Primitives library
# SceneGraph - SceneGraph library
# SceneTools - SceneTools library
# Shaders - Shaders library
# ShaderTools - ShaderTools library
# Text - Text library
# TextureTools - TextureTools library
# Trade - Trade library
# Vk - Vk library
# AndroidApplication - Android application
# EmscriptenApplication - Emscripten application
# GlfwApplication - GLFW application
# GlxApplication - GLX application
# Sdl2Application - SDL2 application
# XEglApplication - X/EGL application
# WindowlessCglApplication - Windowless CGL application
# WindowlessEglApplication - Windowless EGL application
# WindowlessGlxApplication - Windowless GLX application
# WindowlessIosApplication - Windowless iOS application
# WindowlessWglApplication - Windowless WGL application
# CglContext - CGL context
# EglContext - EGL context
# GlxContext - GLX context
# WglContext - WGL context
# OpenGLTester - OpenGLTester class
# VulkanTester - VulkanTester class
# MagnumFont - Magnum bitmap font plugin
# MagnumFontConverter - Magnum bitmap font converter plugin
# ObjImporter - OBJ importer plugin
# TgaImageConverter - TGA image converter plugin
# TgaImporter - TGA importer plugin
# WavAudioImporter - WAV audio importer plugin
# distancefieldconverter - magnum-distancefieldconverter executable
# fontconverter - magnum-fontconverter executable
# imageconverter - magnum-imageconverter executable
# sceneconverterter - magnum-sceneconverter executable
# shaderconverterter - magnum-shaderconverter executable
# gl-info - magnum-gl-info executable
# vk-info - magnum-vk-info executable
# al-info - magnum-al-info executable
#
# Example usage with specifying additional components is::
#
# find_package(Magnum REQUIRED Trade MeshTools Primitives GlfwApplication)
#
# For each component is then defined:
#
# Magnum_*_FOUND - Whether the component was found
# Magnum::* - Component imported target
#
# If exactly one ``*Application`` or exactly one ``Windowless*Application``
# component is requested and found, its target is available in convenience
# alias ``Magnum::Application`` / ``Magnum::WindowlessApplication`` to simplify
# porting. Similarly, if exactly one ``*Context`` component is requested and
# found, its target is available in convenience alias ``Magnum::GLContext``.
#
# The package is found if either debug or release version of each requested
# library (or plugin) is found. If both debug and release libraries (or
# plugins) are found, proper version is chosen based on actual build
# configuration of the project (i.e. Debug build is linked to debug libraries,
# Release build to release libraries). Note that this autodetection might fail
# for the :variable:`MAGNUM_PLUGINS_DIR` variable, especially on
# multi-configuration build systems. You can make use of
# ``CORRADE_IS_DEBUG_BUILD`` preprocessor variable along with
# ``MAGNUM_PLUGINS_*_DEBUG_DIR`` / ``MAGNUM_PLUGINS_*_RELEASE_DIR`` variables
# to decide in preprocessing step.
#
# Features of found Magnum library are exposed in these variables:
#
# MAGNUM_BUILD_DEPRECATED - Defined if compiled with deprecated features
# included
# MAGNUM_BUILD_STATIC - Defined if compiled as static libraries
# MAGNUM_BUILD_STATIC_UNIQUE_GLOBALS - Defined if static libraries keep the
# globals unique even across different shared libraries
# MAGNUM_TARGET_GL - Defined if compiled with OpenGL interop
# MAGNUM_TARGET_GLES - Defined if compiled for OpenGL ES
# MAGNUM_TARGET_GLES2 - Defined if compiled for OpenGL ES 2.0
# MAGNUM_TARGET_GLES3 - Defined if compiled for OpenGL ES 3.0
# MAGNUM_TARGET_WEBGL - Defined if compiled for WebGL
# MAGNUM_TARGET_EGL - Defined if compiled for EGL instead of a
# platform-specific OpenGL support library like CGL, EAGL, GLX or WGL
# MAGNUM_TARGET_VK - Defined if compiled with Vulkan interop
#
# The following variables are provided for backwards compatibility purposes
# only when MAGNUM_BUILD_DEPRECATED is enabled and will be removed in a future
# release:
#
# MAGNUM_BUILD_MULTITHREADED - Alias to CORRADE_BUILD_MULTITHREADED. Use
# CORRADE_BUILD_MULTITHREADED instead.
# MAGNUM_TARGET_HEADLESS - Alias to MAGNUM_TARGET_EGL, unless on iOS,
# Android, Emscripten or Windows RT. Use MAGNUM_TARGET_EGL instead.
# MAGNUM_TARGET_DESKTOP_GLES` - Defined if compiled for OpenGL ES but
# GLX / WGL is used instead of EGL. Use MAGNUM_TARGET_EGL instead.
#
# 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_SHADERCONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Shader
# converter plugin binary installation directory
# MAGNUM_PLUGINS_SHADERCONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Shader
# converter plugin library installation directory
# MAGNUM_PLUGINS_FONT_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Font plugin binary
# installation directory
# MAGNUM_PLUGINS_FONT_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Font plugin
# library installation directory
# MAGNUM_PLUGINS_FONTCONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Font
# converter plugin binary installation directory
# MAGNUM_PLUGINS_FONTCONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Font
# converter plugin library installation directory
# MAGNUM_PLUGINS_IMAGECONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Image
# converter plugin binary installation directory
# MAGNUM_PLUGINS_IMAGECONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Image
# converter plugin library installation directory
# MAGNUM_PLUGINS_IMPORTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Importer
# plugin binary installation directory
# MAGNUM_PLUGINS_IMPORTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Importer
# plugin library installation directory
# MAGNUM_PLUGINS_SCENECONVERTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Scene
# converter plugin binary installation directory
# MAGNUM_PLUGINS_SCENECONVERTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Scene
# converter plugin library installation directory
# MAGNUM_PLUGINS_AUDIOIMPORTER_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Audio
# importer plugin binary installation directory
# MAGNUM_PLUGINS_AUDIOIMPORTER_[DEBUG|RELEASE]_LIBRARY_INSTALL_DIR - Audio
# importer plugin library installation directory
# MAGNUM_INCLUDE_INSTALL_DIR - Header installation directory
# MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR - Plugin header installation directory
#
#
# This file is part of Magnum.
#
# Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
# 2020, 2021, 2022, 2023 Vladimír Vondruš <mosra@centrum.cz>
#
# 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 ( _magnum_component ${ Magnum_FIND_COMPONENTS } )
set ( _MAGNUM_ ${ _magnum_component } _CORRADE_DEPENDENCIES )
# Unrolling the transitive dependencies here so this doesn't need to be
# after resolving inter-component dependencies. Listing also all plugins.
if ( _magnum_component MATCHES "^(Audio|DebugTools|MeshTools|Primitives|SceneTools|ShaderTools|Text|TextureTools|Trade|.+Importer|.+ImageConverter|.+Font|.+ShaderConverter)$" )
list ( APPEND _MAGNUM_ ${ _magnum_component } _CORRADE_DEPENDENCIES PluginManager )
endif ( )
if ( _magnum_component STREQUAL DebugTools )
# DebugTools depends on TestSuite optionally, so if it's not there
# assume it wasn't compiled against it. Also, all variables from the
# FindCorrade module overwrite the local variables here (in particular
# _component, _COMPONENT and such), so we need to prefix extensively.
find_package ( Corrade QUIET COMPONENTS TestSuite )
if ( Corrade_TestSuite_FOUND )
list ( APPEND _MAGNUM_ ${ _magnum_component } _CORRADE_DEPENDENCIES TestSuite )
endif ( )
endif ( )
list ( APPEND _MAGNUM_CORRADE_DEPENDENCIES ${ _MAGNUM_${_magnum_component } _CORRADE_DEPENDENCIES} )
endforeach ( )
find_package ( Corrade REQUIRED Utility ${ _MAGNUM_CORRADE_DEPENDENCIES } )
# Root include dir
find_path ( MAGNUM_INCLUDE_DIR
N A M E S M a g n u m / M a g n u m . h )
mark_as_advanced ( MAGNUM_INCLUDE_DIR )
# Configuration file
find_file ( _MAGNUM_CONFIGURE_FILE configure.h
H I N T S $ { M A G N U M _ I N C L U D E _ D I R } / M a g n u m / )
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
R E Q U I R E D _ V A R S M A G N U M _ I N C L U D E _ D I R _ M A G N U M _ C O N F I G U R E _ F I L E )
endif ( )
# Read flags from configuration
file ( READ ${ _MAGNUM_CONFIGURE_FILE } _magnumConfigure )
string ( REGEX REPLACE ";" "\\\\;" _magnumConfigure "${_magnumConfigure}" )
string ( REGEX REPLACE "\n" ";" _magnumConfigure "${_magnumConfigure}" )
set ( _magnumFlags
B U I L D _ D E P R E C A T E D
B U I L D _ S T A T I C
B U I L D _ S T A T I C _ U N I Q U E _ G L O B A L S
T A R G E T _ G L
T A R G E T _ G L E S
T A R G E T _ G L E S 2
T A R G E T _ G L E S 3
T A R G E T _ W E B G L
T A R G E T _ E G L
T A R G E T _ V K )
foreach ( _magnumFlag ${ _magnumFlags } )
list ( FIND _magnumConfigure "#define MAGNUM_${_magnumFlag}" _magnum_ ${ _magnumFlag } )
if ( NOT _magnum_ ${ _magnumFlag } EQUAL -1 )
set ( MAGNUM_ ${ _magnumFlag } 1 )
endif ( )
endforeach ( )
# For compatibility only, to be removed at some point. Refer to
# src/Magnum/configure.h.cmake for the decision logic here.
if ( MAGNUM_BUILD_DEPRECATED )
if ( CORRADE_BUILD_MULTITHREADED )
set ( MAGNUM_BUILD_MULTITHREADED 1 )
endif ( )
if ( NOT CORRADE_TARGET_IOS AND NOT CORRADE_TARGET_ANDROID AND NOT CORRADE_TARGET_EMSCRIPTEN AND NOT CORRADE_TARGET_WINDOWS_RT )
if ( NOT MAGNUM_TARGET_GLES AND MAGNUM_TARGET_EGL )
set ( MAGNUM_TARGET_HEADLESS 1 )
endif ( )
if ( MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_EGL )
set ( MAGNUM_TARGET_DESKTOP_GLES 1 )
endif ( )
endif ( )
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
M A G N U M _ L I B R A R Y _ R E L E A S E )
# 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
I M P O R T E D _ C O N F I G U R A T I O N S R E L E A S E )
set_property ( TARGET Magnum::Magnum PROPERTY
I M P O R T E D _ L O C A T I O N _ R E L E A S E $ { M A G N U M _ L I B R A R Y _ R E L E A S E } )
endif ( )
if ( MAGNUM_LIBRARY_DEBUG )
set_property ( TARGET Magnum::Magnum APPEND PROPERTY
I M P O R T E D _ C O N F I G U R A T I O N S D E B U G )
set_property ( TARGET Magnum::Magnum PROPERTY
I M P O R T E D _ L O C A T I O N _ D E B U G $ { M A G N U M _ L I B R A R Y _ D E B U G } )
endif ( )
# Include directories
set_property ( TARGET Magnum::Magnum APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES
$ { M A G N U M _ I N C L U D E _ D I R } )
# Dependent libraries
set_property ( TARGET Magnum::Magnum APPEND PROPERTY INTERFACE_LINK_LIBRARIES
C o r r a d e : : U t i l i t y )
else ( )
set ( MAGNUM_LIBRARY Magnum::Magnum )
endif ( )
# Component distinction (listing them explicitly to avoid mistakes with finding
# components from other repositories)
set ( _MAGNUM_LIBRARY_COMPONENTS
A u d i o D e b u g T o o l s G L M a t e r i a l T o o l s M e s h T o o l s P r i m i t i v e s S c e n e G r a p h
S c e n e T o o l s S h a d e r s S h a d e r T o o l s T e x t T e x t u r e T o o l s T r a d e
W i n d o w l e s s E g l A p p l i c a t i o n E g l C o n t e x t O p e n G L T e s t e r )
set ( _MAGNUM_PLUGIN_COMPONENTS
A n y A u d i o I m p o r t e r A n y I m a g e C o n v e r t e r A n y I m a g e I m p o r t e r A n y S c e n e C o n v e r t e r
A n y S c e n e I m p o r t e r M a g n u m F o n t M a g n u m F o n t C o n v e r t e r O b j I m p o r t e r
T g a I m a g e C o n v e r t e r T g a I m p o r t e r W a v A u d i o I m p o r t e r )
set ( _MAGNUM_EXECUTABLE_COMPONENTS
i m a g e c o n v e r t e r s c e n e c o n v e r t e r s h a d e r c o n v e r t e r g l - i n f o a l - i n f o )
# Audio and Vk libs aren't enabled by default, and none of the Context,
# Application, Tester libs nor plugins are. Keep in sync with Magnum's root
# CMakeLists.txt.
set ( _MAGNUM_IMPLICITLY_ENABLED_COMPONENTS
D e b u g T o o l s M e s h T o o l s S c e n e G r a p h S h a d e r s S h a d e r T o o l s T e x t T e x t u r e T o o l s T r a d e
G L P r i m i t i v e s )
if ( NOT CORRADE_TARGET_EMSCRIPTEN )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS Vk VulkanTester )
list ( APPEND _MAGNUM_EXECUTABLE_COMPONENTS vk-info )
endif ( )
if ( NOT CORRADE_TARGET_ANDROID )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS Sdl2Application )
endif ( )
if ( NOT CORRADE_TARGET_ANDROID AND NOT CORRADE_TARGET_IOS AND NOT CORRADE_TARGET_EMSCRIPTEN )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS GlfwApplication )
endif ( )
if ( CORRADE_TARGET_ANDROID )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS AndroidApplication )
endif ( )
if ( CORRADE_TARGET_EMSCRIPTEN )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS EmscriptenApplication )
endif ( )
if ( CORRADE_TARGET_IOS )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS WindowlessIosApplication )
elseif ( CORRADE_TARGET_APPLE AND NOT MAGNUM_TARGET_GLES )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS WindowlessCglApplication CglContext )
endif ( )
if ( CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS GlxApplication XEglApplication WindowlessGlxApplication GlxContext )
endif ( )
if ( CORRADE_TARGET_WINDOWS )
list ( APPEND _MAGNUM_LIBRARY_COMPONENTS WindowlessWglApplication WglContext )
endif ( )
if ( CORRADE_TARGET_UNIX OR CORRADE_TARGET_WINDOWS )
list ( APPEND _MAGNUM_EXECUTABLE_COMPONENTS fontconverter distancefieldconverter )
endif ( )
# Inter-component dependencies
set ( _MAGNUM_Audio_DEPENDENCIES )
# Trade is used by CompareImage. If Trade is not enabled, CompareImage is not
# compiled at all.
set ( _MAGNUM_DebugTools_DEPENDENCIES Trade )
set ( _MAGNUM_DebugTools_Trade_DEPENDENCY_IS_OPTIONAL ON )
# MeshTools, Primitives, SceneGraph and Shaders are used only for GL renderers
# in DebugTools. All of this is optional, compiled in only if the base library
# was selected.
if ( MAGNUM_TARGET_GL )
list ( APPEND _MAGNUM_DebugTools_DEPENDENCIES MeshTools Primitives SceneGraph Shaders GL )
set ( _MAGNUM_DebugTools_MeshTools_DEPENDENCY_IS_OPTIONAL ON )
set ( _MAGNUM_DebugTools_Primitives_DEPENDENCY_IS_OPTIONAL ON )
set ( _MAGNUM_DebugTools_SceneGraph_DEPENDENCY_IS_OPTIONAL ON )
set ( _MAGNUM_DebugTools_Shaders_DEPENDENCY_IS_OPTIONAL ON )
set ( _MAGNUM_DebugTools_GL_DEPENDENCY_IS_OPTIONAL ON )
endif ( )
set ( _MAGNUM_MaterialTools_DEPENDENCIES Trade )
set ( _MAGNUM_MeshTools_DEPENDENCIES Trade )
if ( MAGNUM_TARGET_GL )
list ( APPEND _MAGNUM_MeshTools_DEPENDENCIES GL )
endif ( )
set ( _MAGNUM_OpenGLTester_DEPENDENCIES GL )
if ( MAGNUM_TARGET_EGL )
list ( APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessEglApplication )
elseif ( CORRADE_TARGET_IOS )
list ( APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessIosApplication )
elseif ( CORRADE_TARGET_APPLE )
list ( APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessCglApplication )
elseif ( CORRADE_TARGET_UNIX )
list ( APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessGlxApplication )
elseif ( CORRADE_TARGET_WINDOWS )
list ( APPEND _MAGNUM_OpenGLTester_DEPENDENCIES WindowlessWglApplication )
endif ( )
set ( _MAGNUM_Primitives_DEPENDENCIES MeshTools Trade )
if ( MAGNUM_TARGET_GL )
# GL not required by Primitives themselves, but transitively by MeshTools
list ( APPEND _MAGNUM_Primitives_DEPENDENCIES GL )
endif ( )
set ( _MAGNUM_SceneGraph_DEPENDENCIES )
set ( _MAGNUM_SceneTools_DEPENDENCIES Trade )
set ( _MAGNUM_Shaders_DEPENDENCIES 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_VulkanTester_DEPENDENCIES Vk )
set ( _MAGNUM_AndroidApplication_DEPENDENCIES GL )
set ( _MAGNUM_EmscriptenApplication_DEPENDENCIES )
if ( MAGNUM_TARGET_GL )
list ( APPEND _MAGNUM_EmscriptenApplication_DEPENDENCIES GL )
endif ( )
set ( _MAGNUM_GlfwApplication_DEPENDENCIES )
if ( MAGNUM_TARGET_GL )
list ( APPEND _MAGNUM_GlfwApplication_DEPENDENCIES GL )
endif ( )
set ( _MAGNUM_GlxApplication_DEPENDENCIES GL )
set ( _MAGNUM_Sdl2Application_DEPENDENCIES )
if ( MAGNUM_TARGET_GL )
list ( APPEND _MAGNUM_Sdl2Application_DEPENDENCIES GL )
endif ( )
set ( _MAGNUM_WindowlessCglApplication_DEPENDENCIES GL )
set ( _MAGNUM_WindowlessEglApplication_DEPENDENCIES GL )
set ( _MAGNUM_WindowlessGlxApplication_DEPENDENCIES GL )
set ( _MAGNUM_WindowlessIosApplication_DEPENDENCIES GL )
set ( _MAGNUM_WindowlessWglApplication_DEPENDENCIES GL )
set ( _MAGNUM_XEglApplication_DEPENDENCIES GL )
set ( _MAGNUM_CglContext_DEPENDENCIES GL )
set ( _MAGNUM_EglContext_DEPENDENCIES GL )
set ( _MAGNUM_GlxContext_DEPENDENCIES GL )
set ( _MAGNUM_WglContext_DEPENDENCIES GL )
set ( _MAGNUM_MagnumFont_DEPENDENCIES Trade TgaImporter GL ) # and below
set ( _MAGNUM_MagnumFontConverter_DEPENDENCIES Trade TgaImageConverter ) # and below
set ( _MAGNUM_ObjImporter_DEPENDENCIES MeshTools ) # and below
foreach ( _component ${ _MAGNUM_PLUGIN_COMPONENTS } )
if ( _component MATCHES ".+AudioImporter" )
list ( APPEND _MAGNUM_ ${ _component } _DEPENDENCIES Audio )
elseif ( _component MATCHES ".+ShaderConverter" )
list ( APPEND _MAGNUM_ ${ _component } _DEPENDENCIES ShaderTools )
elseif ( _component MATCHES ".+(Importer|ImageConverter|SceneConverter)" )
list ( APPEND _MAGNUM_ ${ _component } _DEPENDENCIES Trade )
elseif ( _component MATCHES ".+(Font|FontConverter)" )
list ( APPEND _MAGNUM_ ${ _component } _DEPENDENCIES Text TextureTools )
endif ( )
endforeach ( )
# Ensure that all inter-component dependencies are specified as well
set ( _MAGNUM_ADDITIONAL_COMPONENTS )
foreach ( _component ${ Magnum_FIND_COMPONENTS } )
# Mark the dependencies as required if the component is also required, but
# only if they themselves are not optional (for example parts of DebugTools
# are present only if their respective base library is compiled)
if ( Magnum_FIND_REQUIRED_ ${ _component } )
foreach ( _dependency ${ _MAGNUM_${_component } _DEPENDENCIES} )
if ( NOT _MAGNUM_ ${ _component } _ ${ _dependency } _DEPENDENCY_IS_OPTIONAL )
set ( Magnum_FIND_REQUIRED_ ${ _dependency } TRUE )
endif ( )
endforeach ( )
endif ( )
list ( APPEND _MAGNUM_ADDITIONAL_COMPONENTS ${ _MAGNUM_${_component } _DEPENDENCIES} )
endforeach ( )
# Join the lists, remove duplicate components
set ( _MAGNUM_ORIGINAL_FIND_COMPONENTS ${ Magnum_FIND_COMPONENTS } )
if ( _MAGNUM_ADDITIONAL_COMPONENTS )
list ( INSERT Magnum_FIND_COMPONENTS 0 ${ _MAGNUM_ADDITIONAL_COMPONENTS } )
endif ( )
if ( Magnum_FIND_COMPONENTS )
list ( REMOVE_DUPLICATES Magnum_FIND_COMPONENTS )
endif ( )
# 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 IN_LIST _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
M A G N U M _ $ { _ C O M P O N E N T } _ L I B R A R Y _ R E L E A S E )
# Plugin components
elseif ( _component IN_LIST _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 )
# ShaderConverter plugin specific name suffixes
elseif ( _component MATCHES ".+ShaderConverter$" )
set ( _MAGNUM_ ${ _COMPONENT } _PATH_SUFFIX shaderconverters )
# Importer plugin specific name suffixes
elseif ( _component MATCHES ".+Importer$" )
set ( _MAGNUM_ ${ _COMPONENT } _PATH_SUFFIX importers )
# Font plugin specific name suffixes
elseif ( _component MATCHES ".+Font$" )
set ( _MAGNUM_ ${ _COMPONENT } _PATH_SUFFIX fonts )
# ImageConverter plugin specific name suffixes
elseif ( _component MATCHES ".+ImageConverter$" )
set ( _MAGNUM_ ${ _COMPONENT } _PATH_SUFFIX imageconverters )
# SceneConverter plugin specific name suffixes
elseif ( _component MATCHES ".+SceneConverter$" )
set ( _MAGNUM_ ${ _COMPONENT } _PATH_SUFFIX sceneconverters )
# FontConverter plugin specific name suffixes
elseif ( _component MATCHES ".+FontConverter$" )
set ( _MAGNUM_ ${ _COMPONENT } _PATH_SUFFIX fontconverters )
endif ( )
# 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
# accidentally break something else
set ( _tmp_prefixes "${CMAKE_FIND_LIBRARY_PREFIXES}" )
set ( CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES};" )
# Try to find both debug and release version. Dynamic and static
# debug libraries are in different places. Static debug plugins are
# in magnum/ with a -d suffix while dynamic debug plugins are in
# magnum-d/ with no suffix. Problem is that Vcpkg's library linking
# automagic needs the static libs to be in the root library
# directory along with everything else and so we need to search for
# the -d suffixed version *before* the unsuffixed so it doesn't
# pick the release library for both debug and release.
find_library ( MAGNUM_ ${ _COMPONENT } _LIBRARY_DEBUG ${ _component } -d
P A T H _ S U F F I X E S m a g n u m / $ { _ M A G N U M _ $ { _ C O M P O N E N T } _ P A T H _ S U F F I X } )
find_library ( MAGNUM_ ${ _COMPONENT } _LIBRARY_DEBUG ${ _component }
P A T H _ S U F F I X E S m a g n u m - d / $ { _ M A G N U M _ $ { _ C O M P O N E N T } _ P A T H _ S U F F I X } )
find_library ( MAGNUM_ ${ _COMPONENT } _LIBRARY_RELEASE ${ _component }
P A T H _ S U F F I X E S m a g n u m / $ { _ M A G N U M _ $ { _ C O M P O N E N T } _ P A T H _ S U F F I X } )
mark_as_advanced ( MAGNUM_ ${ _COMPONENT } _LIBRARY_DEBUG
M A G N U M _ $ { _ C O M P O N E N T } _ L I B R A R Y _ R E L E A S E )
# Reset back
set ( CMAKE_FIND_LIBRARY_PREFIXES "${_tmp_prefixes}" )
# Executables
elseif ( _component IN_LIST _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
I M P O R T E D _ L O C A T I O N $ { M A G N U M _ $ { _ C O M P O N E N T } _ E X E C U T A B L E } )
endif ( )
# Something unknown, skip. FPHSA will take care of handling this below.
else ( )
continue ( )
endif ( )
# Library location for libraries/plugins
if ( _component IN_LIST _MAGNUM_LIBRARY_COMPONENTS OR _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS )
if ( MAGNUM_ ${ _COMPONENT } _LIBRARY_RELEASE )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I M P O R T E D _ C O N F I G U R A T I O N S R E L E A S E )
set_property ( TARGET Magnum:: ${ _component } PROPERTY
I M P O R T E D _ L O C A T I O N _ R E L E A S E $ { M A G N U M _ $ { _ C O M P O N E N T } _ L I B R A R Y _ R E L E A S E } )
endif ( )
if ( MAGNUM_ ${ _COMPONENT } _LIBRARY_DEBUG )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I M P O R T E D _ C O N F I G U R A T I O N S D E B U G )
set_property ( TARGET Magnum:: ${ _component } PROPERTY
I M P O R T E D _ L O C A T I O N _ D E B U G $ { M A G N U M _ $ { _ C O M P O N E N T } _ L I B R A R Y _ D E B U G } )
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
I N T E R F A C E _ L I N K _ L I B R A R I E S a n d r o i d E G L : : E G L )
# EmscriptenApplication has no additional dependencies
# GLFW application dependencies
elseif ( _component STREQUAL GlfwApplication )
find_package ( GLFW )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S G L F W : : G L F W )
# 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
I N T E R F A C E _ L I N K _ L I B R A R I E S $ { _ M A G N U M _ A P P L E _ F O U N D A T I O N _ F R A M E W O R K _ L I B R A R Y } )
# Needed for opt-in DPI queries
elseif ( CORRADE_TARGET_UNIX )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S $ { C M A K E _ D L _ L I B S } )
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 ( MAGNUM_TARGET_EGL )
find_package ( EGL )
set_property ( TARGET Magnum:: ${ _component } APPEND
P R O P E R T Y I N T E R F A C E _ L I N K _ L I B R A R I E S E G L : : E G L )
elseif ( CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE )
find_package ( OpenGL )
if ( OPENGL_opengl_LIBRARY AND OpenGL_GL_PREFERENCE STREQUAL GLVND )
set_property ( TARGET Magnum:: ${ _component } APPEND
P R O P E R T Y I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n G L : : G L X )
endif ( )
endif ( )
endif ( )
# SDL2 application dependencies
elseif ( _component STREQUAL Sdl2Application )
find_package ( SDL2 )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S S D L 2 : : S D L 2 )
# 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
I N T E R F A C E _ L I N K _ L I B R A R I E S $ { _ M A G N U M _ A P P L E _ F O U N D A T I O N _ F R A M E W O R K _ L I B R A R Y } )
# Needed for opt-in DPI queries
elseif ( CORRADE_TARGET_UNIX )
Platform: initial HiDPI support in SDL2 app on Linux and Emscripten.
This is quite complex, actually. The end goal is: when I request an
800x600 window, it should create a window of the same physical size as
an 800x600 window would have on a system default DPI. After that, the
actual window size (for events), framebuffer size and DPI scaling value
(to correctly scale the contents relative to window size) are
platform-dependent.
On macOS and iOS, the DPI scaling is done simply by having the
framebuffer twice the size while the window size (for events) remains
the same. Easy to support.
On Linux, a non-DPI-aware app is simply having a really tiny window. The
worst behavior of all systems. Next to that, SDL_GetDisplayDPI() returns
physical DPI, which is quite useless as the value is usually coming from
Xorg display autodetection and is usually just 96, unless one goes extra
lengths and supplies a correct value via an xorg.conf. The DE is using a
different, user-configurable value for scaling the visuals and this one
is available through a Xft.dpi property. To get it, we dlopen() self and
dlsym() X11 symbols to get this property. If this fails, it might mean
the app doesn't run on X11 (maybe Wayland, maybe something's just messed
up, who knows) and then we fall back to SDL_GetDisplayDPI(). Which is
usually very wrong, so this is also why I'm implementing two ways to
override this -- either via the app Configuration or via a command-line
/ environment variable.
On Emscripten / HTML5, all that's needed is querying device pixel ratio
and then requesting canvas size scaled by that. The event coordinates
are relative to this size, so there's not much more to handle. Physical
canvas size on the page is controlled via CSS, so no issues with stuff
being too big or too small apply -- in the worst case, things may
be blurry.
On Windows, the DPI scaling is something in-between -- if the app
presents itself as DPI-aware, window size is treated as real pixels (so
one gets really what is asked for, i.e. an 800x600 window on a system
with 240 DPI is maybe four centimeters wide). If not, the window is
upscaled (and blurried) by the compositor. In order to have correct
behavior, I first need to query if the app is DPI-aware and then either
scale the requested size or not (to avoid extra huge windows when the
app is not marked as DPI aware). That will be done in a later commit.
8 years ago
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S $ { C M A K E _ D L _ L I B S } )
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 ( MAGNUM_TARGET_EGL )
find_package ( EGL )
set_property ( TARGET Magnum:: ${ _component } APPEND
P R O P E R T Y I N T E R F A C E _ L I N K _ L I B R A R I E S E G L : : E G L )
elseif ( CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE )
find_package ( OpenGL )
if ( OPENGL_opengl_LIBRARY AND OpenGL_GL_PREFERENCE STREQUAL GLVND )
set_property ( TARGET Magnum:: ${ _component } APPEND
P R O P E R T Y I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n G L : : G L X )
endif ( )
endif ( )
endif ( )
# (Windowless) GLX application dependencies
elseif ( _component STREQUAL GlxApplication OR _component STREQUAL WindowlessGlxApplication )
find_package ( X11 )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ I N C L U D E _ D I R E C T O R I E S $ { X 1 1 _ I N C L U D E _ D I R } )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S $ { X 1 1 _ L I B R A R I E S } )
# 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
I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n G L : : G L X )
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
I N T E R F A C E _ L I N K _ L I B R A R I E S E G L : : E G L )
# 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
I N T E R F A C E _ L I N K _ L I B R A R I E S E G L : : E G L $ { _ M A G N U M _ I O S _ F O U N D A T I O N _ F R A M E W O R K _ L I B R A R Y } )
# Windowless WGL application has no additional dependencies
# X/EGL application dependencies
elseif ( _component STREQUAL XEglApplication )
find_package ( EGL )
find_package ( X11 )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ I N C L U D E _ D I R E C T O R I E S $ { X 1 1 _ I N C L U D E _ D I R } )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S E G L : : E G L $ { X 1 1 _ L I B R A R I E S } )
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
I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n G L : : G L X )
else ( )
find_package ( X11 )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ I N C L U D E _ D I R E C T O R I E S $ { X 1 1 _ I N C L U D E _ D I R } )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S $ { X 1 1 _ L I B R A R I E S } )
endif ( )
# EGL context dependencies
elseif ( _component STREQUAL EglContext )
find_package ( EGL )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S E G L : : E G L )
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
I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n A L : : O p e n A L )
# No special setup for DebugTools library
# GL library
elseif ( _component STREQUAL GL )
if ( NOT MAGNUM_TARGET_GLES OR ( MAGNUM_TARGET_GLES AND NOT MAGNUM_TARGET_EGL AND NOT CORRADE_TARGET_IOS ) )
# If the GLVND library (CMake 3.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
I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n G L : : O p e n G L )
else ( )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S $ { O P E N G L _ g l _ L I B R A R Y } )
endif ( )
elseif ( MAGNUM_TARGET_GLES2 )
find_package ( OpenGLES2 REQUIRED )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n G L E S 2 : : O p e n G L E S 2 )
elseif ( MAGNUM_TARGET_GLES3 )
find_package ( OpenGLES3 REQUIRED )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S O p e n G L E S 3 : : O p e n G L E S 3 )
if ( CORRADE_TARGET_EMSCRIPTEN )
if ( CMAKE_VERSION VERSION_LESS 3.13 )
message ( FATAL_ERROR "CMake 3.13+ is required in order to specify Emscripten linker options" )
endif ( )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ O P T I O N S " S H E L L : - s U S E _ W E B G L 2 = 1 " )
endif ( )
endif ( )
# MaterialTools library
elseif ( _component STREQUAL MaterialTools )
set ( _MAGNUM_ ${ _COMPONENT } _INCLUDE_PATH_NAMES PhongToPbrMetallicRoughness.h )
# 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 )
# VulkanTester library
elseif ( _component STREQUAL VulkanTester )
set ( _MAGNUM_ ${ _COMPONENT } _INCLUDE_PATH_SUFFIX Magnum/Vk )
# Primitives library
elseif ( _component STREQUAL Primitives )
set ( _MAGNUM_ ${ _COMPONENT } _INCLUDE_PATH_NAMES Cube.h )
# No special setup for SceneGraph library
# SceneTools library
elseif ( _component STREQUAL SceneTools )
set ( _MAGNUM_ ${ _COMPONENT } _INCLUDE_PATH_NAMES Hierarchy.h )
# No special setup for ShaderTools library
# No special setup for Shaders library
# No special setup for Text library
# TextureTools library
elseif ( _component STREQUAL TextureTools )
set ( _MAGNUM_ ${ _COMPONENT } _INCLUDE_PATH_NAMES Atlas.h )
# No special setup for Trade library
# Vk library
elseif ( _component STREQUAL Vk )
find_package ( Vulkan REQUIRED )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S V u l k a n : : V u l k a n )
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 IN_LIST _MAGNUM_LIBRARY_COMPONENTS OR _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS )
find_path ( _MAGNUM_ ${ _COMPONENT } _INCLUDE_DIR
N A M E S $ { _ M A G N U M _ $ { _ C O M P O N E N T } _ I N C L U D E _ P A T H _ N A M E S }
H I N T S $ { M A G N U M _ I N C L U D E _ D I R } / $ { _ M A G N U M _ $ { _ C O M P O N E N T } _ I N C L U D E _ P A T H _ S U F F I X } )
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. Skip it also
# if the include dir doesn't contain the generated configure.h, which
# is the case with Magnum as a subproject and given plugin not enabled
# -- there it finds just the sources, where's just configure.h.cmake,
# and that's not useful for anything. The assumption here is that it
# will fail later anyway on the binary not being found.
if ( _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS AND _MAGNUM_ ${ _COMPONENT } _INCLUDE_DIR AND EXISTS ${ _MAGNUM_${_COMPONENT } _INCLUDE_DIR}/configure.h )
# 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
I N T E R F A C E _ S O U R C E S $ { _ M A G N U M _ $ { _ C O M P O N E N T } _ I N C L U D E _ D I R } / i m p o r t S t a t i c P l u g i n . c p p )
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 IN_LIST _MAGNUM_LIBRARY_COMPONENTS OR _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS )
foreach ( _dependency ${ _MAGNUM_${_component } _CORRADE_DEPENDENCIES} )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S C o r r a d e : : $ { _ d e p e n d e n c y } )
endforeach ( )
set_property ( TARGET Magnum:: ${ _component } APPEND PROPERTY
I N T E R F A C E _ L I N K _ L I B R A R I E S M a g n u m : : M a g n u m )
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
I N T E R F A C E _ L I N K _ L I B R A R I E S M a g n u m : : $ { _ d e p e n d e n c y } )
else ( )
list ( APPEND _MAGNUM_ ${ _component } _OPTIONAL_DEPENDENCIES_TO_ADD
$ { _ d e p e n d e n c y } )
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 IN_LIST _MAGNUM_LIBRARY_COMPONENTS OR _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS ) AND _MAGNUM_ ${ _COMPONENT } _INCLUDE_DIR AND ( MAGNUM_ ${ _COMPONENT } _LIBRARY_DEBUG OR MAGNUM_ ${ _COMPONENT } _LIBRARY_RELEASE ) ) OR ( _component IN_LIST _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
P A T H _ S U F F I X E S s h a r e / m a g n u m )
find_file ( MAGNUM_WINDOWLESSEMSCRIPTENAPPLICATION_JS WindowlessEmscriptenApplication.js
P A T H _ S U F F I X E S s h a r e / m a g n u m )
find_file ( MAGNUM_WEBAPPLICATION_CSS WebApplication.css
P A T H _ S U F F I X E S s h a r e / m a g n u m )
mark_as_advanced (
M A G N U M _ E M S C R I P T E N A P P L I C A T I O N _ J S
M A G N U M _ W I N D O W L E S S E M S C R I P T E N A P P L I C A T I O N _ J S
M A G N U M _ W E B A P P L I C A T I O N _ C S S )
set ( MAGNUM_EXTRAS_NEEDED
M A G N U M _ E M S C R I P T E N A P P L I C A T I O N _ J S
M A G N U M _ W I N D O W L E S S E M S C R I P T E N A P P L I C A T I O N _ J S
M A G N U M _ W E B A P P L I C A T I O N _ C S S )
endif ( )
# For CMake 3.16+ with REASON_FAILURE_MESSAGE, provide additional potentially
# useful info about the failed components.
if ( NOT CMAKE_VERSION VERSION_LESS 3.16 )
set ( _MAGNUM_REASON_FAILURE_MESSAGE )
# Go only through the originally specified find_package() components, not
# the dependencies added by us afterwards
foreach ( _component ${ _MAGNUM_ORIGINAL_FIND_COMPONENTS } )
if ( Magnum_ ${ _component } _FOUND )
continue ( )
endif ( )
# If it's not known at all, tell the user -- it might be a new library
# and an old Find module, or something platform-specific.
if ( NOT _component IN_LIST _MAGNUM_LIBRARY_COMPONENTS AND NOT _component IN_LIST _MAGNUM_PLUGIN_COMPONENTS AND NOT _component IN_LIST _MAGNUM_EXECUTABLE_COMPONENTS )
list ( APPEND _MAGNUM_REASON_FAILURE_MESSAGE "${_component} is not a known component on this platform." )
# Otherwise, if it's not among implicitly built components, hint that
# the user may need to enable it
# TODO: currently, the _FOUND variable doesn't reflect if dependencies
# were found. When it will, this needs to be updated to avoid
# misleading messages.
elseif ( NOT _component IN_LIST _MAGNUM_IMPLICITLY_ENABLED_COMPONENTS )
string ( TOUPPER ${ _component } _COMPONENT )
list ( APPEND _MAGNUM_REASON_FAILURE_MESSAGE "${_component} is not built by default. Make sure you enabled MAGNUM_WITH_${_COMPONENT} when building Magnum." )
# Otherwise we have no idea. Better be silent than to print something
# misleading.
else ( )
endif ( )
endforeach ( )
string ( REPLACE ";" " " _MAGNUM_REASON_FAILURE_MESSAGE "${_MAGNUM_REASON_FAILURE_MESSAGE}" )
set ( _MAGNUM_REASON_FAILURE_MESSAGE REASON_FAILURE_MESSAGE "${_MAGNUM_REASON_FAILURE_MESSAGE}" )
endif ( )
# Complete the check with also all components
include ( FindPackageHandleStandardArgs )
find_package_handle_standard_args ( Magnum
R E Q U I R E D _ V A R S M A G N U M _ I N C L U D E _ D I R M A G N U M _ L I B R A R Y $ { M A G N U M _ E X T R A S _ N E E D E D }
H A N D L E _ C O M P O N E N T S
$ { _ M A G N U M _ R E A S O N _ F A I L U R E _ M E S S A G E } )
# 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
I N T E R F A C E _ L I N K _ L I B R A R I E S M a g n u m : : $ { _ d e p e n d e n c y } )
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
$ { p r o p e r t y } " $ { _ M A G N U M _ W I N D O W L E S S A P P L I C A T I O N _ $ { p r o p e r t y } } " )
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
I M P O R T E D _ L O C A T I O N _ R E L E A S E $ { _ M A G N U M _ W I N D O W L E S S A P P L I C A T I O N _ I M P O R T E D _ L O C A T I O N _ R E L E A S E } )
endif ( )
if ( _MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_LOCATION_DEBUG )
set_target_properties ( Magnum::WindowlessApplication PROPERTIES
I M P O R T E D _ L O C A T I O N _ D E B U G $ { _ M A G N U M _ W I N D O W L E S S A P P L I C A T I O N _ I M P O R T E D _ L O C A T I O N _ D E B U G } )
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 }
$ { _ M A G N U M _ A P P L I C A T I O N _ A L I A S } $ { p r o p e r t y } )
if ( _MAGNUM_APPLICATION_ ${ property } )
set_target_properties ( Magnum::Application PROPERTIES ${ property }
" $ { _ M A G N U M _ A P P L I C A T I O N _ $ { p r o p e r t y } } " )
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
I M P O R T E D _ L O C A T I O N _ R E L E A S E $ { _ M A G N U M _ A P P L I C A T I O N _ I M P O R T E D _ L O C A T I O N _ R E L E A S E } )
endif ( )
if ( _MAGNUM_APPLICATION_IMPORTED_LOCATION_DEBUG )
set_target_properties ( Magnum::Application PROPERTIES
I M P O R T E D _ L O C A T I O N _ D E B U G $ { _ M A G N U M _ A P P L I C A T I O N _ I M P O R T E D _ L O C A T I O N _ D E B U G } )
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 }
" $ { _ M A G N U M _ G L C O N T E X T _ $ { p r o p e r t y } } " )
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
I M P O R T E D _ L O C A T I O N _ R E L E A S E $ { _ M A G N U M _ G L C O N T E X T _ I M P O R T E D _ L O C A T I O N _ R E L E A S E } )
endif ( )
if ( _MAGNUM_GLCONTEXT_IMPORTED_LOCATION_DEBUG )
set_target_properties ( Magnum::GLContext PROPERTIES
I M P O R T E D _ L O C A T I O N _ D E B U G $ { _ M A G N U M _ G L C O N T E X T _ I M P O R T E D _ L O C A T I O N _ D E B U G } )
endif ( )
endif ( )
# Prevent creating the alias again
unset ( _MAGNUM_GLCONTEXT_ALIAS )
endif ( )
# Installation and deploy dirs
set ( MAGNUM_DEPLOY_PREFIX "."
C A C H E S T R I N G " P r e f i x w h e r e t o p u t f i n a l a p p l i c a t i o n e x e c u t a b l e s " )
include ( ${ CORRADE_LIB_SUFFIX_MODULE } )
set ( MAGNUM_BINARY_INSTALL_DIR bin )
set ( MAGNUM_LIBRARY_INSTALL_DIR lib ${ LIB_SUFFIX } )
set ( MAGNUM_DATA_INSTALL_DIR share/magnum )
set ( MAGNUM_INCLUDE_INSTALL_DIR include/Magnum )
set ( MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR include/MagnumExternal )
set ( MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR include/MagnumPlugins )
if ( MAGNUM_BUILD_DEPRECATED AND MAGNUM_INCLUDE_INSTALL_PREFIX AND NOT MAGNUM_INCLUDE_INSTALL_PREFIX STREQUAL "." )
message ( DEPRECATION "MAGNUM_INCLUDE_INSTALL_PREFIX is obsolete as its primary use was for old Android NDK versions. Please switch to the NDK r19+ layout instead of using this variable and recreate your build directory to get rid of this warning." )
set ( MAGNUM_DATA_INSTALL_DIR ${ MAGNUM_INCLUDE_INSTALL_PREFIX } / ${ MAGNUM_DATA_INSTALL_DIR } )
set ( MAGNUM_INCLUDE_INSTALL_DIR ${ MAGNUM_INCLUDE_INSTALL_PREFIX } / ${ MAGNUM_INCLUDE_INSTALL_DIR } )
set ( MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR ${ MAGNUM_INCLUDE_INSTALL_PREFIX } / ${ MAGNUM_EXTERNAL_INCLUDE_INSTALL_DIR } )
set ( MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR ${ MAGNUM_INCLUDE_INSTALL_PREFIX } / ${ MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR } )
endif ( )
set ( MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_BINARY_INSTALL_DIR } /magnum-d )
set ( MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR ${ MAGNUM_LIBRARY_INSTALL_DIR } /magnum-d )
set ( MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR ${ MAGNUM_BINARY_INSTALL_DIR } /magnum )
set ( MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_LIBRARY_INSTALL_DIR } /magnum )
set ( MAGNUM_PLUGINS_SHADERCONVERTER_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR } /shaderconverters )
set ( MAGNUM_PLUGINS_SHADERCONVERTER_DEBUG_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR } /shaderconverters )
set ( MAGNUM_PLUGINS_SHADERCONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR } /shaderconverters )
set ( MAGNUM_PLUGINS_SHADERCONVERTER_RELEASE_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR } /shaderconverters )
set ( MAGNUM_PLUGINS_FONT_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR } /fonts )
set ( MAGNUM_PLUGINS_FONT_DEBUG_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR } /fonts )
set ( MAGNUM_PLUGINS_FONT_RELEASE_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR } /fonts )
set ( MAGNUM_PLUGINS_FONT_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR } /fonts )
set ( MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR } /fontconverters )
set ( MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR } /fontconverters )
set ( MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR } /imageconverters )
set ( MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR } /imageconverters )
set ( MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR } /imageconverters )
set ( MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR } /imageconverters )
set ( MAGNUM_PLUGINS_IMPORTER_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR } /importers )
set ( MAGNUM_PLUGINS_IMPORTER_DEBUG_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR } /importers )
set ( MAGNUM_PLUGINS_IMPORTER_RELEASE_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR } /importers )
set ( MAGNUM_PLUGINS_IMPORTER_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR } /importers )
set ( MAGNUM_PLUGINS_SCENECONVERTER_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR } /sceneconverters )
set ( MAGNUM_PLUGINS_SCENECONVERTER_DEBUG_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR } /sceneconverters )
set ( MAGNUM_PLUGINS_SCENECONVERTER_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR } /sceneconverters )
set ( MAGNUM_PLUGINS_SCENECONVERTER_RELEASE_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR } /sceneconverters )
set ( MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_BINARY_INSTALL_DIR } /audioimporters )
set ( MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_DEBUG_LIBRARY_INSTALL_DIR } /audioimporters )
set ( MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_BINARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_BINARY_INSTALL_DIR } /audioimporters )
set ( MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_LIBRARY_INSTALL_DIR ${ MAGNUM_PLUGINS_RELEASE_LIBRARY_INSTALL_DIR } /audioimporters )
# Get base plugin directory from main library location. This is *not* PATH,
# because CMake always converts the path to an absolute location internally,
# making it impossible to specify relative paths there. Sorry in advance for
# not having the dir selection button in CMake GUI.
set ( MAGNUM_PLUGINS_DEBUG_DIR ""
C A C H E S T R I N G " B a s e d i r e c t o r y w h e r e t o l o o k f o r M a g n u m p l u g i n s f o r d e b u g b u i l d s " )
set ( MAGNUM_PLUGINS_RELEASE_DIR ""
C A C H E S T R I N G " B a s e d i r e c t o r y w h e r e t o l o o k f o r M a g n u m p l u g i n s f o r r e l e a s e b u i l d s " )
set ( MAGNUM_PLUGINS_DIR ""
C A C H E S T R I N G " B a s e d i r e c t o r y w h e r e t o l o o k f o r M a g n u m p l u g i n s " )
# Plugin directories. Set only if the above are non-empty. otherwise empty as
# well.
if ( MAGNUM_PLUGINS_DIR )
set ( MAGNUM_PLUGINS_FONT_DIR ${ MAGNUM_PLUGINS_DIR } /fonts )
set ( MAGNUM_PLUGINS_FONTCONVERTER_DIR ${ MAGNUM_PLUGINS_DIR } /fontconverters )
set ( MAGNUM_PLUGINS_IMAGECONVERTER_DIR ${ MAGNUM_PLUGINS_DIR } /imageconverters )
set ( MAGNUM_PLUGINS_IMPORTER_DIR ${ MAGNUM_PLUGINS_DIR } /importers )
set ( MAGNUM_PLUGINS_SCENECONVERTER_DIR ${ MAGNUM_PLUGINS_DIR } /sceneconverters )
set ( MAGNUM_PLUGINS_AUDIOIMPORTER_DIR ${ MAGNUM_PLUGINS_DIR } /audioimporters )
endif ( )
if ( MAGNUM_PLUGINS_DEBUG_DIR )
set ( MAGNUM_PLUGINS_FONT_DEBUG_DIR ${ MAGNUM_PLUGINS_DEBUG_DIR } /fonts )
set ( MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_DIR ${ MAGNUM_PLUGINS_DEBUG_DIR } /fontconverters )
set ( MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_DIR ${ MAGNUM_PLUGINS_DEBUG_DIR } /imageconverters )
set ( MAGNUM_PLUGINS_IMPORTER_DEBUG_DIR ${ MAGNUM_PLUGINS_DEBUG_DIR } /importers )
set ( MAGNUM_PLUGINS_FONT_RELEASE_DIR ${ MAGNUM_PLUGINS_RELEASE_DIR } /fonts )
set ( MAGNUM_PLUGINS_SCENECONVERTER_DEBUG_DIR ${ MAGNUM_PLUGINS_DEBUG_DIR } /sceneconverters )
set ( MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_DIR ${ MAGNUM_PLUGINS_DEBUG_DIR } /audioimporters )
endif ( )
if ( MAGNUM_PLUGINS_RELEASE_DIR )
set ( MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_DIR ${ MAGNUM_PLUGINS_RELEASE_DIR } /fontconverters )
set ( MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_DIR ${ MAGNUM_PLUGINS_RELEASE_DIR } /imageconverters )
set ( MAGNUM_PLUGINS_IMPORTER_RELEASE_DIR ${ MAGNUM_PLUGINS_RELEASE_DIR } /importers )
set ( MAGNUM_PLUGINS_SCENECONVERTER_RELEASE_DIR ${ MAGNUM_PLUGINS_RELEASE_DIR } /sceneconverters )
set ( MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_DIR ${ MAGNUM_PLUGINS_RELEASE_DIR } /audioimporters )
endif ( )
