ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5976 Commits
21 Branches
19 Tags
70 MiB
Tree: ff7b9eadcb
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ff7b9eadcb'
${ noResults }
magnum/modules/FindMagnum.cmake

1066 lines
53 KiB
Raw Normal View History Unescape

Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#.rst:
# Find Magnum
# -----------
Installation commands in CMake, development PKGBUILD.
16 years ago
#
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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
modules: added MAGNUM_DEPLOY_PREFIX cache variable. Like CMAKE_INSTALL_PREFIX, but for deploying final executables (such as Emscripten apps).
9 years ago
# MAGNUM_DEPLOY_PREFIX - Prefix where to put final application
modules: give MAGNUM_DEPLOY_PREFIX a saner default. Otherwise, when used as-is in the install() command, CMake complains that DESTINATION can't be empty.
9 years ago
# executables, defaults to ``.``. If a relative path is used, it's relative
# to :variable:`CMAKE_INSTALL_PREFIX`.
CMake: make it possible to override include install location. Needed so Gradle CMake on Android "just works".
8 years ago
# 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`.
modules: expose separate plugin directories for debug and release builds.
12 years ago
# 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
Install also debug plugins to different location. Following changes done in Corrade.
12 years ago
# MAGNUM_PLUGINS_DIR - Base directory with dynamic plugins, defaults
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# to :variable:`MAGNUM_PLUGINS_RELEASE_DIR` in release builds and
# multi-configuration builds or to :variable:`MAGNUM_PLUGINS_DEBUG_DIR` in
# debug builds. You can modify all three variables (e.g. set them to ``.``
# when deploying on Windows with plugins stored relatively to the
# executable), the following ``MAGNUM_PLUGINS_*_DIR`` variables depend on it.
modules: expose separate plugin directories for debug and release builds.
12 years ago
# MAGNUM_PLUGINS_FONT[|_DEBUG|_RELEASE]_DIR - Directory with dynamic font
Install also debug plugins to different location. Following changes done in Corrade.
12 years ago
# plugins
modules: expose separate plugin directories for debug and release builds.
12 years ago
# 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
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
# This command will try to find only the base library, not the optional
Use glLoadGen instead of GLEW. Removed all known GLEW workarounds, added one small workaround for missing ARB_texture_compression_bptc. I didn't want to patch glLoadGen for just four enum values, this way it's possible to use stock one without any patching (except for missing OpenGL 2.1 support, as stated in external/OpenGL/GL/README.md). As one file now replaces both `glew.h` and `glcorearb.h` and it has the same size as `glcorearb.h` alone , it saves approximately 18k LOC, resulting in 15 second shorter compilation time (5:03 before, 4:48 now). Not bad.
13 years ago
# 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:
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#
Integrated the Any* plugins to the buildsystem and docs.
8 years ago
# AnyAudioImporter - Any audio importer
# AnyImageConverter - Any image converter
# AnyImageImporter - Any image importer
# AnySceneImporter - Any scene importer
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Audio - Audio library
# DebugTools - DebugTools library
Split the OpenGL layer out, pt 2: updated FindMagnum.cmake.
8 years ago
# GL - GL library
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# MeshTools - MeshTools library
# Primitives - Primitives library
# SceneGraph - SceneGraph library
# Shaders - Shaders library
# Shapes - Shapes library
# Text - Text library
# TextureTools - TextureTools library
Split the Trade library out.
8 years ago
# Trade - Trade library
Bootstrap Vulkan support.
8 years ago
# Vk - Vk library
modules: Add GlfwApplication to FindMagnum.cmake Signed-off-by: Squareys <Squareys@googlemail.com>
10 years ago
# GlfwApplication - GLFW application
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# GlutApplication - GLUT application
# GlxApplication - GLX application
# Sdl2Application - SDL2 application
# XEglApplication - X/EGL application
# WindowlessCglApplication - Windowless CGL application
Platform: new WindowlessEglApplication. Uses just EGL and no other platform toolkit, meaning that the same code can be used on all platforms if the drivers support it. Should be working for OpenGL ES for most drivers, however desktop OpenGL is supported only on NVidia since version 355.
10 years ago
# WindowlessEglApplication - Windowless EGL application
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# WindowlessGlxApplication - Windowless GLX application
Platform: added WindowlessIosApplication.
10 years ago
# WindowlessIosApplication - Windowless iOS application
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# WindowlessWglApplication - Windowless WGL application
Platform: added WindowlessWindowsEglApplication. Windowless application on Windows, OpenGL ES and EGL. Works with ANGLE.
11 years ago
# WindowlessWindowsEglApplication - Windowless Windows/EGL application
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# CglContext - CGL context
# EglContext - EGL context
# GlxContext - GLX context
# WglContext - WGL context
Made Test/AbstractOpenGLTester.h a public and documented API. There will be numerous additions to this one so it made sense to make it a static library instead of a header-only library. That also allows CMake users to just link to Magnum::OpenGLTester instead of going through the pain of a huge branching in order to find a correct windowless application just to run their tests. It could have been done even without the static library using a INTERFACE target, but that wouldn't work on CMake < 3.0 (which, unfortunately, quite a few people are still stuck with). Unfortunately it's already heavily used elsewhere so I had to go through the pain of deprecating the old implementation. The old implementation was header-only so it can't be just typedef'd to the new one as there would be linker failures. So the old header is just kept as it was, with only the macros reduced.
9 years ago
# OpenGLTester - OpenGLTester class
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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
New magnum-imageconverter utility. Converts images of different formats.
10 years ago
# imageconverter - magnum-imageconverter executable
Split the OpenGL layer out, pt 7: renamed magnum-info to magnum-gl-info. The WITH_MAGNUMINFO CMake option is now WITH_GL_INFO. No backwards compatibility is provided, sorry.
8 years ago
# gl-info - magnum-gl-info executable
Audio: added magnum-al-info utility.
10 years ago
# al-info - magnum-al-info executable
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#
# Example usage with specifying additional components is::
#
Split the Trade library out.
8 years ago
# find_package(Magnum REQUIRED Trade MeshTools Primitives GlutApplication)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
# For each component is then defined:
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#
# 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
Split the OpenGL layer out, pt 27: CMake Magnum::{Context => GLContext}. No backwards compatibility provided, sorry.
8 years ago
# found, its target is available in convenience alias ``Magnum::GLContext``.
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
#
Install and find debug libraries with "-d" suffix. Makes it possible to have both debug and release libraries installed. If both libraries are present when finding the package, proper version is used based on what configuration is used in depending project.
12 years ago
# The package is found if either debug or release version of each requested
Install also debug plugins to different location. Following changes done in Corrade.
12 years ago
# 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
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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.
Install and find debug libraries with "-d" suffix. Makes it possible to have both debug and release libraries installed. If both libraries are present when finding the package, proper version is used based on what configuration is used in depending project.
12 years ago
#
Updated documentation on building and library finding.
13 years ago
# Features of found Magnum library are exposed in these variables:
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#
Initial support for ability to disable building of deprecated APIs. CMake option `BUILD_DEPRECATED`, enabled by default, exposed as `MAGNUM_BUILD_DEPRECATED` to users both in CMake and C++ code.
13 years ago
# MAGNUM_BUILD_DEPRECATED - Defined if compiled with deprecated APIs
# included
# MAGNUM_BUILD_STATIC - Defined if compiled as static libraries
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
# MAGNUM_BUILD_MULTITHREADED - Defined if compiled in a way that allows
# having multiple thread-local Magnum contexts
Split the OpenGL layer out, pt 3: new MAGNUM_TARGET_GL variable. This will later enable conditional compilation of APIs that depend on the GL library (for example the Text library directly producing compiled meshes instead of just plain vertex data).
8 years ago
# MAGNUM_TARGET_GL - Defined if compiled with OpenGL interop
Initial support for ability to disable building of deprecated APIs. CMake option `BUILD_DEPRECATED`, enabled by default, exposed as `MAGNUM_BUILD_DEPRECATED` to users both in CMake and C++ code.
13 years ago
# 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
FindMagnum: fixed formatting with `cmake --help-module`.
13 years ago
# emulation on desktop OpenGL
Provide MAGNUM_TARGET_WEBGL also in CMake.
12 years ago
# MAGNUM_TARGET_WEBGL - Defined if compiled for WebGL
Added TARGET_HEADLESS option. Toggles between using CGL/GLX/WGL (requiring running graphical desktop environment) or EGL (without display attachment) for command-line utilities and GL tests. Also exposed to the user through MAGNUM_TARGET_HEADLESS CMake and preprocessor variables.
10 years ago
# MAGNUM_TARGET_HEADLESS - Defined if compiled for headless machines
Bootstrap Vulkan support.
8 years ago
# MAGNUM_TARGET_VK - Defined if compiled with Vulkan interop
Updated documentation on building and library finding.
13 years ago
#
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
# Additionally these variables are defined for internal usage:
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
#
Install and find debug libraries with "-d" suffix. Makes it possible to have both debug and release libraries installed. If both libraries are present when finding the package, proper version is used based on what configuration is used in depending project.
12 years ago
# 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
modules: added MAGNUM_BINARY_INSTALL_DIR variable to FindMagnum.cmake. Will be used in depending projects for e.g. installing DLLs on Windows.
12 years ago
# MAGNUM_BINARY_INSTALL_DIR - Binary installation directory
Install and find debug libraries with "-d" suffix. Makes it possible to have both debug and release libraries installed. If both libraries are present when finding the package, proper version is used based on what configuration is used in depending project.
12 years ago
# MAGNUM_LIBRARY_INSTALL_DIR - Library installation directory
modules: new internal MAGNUM_DATA_INSTALL_DIR. Will be used by examples etc. to install various auxiliary data.
11 years ago
# MAGNUM_DATA_INSTALL_DIR - Data installation directory
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
# MAGNUM_PLUGINS_[DEBUG|RELEASE]_BINARY_INSTALL_DIR - Plugin binary
Audio: added AbstractImporter plugin interface.
13 years ago
# installation directory
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
# 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
Install and find debug libraries with "-d" suffix. Makes it possible to have both debug and release libraries installed. If both libraries are present when finding the package, proper version is used based on what configuration is used in depending project.
12 years ago
# MAGNUM_INCLUDE_INSTALL_DIR - Header installation directory
# MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR - Plugin header installation directory
Installation commands in CMake, development PKGBUILD.
16 years ago
#
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Workflows without imported targets are deprecated and the following variables
# are included just for backwards compatibility and only if
# :variable:`MAGNUM_BUILD_DEPRECATED` is enabled:
#
Doc++
8 years ago
# MAGNUM_LIBRARIES - Expands to ``Magnum::Magnum`` target. Use
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# ``Magnum::Magnum`` target directly instead.
# MAGNUM_*_LIBRARIES - Expands to ``Magnum::*`` target. Use
# ``Magnum::*`` target directly instead.
# MAGNUM_APPLICATION_LIBRARIES / MAGNUM_WINDOWLESSAPPLICATION_LIBRARIES
# - Expands to ``Magnum::Application`` /
# ``Magnum::WindowlessApplication`` target. Use ``Magnum::Application`` /
# ``Magnum::WindowlessApplication`` target directly instead.
# MAGNUM_CONTEXT_LIBRARIES - Expands to ``Magnum::Context`` target. Use
# ``Magnum::Context`` target directly instead.
#
Installation commands in CMake, development PKGBUILD.
16 years ago
Relicensing to MIT/Expat license, part 4: CMake and documentation files. They didn't contain license header before, but I think adding it also there wouldn't do any harm. Documentation is also integral part of the codebase.
13 years ago
#
# This file is part of Magnum.
#
Updated copyright year.
8 years ago
# Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
Happy new year too.
12 years ago
# Vladimír Vondruš <mosra@centrum.cz>
Relicensing to MIT/Expat license, part 4: CMake and documentation files. They didn't contain license header before, but I think adding it also there wouldn't do any harm. Documentation is also integral part of the codebase.
13 years ago
#
# 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.
#
Split the Trade library out.
8 years ago
# 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})
Installation commands in CMake, development PKGBUILD.
16 years ago
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
# Root include dir
find_path(MAGNUM_INCLUDE_DIR
Making includes absolute, part 3: updated FindMagnum.cmake. If MAGNUM_BUILD_DEPRECATED is defined, it behaves the same as previously, although you may need to recreate your build dir.
12 years ago
NAMES Magnum/Magnum.h)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
mark_as_advanced(MAGNUM_INCLUDE_DIR)
Installation commands in CMake, development PKGBUILD.
16 years ago
CMake subproject support, part 3: ability to override configure.h location. Similarly as in Corrade, but this did not require any user-facing changes.
11 years ago
# Configuration file
find_file(_MAGNUM_CONFIGURE_FILE configure.h
HINTS ${MAGNUM_INCLUDE_DIR}/Magnum/)
modules: mark internal variable as such.
9 years ago
mark_as_advanced(_MAGNUM_CONFIGURE_FILE)
CMake subproject support, part 3: ability to override configure.h location. Similarly as in Corrade, but this did not require any user-facing changes.
11 years ago
modules: bail out with proper message if Magnum is not found. Currently it failed on "error when trying to open configure.h", which is NOT a helpful message at all. Now we check for existence of the include dir before trying to open the file, thus failing with proper "Could NOT find Magnum" message.
12 years ago
# 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
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
REQUIRED_VARS MAGNUM_INCLUDE_DIR _MAGNUM_CONFIGURE_FILE)
modules: bail out with proper message if Magnum is not found. Currently it failed on "error when trying to open configure.h", which is NOT a helpful message at all. Now we check for existence of the include dir before trying to open the file, thus failing with proper "Could NOT find Magnum" message.
12 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Read flags from configuration
CMake subproject support, part 3: ability to override configure.h location. Similarly as in Corrade, but this did not require any user-facing changes.
11 years ago
file(READ ${_MAGNUM_CONFIGURE_FILE} _magnumConfigure)
modules: simplified flag parsing in FindMagnum.cmake.
12 years ago
set(_magnumFlags
BUILD_DEPRECATED
BUILD_STATIC
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
BUILD_MULTITHREADED
Split the OpenGL layer out, pt 3: new MAGNUM_TARGET_GL variable. This will later enable conditional compilation of APIs that depend on the GL library (for example the Text library directly producing compiled meshes instead of just plain vertex data).
8 years ago
TARGET_GL
modules: simplified flag parsing in FindMagnum.cmake.
12 years ago
TARGET_GLES
TARGET_GLES2
TARGET_GLES3
TARGET_DESKTOP_GLES
Added TARGET_HEADLESS option. Toggles between using CGL/GLX/WGL (requiring running graphical desktop environment) or EGL (without display attachment) for command-line utilities and GL tests. Also exposed to the user through MAGNUM_TARGET_HEADLESS CMake and preprocessor variables.
10 years ago
TARGET_WEBGL
Bootstrap Vulkan support.
8 years ago
TARGET_HEADLESS
TARGET_VK)
modules: simplified flag parsing in FindMagnum.cmake.
12 years ago
foreach(_magnumFlag ${_magnumFlags})
string(FIND "${_magnumConfigure}" "#define MAGNUM_${_magnumFlag}" _magnum_${_magnumFlag})
if(NOT _magnum_${_magnumFlag} EQUAL -1)
set(MAGNUM_${_magnumFlag} 1)
endif()
endforeach()
Checking whether Magnum was build for OpenGL ES in FindMagnum.cmake.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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})
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
get_filename_component(_MAGNUM_PLUGINS_DIR_PREFIX ${MAGNUM_LIBRARY_DEBUG} PATH)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
set(_MAGNUM_PLUGINS_DIR_SUFFIX "-d")
endif()
elseif(MAGNUM_LIBRARY_DEBUG)
set(MAGNUM_LIBRARY ${MAGNUM_LIBRARY_DEBUG})
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
get_filename_component(_MAGNUM_PLUGINS_DIR_PREFIX ${MAGNUM_LIBRARY_DEBUG} PATH)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
set(_MAGNUM_PLUGINS_DIR_SUFFIX "-d")
elseif(MAGNUM_LIBRARY_RELEASE)
set(MAGNUM_LIBRARY ${MAGNUM_LIBRARY_RELEASE})
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
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)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
endif()
Checking whether Magnum was build for OpenGL ES in FindMagnum.cmake.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
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
Split the OpenGL layer out, pt 2: updated FindMagnum.cmake.
8 years ago
${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)
set_property(TARGET Magnum::Magnum APPEND PROPERTY
INTERFACE_INCLUDE_DIRECTORIES ${MAGNUM_INCLUDE_DIR}/MagnumExternal/OpenGL)
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Dependent libraries
set_property(TARGET Magnum::Magnum APPEND PROPERTY INTERFACE_LINK_LIBRARIES
Split the Trade library out.
8 years ago
Corrade::Utility)
modules: fix root library finding for superprojects. Will this never end?!
10 years ago
else()
set(MAGNUM_LIBRARY Magnum::Magnum)
Initial support for WebGL 2. The actual WebGL 2 distinction was done as a part of previous WebGL cleanup. It compiles, but is completely broken, as Emscripten has some missing bits to go through at least Context class creation.
11 years ago
endif()
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
# 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 Shapes Text
Bootstrap Vulkan support.
8 years ago
TextureTools Trade Vk
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
AndroidApplication GlfwApplication GlutApplication 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, Shaders and Shapes are used only for
# GL renderers
list(APPEND _MAGNUM_DebugTools_DEPENDENCIES MeshTools Primitives SceneGraph Shaders Shapes Trade GL)
endif()
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
set(_MAGNUM_MeshTools_DEPENDENCIES )
if(MAGNUM_TARGET_GL)
# Trade is used only in compile(), which needs GL as well
list(APPEND _MAGNUM_${_COMPONENT}_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)
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
endif()
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
endif()
set(_MAGNUM_Primitives_DEPENDENCIES Trade)
set(_MAGNUM_SceneGraph_DEPENDENCIES )
set(_MAGNUM_Shaders_DEPENDENCIES GL)
set(_MAGNUM_Shapes_DEPENDENCIES SceneGraph)
set(_MAGNUM_Text_DEPENDENCIES TextureTools GL)
set(_MAGNUM_TextureTools_DEPENDENCIES )
if(MAGNUM_TARGET_GL)
list(APPEND _MAGNUM_TextureTools_DEPENDENCIES GL)
endif()
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
set(_MAGNUM_Trade_DEPENDENCIES )
set(_MAGNUM_AndroidApplication_DEPENDENCIES GL)
Split the OpenGL layer out, pt 29: SDL2 and GLFW apps w/o GL.
8 years ago
set(_MAGNUM_GlfwApplication_DEPENDENCIES )
if(MAGNUM_TARGET_GL)
list(APPEND _MAGNUM_GlfwApplication_DEPENDENCIES GL)
endif()
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
set(_MAGNUM_GlutApplication_DEPENDENCIES GL)
set(_MAGNUM_GlxApplication_DEPENDENCIES GL)
Split the OpenGL layer out, pt 29: SDL2 and GLFW apps w/o GL.
8 years ago
set(_MAGNUM_Sdl2Application_DEPENDENCIES )
if(MAGNUM_TARGET_GL)
list(APPEND _MAGNUM_Sdl2Application_DEPENDENCIES GL)
endif()
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
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) # and below
set(_MAGNUM_MagnumFontConverter_DEPENDENCIES Trade TgaImageConverter) # and below
set(_MAGNUM_ObjImporter_DEPENDENCIES MeshTools) # and below
foreach(_component ${_MAGNUM_PLUGIN_COMPONENT_LIST})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
if(_component MATCHES ".+AudioImporter")
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
list(APPEND _MAGNUM_${_component}_DEPENDENCIES Audio)
Split the Trade library out.
8 years ago
elseif(_component MATCHES ".+(Importer|ImageConverter)")
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
list(APPEND _MAGNUM_${_component}_DEPENDENCIES Trade)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
elseif(_component MATCHES ".+(Font|FontConverter)")
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
list(APPEND _MAGNUM_${_component}_DEPENDENCIES Text TextureTools GL)
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
endif()
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
endforeach()
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
# Ensure that all inter-component dependencies are specified as well
set(_MAGNUM_ADDITIONAL_COMPONENTS )
foreach(_component ${Magnum_FIND_COMPONENTS})
modules: properly handle implicit required inter-module dependencies.
10 years ago
# Mark the dependencies as required if the component is also required
if(Magnum_FIND_REQUIRED_${_component})
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
foreach(_dependency ${_MAGNUM_${_component}_DEPENDENCIES})
modules: properly handle implicit required inter-module dependencies.
10 years ago
set(Magnum_FIND_REQUIRED_${_dependency} TRUE)
endforeach()
endif()
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
list(APPEND _MAGNUM_ADDITIONAL_COMPONENTS ${_MAGNUM_${_component}_DEPENDENCIES})
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
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)
Avoid linker errors with *WindowContext on mingw.
14 years ago
endif()
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
# 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()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
# Find all components
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
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()
Integrated plugins into build system and updated the documentation.
13 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Plugin components
if(_component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS})
add_library(Magnum::${_component} UNKNOWN IMPORTED)
Integrated plugins into build system and updated the documentation.
13 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# AudioImporter plugin specific name suffixes
if(_component MATCHES ".+AudioImporter$")
set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX audioimporters)
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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)
Install also debug plugins to different location. Following changes done in Corrade.
12 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Importer plugin specific name suffixes
elseif(_component MATCHES ".+Importer$")
set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX importers)
Integrated plugins into build system and updated the documentation.
13 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Font plugin specific name suffixes
elseif(_component MATCHES ".+Font$")
set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX fonts)
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# ImageConverter plugin specific name suffixes
elseif(_component MATCHES ".+ImageConverter$")
set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX imageconverters)
Platform: initial version of AndroidApplication. No input events yet.
12 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# FontConverter plugin specific name suffixes
elseif(_component MATCHES ".+FontConverter$")
set(_MAGNUM_${_COMPONENT}_PATH_SUFFIX fontconverters)
New library for OpenGL context creation using various toolkits. Currently there is only GLUT context, pulled from magnum-examples repository.
14 years ago
endif()
First version of SDL2 context.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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)
First version of SDL2 context.
14 years ago
endif()
Barebone X/EGL context.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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
modules: properly save CMAKE_FIND_LIBRARY_PREFIXES in FindMagnum.cmake. On Emscripten this was equal to ";somebogusprefix" (as per the toolchain), which got expanded into just somebogusprefix, losing the empty string. Saving it back to CMAKE_FIND_LIBRARY_PREFIXES would cause all subsequent find_library() calls to fail, because no library is named somebogusprefixMagnum*.bc. Thinking about this, the "somebogusprefix" was probably added "back then" as a workaround to CMake complaining that I'm messing up in the Find module. So I guess I can remove that as well.
9 years ago
set(_tmp_prefixes "${CMAKE_FIND_LIBRARY_PREFIXES}")
set(CMAKE_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES};")
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Try to find both debug and release version. Dynamic and static
# debug libraries are in different places.
find_library(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG ${_component}
PATH_SUFFIXES magnum-d/${_MAGNUM_${_COMPONENT}_PATH_SUFFIX})
find_library(MAGNUM_${_COMPONENT}_LIBRARY_DEBUG ${_component}-d
PATH_SUFFIXES magnum/${_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
modules: properly handle platforms with empty CMAKE_FIND_LIBRARY_PREFIXES. For example Windows with MSVC. The variable is set to empty list, which we need to preserve when setting it back. Otherwise CMake complains loudly.
10 years ago
set(CMAKE_FIND_LIBRARY_PREFIXES "${_tmp_prefixes}")
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
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})
modules: link EGL along with SDL if targetting non-desktop ES.
11 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
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})
Added GLX context.
14 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
endif()
modules: minor cleanup.
12 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Executables
if(_component MATCHES ${_MAGNUM_EXECUTABLE_COMPONENTS})
add_executable(Magnum::${_component} IMPORTED)
Added GLX context.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
find_program(MAGNUM_${_COMPONENT}_EXECUTABLE magnum-${_component})
mark_as_advanced(MAGNUM_${_COMPONENT}_EXECUTABLE)
Platform: added WindowlessWindowsEglApplication. Windowless application on Windows, OpenGL ES and EGL. Works with ANGLE.
11 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
if(MAGNUM_${_COMPONENT}_EXECUTABLE)
set_property(TARGET Magnum::${_component} PROPERTY
IMPORTED_LOCATION ${MAGNUM_${_COMPONENT}_EXECUTABLE})
Barebone X/EGL context.
14 years ago
endif()
endif()
New library for OpenGL context creation using various toolkits. Currently there is only GLUT context, pulled from magnum-examples repository.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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)
modules: Add GlfwApplication to FindMagnum.cmake Signed-off-by: Squareys <Squareys@googlemail.com>
10 years ago
# GLFW application dependencies
elseif(_component STREQUAL GlfwApplication)
find_package(GLFW)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES GLFW::GLFW)
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
# 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.
if(MAGNUM_TARGET_GL)
if(CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE AND (NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES))
set(OpenGL_GL_PREFERENCE GLVND)
find_package(OpenGL)
if(OPENGL_opengl_LIBRARY)
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()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# GLUT application dependencies
elseif(_component STREQUAL GlutApplication)
find_package(GLUT)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_INCLUDE_DIRECTORIES ${GLUT_INCLUDE_DIR})
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES ${GLUT_glut_LIBRARY})
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
# 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. I don't think GLUT works with EGL, so not
# handling that.
set(OpenGL_GL_PREFERENCE GLVND)
find_package(OpenGL)
if(OPENGL_opengl_LIBRARY)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES OpenGL::GLX)
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# SDL2 application dependencies
elseif(_component STREQUAL Sdl2Application)
find_package(SDL2)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES SDL2::SDL2)
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
# 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.
if(MAGNUM_TARGET_GL)
if(CORRADE_TARGET_UNIX AND NOT CORRADE_TARGET_APPLE AND (NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES))
set(OpenGL_GL_PREFERENCE GLVND)
find_package(OpenGL)
if(OPENGL_opengl_LIBRARY)
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()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# (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})
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
# 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.
set(OpenGL_GL_PREFERENCE GLVND)
find_package(OpenGL)
if(OPENGL_opengl_LIBRARY)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES OpenGL::GLX)
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Windowless CGL application has no additional dependencies
Platform: new WindowlessEglApplication. Uses just EGL and no other platform toolkit, meaning that the same code can be used on all platforms if the drivers support it. Should be working for OpenGL ES for most drivers, however desktop OpenGL is supported only on NVidia since version 355.
10 years ago
# Windowless EGL application dependencies
elseif(_component STREQUAL WindowlessEglApplication)
find_package(EGL)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES EGL::EGL)
Platform: added WindowlessIosApplication.
10 years ago
# 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})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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})
Platform: added publicly usable *Context libraries. They contain the same platform-specific stub as is used in *Application libraries to load GL function pointers.
12 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Context libraries
elseif(_component MATCHES ".+Context")
set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/Platform)
Split the OpenGL layer out, pt 14: Platform::{Context => GLContext}. Compatibility header and alias in the next commit so Git is able to recognize the file move.
8 years ago
set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES GLContext.h)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# GLX context dependencies
if(_component STREQUAL GlxContext)
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})
# EGL context dependencies
modules: minor cleanup.
10 years ago
elseif(_component STREQUAL EglContext)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
find_package(EGL)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES EGL::EGL)
Extension loading for OpenGL ES. Added EglContext, wired flextGLInit() to be called on all GLES platforms except for Emscripten and NaCl.
12 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# No additional dependencies for CGL context
# No additional dependencies for WGL context
Platform: added publicly usable *Context libraries. They contain the same platform-specific stub as is used in *Application libraries to load GL function pointers.
12 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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
Split the Trade library out.
8 years ago
INTERFACE_LINK_LIBRARIES ${OPENAL_LIBRARY} Corrade::PluginManager)
Moved Profiler and debug draw from Physics to new DebugTools library. Also cleaned up the code and split renderer creation from resource manager.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# No special setup for DebugTools library
modules: cleanup.
11 years ago
Split the OpenGL layer out, pt 2: updated FindMagnum.cmake.
8 years ago
# GL library
elseif(_component STREQUAL GL)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_INCLUDE_DIRECTORIES ${MAGNUM_INCLUDE_DIR}/MagnumExternal/OpenGL)
if(NOT MAGNUM_TARGET_GLES OR MAGNUM_TARGET_DESKTOP_GLES)
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
# 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.
set(OpenGL_GL_PREFERENCE GLVND)
Split the OpenGL layer out, pt 2: updated FindMagnum.cmake.
8 years ago
find_package(OpenGL REQUIRED)
CMake: prefer GLVND if on CMake 3.11. This *did not* make things simpler. At all. Ugh. Can I follow Apple and deprecate GL too?
8 years ago
if(OPENGL_opengl_LIBRARY)
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()
Split the OpenGL layer out, pt 2: updated FindMagnum.cmake.
8 years ago
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()
# Emscripten needs a special flag to use WebGL 2
if(CORRADE_TARGET_EMSCRIPTEN AND NOT MAGNUM_TARGET_GLES2)
# TODO: give me INTERFACE_LINK_OPTIONS or something, please
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -s USE_WEBGL2=1")
endif()
Made Test/AbstractOpenGLTester.h a public and documented API. There will be numerous additions to this one so it made sense to make it a static library instead of a header-only library. That also allows CMake users to just link to Magnum::OpenGLTester instead of going through the pain of a huge branching in order to find a correct windowless application just to run their tests. It could have been done even without the static library using a INTERFACE target, but that wouldn't work on CMake < 3.0 (which, unfortunately, quite a few people are still stuck with). Unfortunately it's already heavily used elsewhere so I had to go through the pain of deprecating the old implementation. The old implementation was header-only so it can't be just typedef'd to the new one as there would be linker failures. So the old header is just kept as it was, with only the macros reduced.
9 years ago
# MeshTools library
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
elseif(_component STREQUAL MeshTools)
set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES CompressIndices.h)
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
Made Test/AbstractOpenGLTester.h a public and documented API. There will be numerous additions to this one so it made sense to make it a static library instead of a header-only library. That also allows CMake users to just link to Magnum::OpenGLTester instead of going through the pain of a huge branching in order to find a correct windowless application just to run their tests. It could have been done even without the static library using a INTERFACE target, but that wouldn't work on CMake < 3.0 (which, unfortunately, quite a few people are still stuck with). Unfortunately it's already heavily used elsewhere so I had to go through the pain of deprecating the old implementation. The old implementation was header-only so it can't be just typedef'd to the new one as there would be linker failures. So the old header is just kept as it was, with only the macros reduced.
9 years ago
# OpenGLTester library
elseif(_component STREQUAL OpenGLTester)
Split the OpenGL layer out, pt 2: updated FindMagnum.cmake.
8 years ago
set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_SUFFIX Magnum/GL)
Made Test/AbstractOpenGLTester.h a public and documented API. There will be numerous additions to this one so it made sense to make it a static library instead of a header-only library. That also allows CMake users to just link to Magnum::OpenGLTester instead of going through the pain of a huge branching in order to find a correct windowless application just to run their tests. It could have been done even without the static library using a INTERFACE target, but that wouldn't work on CMake < 3.0 (which, unfortunately, quite a few people are still stuck with). Unfortunately it's already heavily used elsewhere so I had to go through the pain of deprecating the old implementation. The old implementation was header-only so it can't be just typedef'd to the new one as there would be linker failures. So the old header is just kept as it was, with only the macros reduced.
9 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Primitives library
elseif(_component STREQUAL Primitives)
set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES Cube.h)
Initial support for Text library.
14 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# No special setup for SceneGraph library
# No special setup for Shaders library
# No special setup for Shapes library
Split the Trade library out.
8 years ago
# Text library
elseif(_component STREQUAL Text)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES Corrade::PluginManager)
modules: cleanup.
11 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# TextureTools library
elseif(_component STREQUAL TextureTools)
set(_MAGNUM_${_COMPONENT}_INCLUDE_PATH_NAMES Atlas.h)
Split the Trade library out.
8 years ago
# Trade library
elseif(_component STREQUAL Trade)
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES Corrade::PluginManager)
Bootstrap Vulkan support.
8 years ago
# 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)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
endif()
New TextureTools library with joke implementation of atlas packer.
14 years ago
Integrated the Any* plugins to the buildsystem and docs.
8 years ago
# 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
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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()
modules: don't fail w/ confusing error if plugin include dir is not found. Introduced by accident when implementing automagic import of static plugins.
8 years ago
# Automatic import of static plugins on CMake >= 3.1. Skip in case the
# include dir was not found -- that'll fail later with a proper
# message.
if(_component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS} AND NOT CMAKE_VERSION VERSION_LESS 3.1 AND _MAGNUM_${_COMPONENT}_INCLUDE_DIR)
Automagic way of importing static plugins. Statically built plugins get imported automatically when using CMake 3.1 and newer. Otherwise simply #include a corresponding importStaticPlugin.cpp file.
8 years ago
# 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()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Link to core Magnum library, add inter-library dependencies
if(_component MATCHES ${_MAGNUM_LIBRARY_COMPONENTS} OR _component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS})
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES Magnum::Magnum)
modules: properly handle deep dependencies in FindMagnum. Previously, when requesting OpenGLTester, the script correctly found that it needs some Windowless*Application and a GL library and added them as dependencies to OpenGLTester. But it didn't handle the dependency of Windowless*Application on GL, which caused GL to be linked *before* Windowless*Application, causing linker to complain that Windowless*Application needs some more stuff from GL.
8 years ago
foreach(_dependency ${_MAGNUM_${_component}_DEPENDENCIES})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
set_property(TARGET Magnum::${_component} APPEND PROPERTY
INTERFACE_LINK_LIBRARIES Magnum::${_dependency})
endforeach()
endif()
New ObjImporter plugin.
12 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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()
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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})
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
else()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
unset(_MAGNUM_WINDOWLESSAPPLICATION_ALIAS)
modules: properly handle inter-project dependencies in FindMagnum.cmake. It's not needed to manually specify whole component dependency tree, also each MAGNUM_*_LIBRARIES and MAGNUM_*_INCLUDE_DIRS variable now lists all external and inter-project dependencies. For example, if the user requires DebugTools component, it automatically searches also for all the following components: MeshTools Primitives SceneGraph Shaders Shapes And MAGNUM_DEBUGTOOLS_LIBRARIES contains the following extensive list of libraries: MagnumDebugTools MagnumMeshTools MagnumPrimitives MagnumSceneGraph MagnumShaders MagnumShapes Magnum CorradePluginManager CorradeUtility libGL
11 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
elseif(_component MATCHES ".+Application")
if(NOT DEFINED _MAGNUM_APPLICATION_ALIAS)
set(_MAGNUM_APPLICATION_ALIAS Magnum::${_component})
else()
unset(_MAGNUM_APPLICATION_ALIAS)
FindMagnum: provide MAGNUM_APPLICATION_{LIBRARIES,INCLUDE_DIRS} aliases. Convenience aliases to variables related to one particular *Application component, defined if and only if exactly one *Application component is requested and found. Meant to be used to simplify porting when each platform uses different *Application library.
13 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
elseif(_component MATCHES ".+Context")
Split the OpenGL layer out, pt 27: CMake Magnum::{Context => GLContext}. No backwards compatibility provided, sorry.
8 years ago
if(NOT DEFINED _MAGNUM_GLCONTEXT_ALIAS)
set(_MAGNUM_GLCONTEXT_ALIAS Magnum::${_component})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
else()
Split the OpenGL layer out, pt 27: CMake Magnum::{Context => GLContext}. No backwards compatibility provided, sorry.
8 years ago
unset(_MAGNUM_GLCONTEXT_ALIAS)
Platform: added publicly usable *Context libraries. They contain the same platform-specific stub as is used in *Application libraries to load GL function pointers.
12 years ago
endif()
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
endif()
# Deprecated variables
if(MAGNUM_BUILD_DEPRECATED AND _component MATCHES ${_MAGNUM_LIBRARY_COMPONENTS} OR _component MATCHES ${_MAGNUM_PLUGIN_COMPONENTS})
set(MAGNUM_${_COMPONENT}_LIBRARIES Magnum::${_component})
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
endif()
endforeach()
modules: bail out with proper message if Magnum is not found. Currently it failed on "error when trying to open configure.h", which is NOT a helpful message at all. Now we check for existence of the include dir before trying to open the file, thus failing with proper "Could NOT find Magnum" message.
12 years ago
# Complete the check with also all components
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
include(FindPackageHandleStandardArgs)
Revert "Added lost parameter to FPHSA in FindMagnum.cmake." It shouldn't probably be there. This reverts commit 64b6c6d6b5985dc3ead455aedb23e23922cb4e90.
14 years ago
find_package_handle_standard_args(Magnum
modules: fix root library finding for superprojects. Will this never end?!
10 years ago
REQUIRED_VARS MAGNUM_INCLUDE_DIR MAGNUM_LIBRARY
Follow CMake coding guidelines in FindMagnum.cmake.
14 years ago
HANDLE_COMPONENTS)
Installation commands in CMake, development PKGBUILD.
16 years ago
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# 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)
modules: fix Application and Context aliases for superprojects. Oh well :(
10 years ago
add_library(Magnum::WindowlessApplication ALIAS ${_MAGNUM_WINDOWLESSAPPLICATION_ALIASED_TARGET})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
else()
add_library(Magnum::WindowlessApplication UNKNOWN IMPORTED)
get_target_property(_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_CONFIGURATIONS ${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS} IMPORTED_CONFIGURATIONS)
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)
set_target_properties(Magnum::WindowlessApplication PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES $<TARGET_PROPERTY:${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS},INTERFACE_INCLUDE_DIRECTORIES>
INTERFACE_COMPILE_DEFINITIONS $<TARGET_PROPERTY:${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS},INTERFACE_COMPILE_DEFINITIONS>
INTERFACE_COMPILE_OPTIONS $<TARGET_PROPERTY:${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS},INTERFACE_COMPILE_OPTIONS>
INTERFACE_LINK_LIBRARIES $<TARGET_PROPERTY:${_MAGNUM_WINDOWLESSAPPLICATION_ALIAS},INTERFACE_LINK_LIBRARIES>
modules: updated FindMagnum.cmake. It was not handling the case of both debug and release libraries for application and contexts properly.
10 years ago
IMPORTED_CONFIGURATIONS "${_MAGNUM_WINDOWLESSAPPLICATION_IMPORTED_CONFIGURATIONS}")
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
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()
if(MAGNUM_BUILD_DEPRECATED)
set(MAGNUM_WINDOWLESSAPPLICATION_LIBRARIES Magnum::WindowlessApplication)
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)
modules: fix Application and Context aliases for superprojects. Oh well :(
10 years ago
add_library(Magnum::Application ALIAS ${_MAGNUM_APPLICATION_ALIASED_TARGET})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
else()
add_library(Magnum::Application UNKNOWN IMPORTED)
get_target_property(_MAGNUM_APPLICATION_IMPORTED_CONFIGURATIONS ${_MAGNUM_APPLICATION_ALIAS} IMPORTED_CONFIGURATIONS)
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)
set_target_properties(Magnum::Application PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES $<TARGET_PROPERTY:${_MAGNUM_APPLICATION_ALIAS},INTERFACE_INCLUDE_DIRECTORIES>
INTERFACE_COMPILE_DEFINITIONS $<TARGET_PROPERTY:${_MAGNUM_APPLICATION_ALIAS},INTERFACE_COMPILE_DEFINITIONS>
INTERFACE_COMPILE_OPTIONS $<TARGET_PROPERTY:${_MAGNUM_APPLICATION_ALIAS},INTERFACE_COMPILE_OPTIONS>
INTERFACE_LINK_LIBRARIES $<TARGET_PROPERTY:${_MAGNUM_APPLICATION_ALIAS},INTERFACE_LINK_LIBRARIES>
modules: updated FindMagnum.cmake. It was not handling the case of both debug and release libraries for application and contexts properly.
10 years ago
IMPORTED_CONFIGURATIONS "${_MAGNUM_APPLICATION_IMPORTED_CONFIGURATIONS}")
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
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()
if(MAGNUM_BUILD_DEPRECATED)
set(MAGNUM_APPLICATION_LIBRARIES Magnum::Application)
endif()
# Prevent creating the alias again
unset(_MAGNUM_APPLICATION_ALIAS)
endif()
Split the OpenGL layer out, pt 27: CMake Magnum::{Context => GLContext}. No backwards compatibility provided, sorry.
8 years ago
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})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
else()
Split the OpenGL layer out, pt 27: CMake Magnum::{Context => GLContext}. No backwards compatibility provided, sorry.
8 years ago
add_library(Magnum::GLContext UNKNOWN IMPORTED)
get_target_property(_MAGNUM_GLCONTEXT_IMPORTED_CONFIGURATIONS ${_MAGNUM_GLCONTEXT_ALIAS} IMPORTED_CONFIGURATIONS)
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)
set_target_properties(Magnum::GLContext PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES $<TARGET_PROPERTY:${_MAGNUM_GLCONTEXT_ALIAS},INTERFACE_INCLUDE_DIRECTORIES>
INTERFACE_COMPILE_DEFINITIONS $<TARGET_PROPERTY:${_MAGNUM_GLCONTEXT_ALIAS},INTERFACE_COMPILE_DEFINITIONS>
INTERFACE_COMPILE_OPTIONS $<TARGET_PROPERTY:${_MAGNUM_GLCONTEXT_ALIAS},INTERFACE_COMPILE_OPTIONS>
INTERFACE_LINK_LIBRARIES $<TARGET_PROPERTY:${_MAGNUM_GLCONTEXT_ALIAS},INTERFACE_LINK_LIBRARIES>
IMPORTED_CONFIGURATIONS "${_MAGNUM_GLCONTEXT_IMPORTED_CONFIGURATIONS}")
if(_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_RELEASE)
set_target_properties(Magnum::GLContext PROPERTIES
IMPORTED_LOCATION_RELEASE ${_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_RELEASE})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
endif()
Split the OpenGL layer out, pt 27: CMake Magnum::{Context => GLContext}. No backwards compatibility provided, sorry.
8 years ago
if(_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_DEBUG)
set_target_properties(Magnum::GLContext PROPERTIES
IMPORTED_LOCATION_DEBUG ${_MAGNUM_GLCONTEXT_IMPORTED_LOCATION_DEBUG})
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
endif()
endif()
# Prevent creating the alias again
Split the OpenGL layer out, pt 27: CMake Magnum::{Context => GLContext}. No backwards compatibility provided, sorry.
8 years ago
unset(_MAGNUM_GLCONTEXT_ALIAS)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
endif()
modules: added MAGNUM_DEPLOY_PREFIX cache variable. Like CMAKE_INSTALL_PREFIX, but for deploying final executables (such as Emscripten apps).
9 years ago
# Installation and deploy dirs
modules: give MAGNUM_DEPLOY_PREFIX a saner default. Otherwise, when used as-is in the install() command, CMake complains that DESTINATION can't be empty.
9 years ago
set(MAGNUM_DEPLOY_PREFIX "."
modules: added MAGNUM_DEPLOY_PREFIX cache variable. Like CMAKE_INSTALL_PREFIX, but for deploying final executables (such as Emscripten apps).
9 years ago
CACHE STRING "Prefix where to put final application executables")
CMake: make it possible to override include install location. Needed so Gradle CMake on Android "just works".
8 years ago
set(MAGNUM_INCLUDE_INSTALL_PREFIX "."
CACHE STRING "Prefix where to put platform-independent include and other files")
modules: added MAGNUM_DEPLOY_PREFIX cache variable. Like CMAKE_INSTALL_PREFIX, but for deploying final executables (such as Emscripten apps).
9 years ago
modules: updated FindCorrade.cmake, adapted to Corrade changes.
12 years ago
include(${CORRADE_LIB_SUFFIX_MODULE})
CMake: use relative install paths. CMAKE_INSTALL_PREFIX is prepended automatically for relative paths.
9 years ago
set(MAGNUM_BINARY_INSTALL_DIR bin)
set(MAGNUM_LIBRARY_INSTALL_DIR lib${LIB_SUFFIX})
CMake: make it possible to override include install location. Needed so Gradle CMake on Android "just works".
8 years ago
set(MAGNUM_DATA_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/share/magnum)
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
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)
CMake: make it possible to override include install location. Needed so Gradle CMake on Android "just works".
8 years ago
set(MAGNUM_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/include/Magnum)
set(MAGNUM_PLUGINS_INCLUDE_INSTALL_DIR ${MAGNUM_INCLUDE_INSTALL_PREFIX}/include/MagnumPlugins)
Standards-compilant FindMangum.cmake module. It is now required to specify which modules to find, as only these modules will be searched for.
14 years ago
CMake: make MAGNUM_PLUGINS[_DEBUG|_RELEASE|]_DIR a STRING cache entry. The PATH entry is always converted to absolute, making it impossible to specify a relative path (e.g. relative to executable location).
10 years ago
# 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.
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
set(MAGNUM_PLUGINS_DEBUG_DIR ${_MAGNUM_PLUGINS_DIR_PREFIX}/magnum-d
CMake: make MAGNUM_PLUGINS[_DEBUG|_RELEASE|]_DIR a STRING cache entry. The PATH entry is always converted to absolute, making it impossible to specify a relative path (e.g. relative to executable location).
10 years ago
CACHE STRING "Base directory where to look for Magnum plugins for debug builds")
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
set(MAGNUM_PLUGINS_RELEASE_DIR ${_MAGNUM_PLUGINS_DIR_PREFIX}/magnum
CMake: make MAGNUM_PLUGINS[_DEBUG|_RELEASE|]_DIR a STRING cache entry. The PATH entry is always converted to absolute, making it impossible to specify a relative path (e.g. relative to executable location).
10 years ago
CACHE STRING "Base directory where to look for Magnum plugins for release builds")
CMake: install plugin binary / library to different places. In order to have it correct on Windows where DLLs should be next to executables.
10 years ago
set(MAGNUM_PLUGINS_DIR ${_MAGNUM_PLUGINS_DIR_PREFIX}/magnum${_MAGNUM_PLUGINS_DIR_SUFFIX}
CMake: make MAGNUM_PLUGINS[_DEBUG|_RELEASE|]_DIR a STRING cache entry. The PATH entry is always converted to absolute, making it impossible to specify a relative path (e.g. relative to executable location).
10 years ago
CACHE STRING "Base directory where to look for Magnum plugins")
FindMagnum.cmake: allow user to override plugin directories. Useful when deploying on Windows.
13 years ago
Text: turned AbstractFont into plugin interface.
13 years ago
# Plugin directories
FindMagnum.cmake: allow user to override plugin directories. Useful when deploying on Windows.
13 years ago
set(MAGNUM_PLUGINS_FONT_DIR ${MAGNUM_PLUGINS_DIR}/fonts)
modules: expose separate plugin directories for debug and release builds.
12 years ago
set(MAGNUM_PLUGINS_FONT_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/fonts)
set(MAGNUM_PLUGINS_FONT_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/fonts)
FindMagnum.cmake: allow user to override plugin directories. Useful when deploying on Windows.
13 years ago
set(MAGNUM_PLUGINS_FONTCONVERTER_DIR ${MAGNUM_PLUGINS_DIR}/fontconverters)
modules: expose separate plugin directories for debug and release builds.
12 years ago
set(MAGNUM_PLUGINS_FONTCONVERTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/fontconverters)
set(MAGNUM_PLUGINS_FONTCONVERTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/fontconverters)
FindMagnum.cmake: allow user to override plugin directories. Useful when deploying on Windows.
13 years ago
set(MAGNUM_PLUGINS_IMAGECONVERTER_DIR ${MAGNUM_PLUGINS_DIR}/imageconverters)
modules: expose separate plugin directories for debug and release builds.
12 years ago
set(MAGNUM_PLUGINS_IMAGECONVERTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/imageconverters)
set(MAGNUM_PLUGINS_IMAGECONVERTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/imageconverters)
FindMagnum.cmake: allow user to override plugin directories. Useful when deploying on Windows.
13 years ago
set(MAGNUM_PLUGINS_IMPORTER_DIR ${MAGNUM_PLUGINS_DIR}/importers)
modules: expose separate plugin directories for debug and release builds.
12 years ago
set(MAGNUM_PLUGINS_IMPORTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/importers)
set(MAGNUM_PLUGINS_IMPORTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/importers)
Audio: added AbstractImporter plugin interface.
13 years ago
set(MAGNUM_PLUGINS_AUDIOIMPORTER_DIR ${MAGNUM_PLUGINS_DIR}/audioimporters)
modules: expose separate plugin directories for debug and release builds.
12 years ago
set(MAGNUM_PLUGINS_AUDIOIMPORTER_DEBUG_DIR ${MAGNUM_PLUGINS_DEBUG_DIR}/audioimporters)
set(MAGNUM_PLUGINS_AUDIOIMPORTER_RELEASE_DIR ${MAGNUM_PLUGINS_RELEASE_DIR}/audioimporters)
Modern CMake usage: reworked to use target-specific properties. As with Corrade, this is not exactly backwards compatible, but for common use case without OBJECT libraries this should not be a problem. In any case, recreate the build dir and update your copy of all Find*.cmake modules to avoid weird things happening. User-facing changes: * Documentation of all Find*.cmake modules converted to reStructuredText to follow official CMake guidelines. * The newfangled way to use the libraries is to link to Magnum::Shaders instead of adding ${MAGNUM_SHADERS_INCLUDE_DIRS} to include path and linking to ${MAGNUM_SHADERS_LIBRARIES}. * The old ${MAGNUM_*_LIBRARIES} are deprecated and now just expand to Magnum::* target. Use the target directly. These are also enabled only when building with MAGNUM_BUILD_DEPRECATED. * The old ${MAGNUM_*_INCLUDE_DIRS} are removed as the Magnum::* targets cover these too. Internal changes: * Global state such as include_directories() was replaced with target-specific settings.
10 years ago
# Deprecated variables
if(MAGNUM_BUILD_DEPRECATED)
set(MAGNUM_LIBRARIES Magnum::Magnum)
endif()